236 lines
8.1 KiB
Rust
236 lines
8.1 KiB
Rust
use std::time::{Duration, SystemTime};
|
|
|
|
use crate::event::PacketMeta;
|
|
|
|
/// Largest lag behind the paired userspace receive sample that a kernel
|
|
/// receive timestamp may show and still be used as a measurement endpoint.
|
|
///
|
|
/// This is a sanity guard, not an expected kernel-to-userspace wakeup
|
|
/// latency: ordinary wakeup latency is orders of magnitude smaller. A kernel
|
|
/// timestamp this far behind the userspace sample most likely reflects a
|
|
/// realtime clock discontinuity or otherwise unusable metadata, and falling
|
|
/// back is preferable to injecting a bad cross-host timing sample.
|
|
const MAX_KERNEL_RX_LAG: Duration = Duration::from_secs(1);
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
|
pub(crate) struct ReceiveMeta {
|
|
pub(crate) traffic_class: Option<u8>,
|
|
pub(crate) kernel_rx_timestamp: Option<SystemTime>,
|
|
}
|
|
|
|
impl ReceiveMeta {
|
|
/// Receive wall-clock endpoint to use for downstream one-way delay.
|
|
///
|
|
/// Prefers an observed kernel receive timestamp, which is sampled earlier
|
|
/// than the userspace receive instant and therefore excludes socket wakeup
|
|
/// latency from the measured server-to-client delay. The kernel value is
|
|
/// only used when it is plausible for the datagram that produced
|
|
/// `userspace_wall`: it cannot be later than the userspace sample that
|
|
/// observed the datagram, and it may not lag it by more than
|
|
/// [`MAX_KERNEL_RX_LAG`]. Anything else falls back to `userspace_wall`.
|
|
///
|
|
/// Rejecting a kernel timestamp here never discards it as observed
|
|
/// metadata: [`PacketMeta::kernel_rx_timestamp`] still reports the raw
|
|
/// value.
|
|
pub(crate) fn preferred_receive_wall(&self, userspace_wall: SystemTime) -> SystemTime {
|
|
let Some(kernel_wall) = self.kernel_rx_timestamp else {
|
|
return userspace_wall;
|
|
};
|
|
// `duration_since` fails exactly when the kernel timestamp is later
|
|
// than the userspace sample, which cannot happen for a datagram that
|
|
// sample observed.
|
|
match userspace_wall.duration_since(kernel_wall) {
|
|
Ok(lag) if lag <= MAX_KERNEL_RX_LAG => kernel_wall,
|
|
_ => userspace_wall,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<ReceiveMeta> for PacketMeta {
|
|
fn from(meta: ReceiveMeta) -> Self {
|
|
Self {
|
|
traffic_class: meta.traffic_class,
|
|
dscp: meta.traffic_class.map(|traffic_class| traffic_class >> 2),
|
|
ecn: meta.traffic_class.map(|traffic_class| traffic_class & 0b11),
|
|
kernel_rx_timestamp: meta.kernel_rx_timestamp,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::time::{Duration, SystemTime};
|
|
|
|
use super::{ReceiveMeta, MAX_KERNEL_RX_LAG};
|
|
use crate::event::PacketMeta;
|
|
|
|
fn userspace_wall() -> SystemTime {
|
|
SystemTime::UNIX_EPOCH + Duration::from_secs(1_700_000_000)
|
|
}
|
|
|
|
fn meta_with_kernel_rx(kernel_rx_timestamp: SystemTime) -> ReceiveMeta {
|
|
ReceiveMeta {
|
|
traffic_class: None,
|
|
kernel_rx_timestamp: Some(kernel_rx_timestamp),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn preferred_receive_wall_without_kernel_timestamp_uses_userspace_sample() {
|
|
let userspace = userspace_wall();
|
|
|
|
assert_eq!(
|
|
ReceiveMeta::default().preferred_receive_wall(userspace),
|
|
userspace
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn preferred_receive_wall_uses_plausible_earlier_kernel_timestamp() {
|
|
let userspace = userspace_wall();
|
|
let kernel = userspace - Duration::from_micros(80);
|
|
|
|
assert_eq!(
|
|
meta_with_kernel_rx(kernel).preferred_receive_wall(userspace),
|
|
kernel
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn preferred_receive_wall_accepts_kernel_timestamp_equal_to_userspace_sample() {
|
|
let userspace = userspace_wall();
|
|
|
|
assert_eq!(
|
|
meta_with_kernel_rx(userspace).preferred_receive_wall(userspace),
|
|
userspace
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn preferred_receive_wall_rejects_kernel_timestamp_later_than_userspace_sample() {
|
|
let userspace = userspace_wall();
|
|
let kernel = userspace + Duration::from_nanos(1);
|
|
|
|
assert_eq!(
|
|
meta_with_kernel_rx(kernel).preferred_receive_wall(userspace),
|
|
userspace
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn preferred_receive_wall_accepts_kernel_timestamp_exactly_at_the_lag_bound() {
|
|
// The bound is inclusive: a lag of exactly MAX_KERNEL_RX_LAG is
|
|
// still accepted, one nanosecond more is not.
|
|
let userspace = userspace_wall();
|
|
let at_bound = userspace - MAX_KERNEL_RX_LAG;
|
|
let past_bound = userspace - MAX_KERNEL_RX_LAG - Duration::from_nanos(1);
|
|
|
|
assert_eq!(
|
|
meta_with_kernel_rx(at_bound).preferred_receive_wall(userspace),
|
|
at_bound
|
|
);
|
|
assert_eq!(
|
|
meta_with_kernel_rx(past_bound).preferred_receive_wall(userspace),
|
|
userspace
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn preferred_receive_wall_rejects_implausibly_old_kernel_timestamp() {
|
|
let userspace = userspace_wall();
|
|
let kernel = SystemTime::UNIX_EPOCH;
|
|
|
|
assert_eq!(
|
|
meta_with_kernel_rx(kernel).preferred_receive_wall(userspace),
|
|
userspace
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn preferred_receive_wall_handles_extreme_timestamps_without_panicking() {
|
|
let userspace = userspace_wall();
|
|
let far_future = SystemTime::UNIX_EPOCH + Duration::from_secs(u64::from(u32::MAX)) * 4;
|
|
let before_epoch = SystemTime::UNIX_EPOCH - Duration::from_secs(u64::from(u32::MAX));
|
|
|
|
assert_eq!(
|
|
meta_with_kernel_rx(far_future).preferred_receive_wall(userspace),
|
|
userspace
|
|
);
|
|
assert_eq!(
|
|
meta_with_kernel_rx(before_epoch).preferred_receive_wall(userspace),
|
|
userspace
|
|
);
|
|
assert_eq!(
|
|
ReceiveMeta::default().preferred_receive_wall(before_epoch),
|
|
before_epoch
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn metadata_preserves_kernel_timestamp_rejected_for_measurement() {
|
|
let userspace = userspace_wall();
|
|
let rejected = userspace + Duration::from_secs(30);
|
|
let meta = meta_with_kernel_rx(rejected);
|
|
|
|
assert_eq!(meta.preferred_receive_wall(userspace), userspace);
|
|
assert_eq!(
|
|
PacketMeta::from(meta).kernel_rx_timestamp,
|
|
Some(rejected),
|
|
"observed metadata must survive rejection as a measurement endpoint"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn metadata_observed_traffic_class_zero_preserves_observed_zero() {
|
|
let packet_meta = PacketMeta::from(ReceiveMeta {
|
|
traffic_class: Some(0),
|
|
kernel_rx_timestamp: None,
|
|
});
|
|
|
|
assert_eq!(packet_meta.traffic_class, Some(0));
|
|
assert_eq!(packet_meta.dscp, Some(0));
|
|
assert_eq!(packet_meta.ecn, Some(0));
|
|
assert_eq!(packet_meta.kernel_rx_timestamp, None);
|
|
}
|
|
|
|
#[test]
|
|
fn metadata_observed_traffic_class_derives_dscp_and_ecn() {
|
|
let packet_meta = PacketMeta::from(ReceiveMeta {
|
|
traffic_class: Some(184),
|
|
kernel_rx_timestamp: None,
|
|
});
|
|
|
|
assert_eq!(packet_meta.traffic_class, Some(184));
|
|
assert_eq!(packet_meta.dscp, Some(46));
|
|
assert_eq!(packet_meta.ecn, Some(0));
|
|
assert_eq!(packet_meta.kernel_rx_timestamp, None);
|
|
|
|
let packet_meta = PacketMeta::from(ReceiveMeta {
|
|
traffic_class: Some(186),
|
|
kernel_rx_timestamp: None,
|
|
});
|
|
|
|
assert_eq!(packet_meta.traffic_class, Some(186));
|
|
assert_eq!(packet_meta.dscp, Some(46));
|
|
assert_eq!(packet_meta.ecn, Some(2));
|
|
assert_eq!(packet_meta.kernel_rx_timestamp, None);
|
|
}
|
|
|
|
#[test]
|
|
fn metadata_mapping_preserves_none_vs_observed_zero() {
|
|
let unavailable = PacketMeta::from(ReceiveMeta::default());
|
|
let observed_zero = PacketMeta::from(ReceiveMeta {
|
|
traffic_class: Some(0),
|
|
kernel_rx_timestamp: None,
|
|
});
|
|
|
|
assert_eq!(unavailable.traffic_class, None);
|
|
assert_eq!(unavailable.dscp, None);
|
|
assert_eq!(unavailable.ecn, None);
|
|
|
|
assert_eq!(observed_zero.traffic_class, Some(0));
|
|
assert_eq!(observed_zero.dscp, Some(0));
|
|
assert_eq!(observed_zero.ecn, Some(0));
|
|
}
|
|
}
|