use std::sync::atomic::{fence, Ordering};
use std::sync::Arc;
use crate::copy;
use crate::error::{Error, Result};
use crate::layout::{frame_size, FRAME_HEADER, PAD};
use crate::mapping::Mapping;
pub struct Consumer {
map: Arc<Mapping>,
local: u64,
cached_published: u64,
overrun: bool,
}
impl Consumer {
pub(crate) fn new(map: Arc<Mapping>) -> Self {
let head = map.published().load(Ordering::Acquire);
Self {
map,
local: head,
cached_published: head,
overrun: false,
}
}
pub fn position(&self) -> u64 {
self.local
}
pub fn is_overrun(&self) -> bool {
self.overrun
}
pub fn resync(&mut self) -> u64 {
let head = self.map.published().load(Ordering::Acquire);
let skipped = head.saturating_sub(self.local);
self.local = head;
self.cached_published = head;
self.overrun = false;
skipped
}
pub fn try_read(&mut self, out: &mut [u8]) -> Result<Option<usize>> {
if self.overrun {
return Err(self.overrun_error());
}
loop {
if self.local == self.cached_published {
self.cached_published = self.map.published().load(Ordering::Acquire);
if self.local == self.cached_published {
return Ok(None);
}
}
let cap = self.map.capacity();
let mask = self.map.mask();
let base = self.map.buffer_ptr();
let start = self.local;
let idx = (start & mask) as usize;
let reserved = self.map.reserved().load(Ordering::Acquire);
if reserved.wrapping_sub(start) > cap {
return Err(self.mark_overrun(reserved));
}
let header = unsafe { copy::read_word(base.add(idx)) };
if header == PAD {
self.local = (start | mask) + 1;
continue;
}
let len = header as usize;
if len > crate::layout::max_payload(cap) {
return Err(self.mark_overrun(reserved));
}
let size = frame_size(len);
if size > cap - idx as u64 {
return Err(self.mark_overrun(reserved));
}
if len > out.len() {
return Err(Error::BufferTooSmall {
needed: len,
provided: out.len(),
});
}
unsafe { copy::read(&mut out[..len], base.add(idx + FRAME_HEADER)) };
fence(Ordering::Acquire);
let reserved = self.map.reserved().load(Ordering::Acquire);
if reserved.wrapping_sub(start) > cap {
return Err(self.mark_overrun(reserved));
}
self.local = start + size;
return Ok(Some(len));
}
}
fn mark_overrun(&mut self, reserved: u64) -> Error {
self.overrun = true;
Error::Overrun {
behind: reserved.wrapping_sub(self.local),
}
}
fn overrun_error(&self) -> Error {
Error::Overrun {
behind: self
.map
.reserved()
.load(Ordering::Acquire)
.wrapping_sub(self.local),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::layout::{FRAME_HEADER, PAD};
const CAP: u64 = 4096;
fn crafted(published: u64) -> Arc<Mapping> {
let map = Mapping::anon(CAP).unwrap();
map.published().store(published, Ordering::Release);
map.reserved().store(published, Ordering::Release);
Arc::new(map)
}
fn publish(map: &Mapping, to: u64) {
map.reserved().store(to, Ordering::Release);
map.published().store(to, Ordering::Release);
}
#[test]
fn an_absurd_length_is_refused_before_it_is_arithmetic() {
let map = crafted(0);
let mut consumer = Consumer::new(Arc::clone(&map));
map.poke_ring(0, u64::MAX - 1);
publish(&map, 16);
let mut buf = [0u8; 64];
assert!(matches!(
consumer.try_read(&mut buf),
Err(Error::Overrun { .. })
));
}
#[test]
fn a_frame_running_past_the_ring_end_is_refused() {
let map = crafted(CAP - 8);
let mut consumer = Consumer::new(Arc::clone(&map));
map.poke_ring((CAP - 8) as usize, 1);
publish(&map, CAP + 8);
let mut buf = [0u8; 64];
assert!(matches!(
consumer.try_read(&mut buf),
Err(Error::Overrun { .. })
));
}
#[test]
fn a_length_beyond_the_maximum_payload_is_refused() {
let map = crafted(0);
let mut consumer = Consumer::new(Arc::clone(&map));
map.poke_ring(0, crate::layout::max_payload(CAP) as u64 + 1);
publish(&map, CAP / 2);
let mut buf = [0u8; 4096];
assert!(matches!(
consumer.try_read(&mut buf),
Err(Error::Overrun { .. })
));
}
#[test]
fn a_pad_word_at_the_end_of_the_ring_wraps_without_reading_past_it() {
let map = crafted(CAP - 8);
let mut consumer = Consumer::new(Arc::clone(&map));
map.poke_ring((CAP - 8) as usize, PAD);
map.poke_ring(0, 0);
publish(&map, CAP + FRAME_HEADER as u64);
let mut buf = [0u8; 64];
assert_eq!(consumer.try_read(&mut buf).unwrap(), Some(0));
}
#[test]
fn a_well_formed_frame_is_still_accepted() {
let map = crafted(0);
let mut consumer = Consumer::new(Arc::clone(&map));
map.poke_ring(0, 8);
map.poke_ring(FRAME_HEADER, u64::from_ne_bytes(*b"abcdefgh"));
publish(&map, 16);
let mut buf = [0u8; 64];
assert_eq!(consumer.try_read(&mut buf).unwrap(), Some(8));
assert_eq!(&buf[..8], b"abcdefgh");
}
}