2017-07-27 21:51:02 +08:00
|
|
|
use {Error, Result};
|
2017-03-07 18:56:48 +08:00
|
|
|
use super::{DeviceLimits, Device};
|
2016-12-31 09:04:39 +08:00
|
|
|
|
|
|
|
// We use our own RNG to stay compatible with #![no_std].
|
|
|
|
// The use of the RNG below has a slight bias, but it doesn't matter.
|
|
|
|
fn xorshift32(state: &mut u32) -> u32 {
|
|
|
|
let mut x = *state;
|
|
|
|
x ^= x << 13;
|
|
|
|
x ^= x >> 17;
|
|
|
|
x ^= x << 5;
|
|
|
|
*state = x;
|
|
|
|
x
|
|
|
|
}
|
|
|
|
|
|
|
|
// This could be fixed once associated consts are stable.
|
|
|
|
const MTU: usize = 1536;
|
|
|
|
|
2017-05-29 18:53:30 +08:00
|
|
|
#[derive(Debug, Clone, Copy, Default)]
|
2016-12-31 09:04:39 +08:00
|
|
|
struct Config {
|
|
|
|
corrupt_pct: u8,
|
|
|
|
drop_pct: u8,
|
2017-05-29 18:53:30 +08:00
|
|
|
reorder_pct: u8,
|
|
|
|
max_size: usize,
|
|
|
|
max_tx_rate: u64,
|
|
|
|
max_rx_rate: u64,
|
2017-07-23 23:10:57 +08:00
|
|
|
interval: u64,
|
2017-05-29 18:53:30 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
|
|
struct State {
|
|
|
|
rng_seed: u32,
|
2017-07-23 23:10:57 +08:00
|
|
|
refilled_at: u64,
|
2017-05-29 18:53:30 +08:00
|
|
|
tx_bucket: u64,
|
|
|
|
rx_bucket: u64,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl State {
|
|
|
|
fn maybe(&mut self, pct: u8) -> bool {
|
|
|
|
xorshift32(&mut self.rng_seed) % 100 < pct as u32
|
|
|
|
}
|
|
|
|
|
|
|
|
fn corrupt<T: AsMut<[u8]>>(&mut self, mut buffer: T) {
|
|
|
|
let mut buffer = buffer.as_mut();
|
|
|
|
// We introduce a single bitflip, as the most likely, and the hardest to detect, error.
|
|
|
|
let index = (xorshift32(&mut self.rng_seed) as usize) % buffer.len();
|
|
|
|
let bit = 1 << (xorshift32(&mut self.rng_seed) % 8) as u8;
|
|
|
|
buffer[index] ^= bit;
|
|
|
|
}
|
|
|
|
|
2017-07-23 23:10:57 +08:00
|
|
|
fn refill(&mut self, config: &Config, timestamp: u64) {
|
|
|
|
if self.refilled_at - timestamp > config.interval {
|
2017-05-29 18:53:30 +08:00
|
|
|
self.tx_bucket = config.max_tx_rate;
|
|
|
|
self.rx_bucket = config.max_rx_rate;
|
2017-07-23 23:10:57 +08:00
|
|
|
self.refilled_at = timestamp;
|
2017-05-29 18:53:30 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-23 23:10:57 +08:00
|
|
|
fn maybe_transmit(&mut self, config: &Config, timestamp: u64) -> bool {
|
2017-05-29 18:53:30 +08:00
|
|
|
if config.max_tx_rate == 0 { return true }
|
|
|
|
|
2017-07-23 23:10:57 +08:00
|
|
|
self.refill(config, timestamp);
|
2017-05-29 18:53:30 +08:00
|
|
|
if self.tx_bucket > 0 {
|
|
|
|
self.tx_bucket -= 1;
|
|
|
|
true
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-23 23:10:57 +08:00
|
|
|
fn maybe_receive(&mut self, config: &Config, timestamp: u64) -> bool {
|
2017-05-29 18:53:30 +08:00
|
|
|
if config.max_rx_rate == 0 { return true }
|
|
|
|
|
2017-07-23 23:10:57 +08:00
|
|
|
self.refill(config, timestamp);
|
2017-05-29 18:53:30 +08:00
|
|
|
if self.rx_bucket > 0 {
|
|
|
|
self.rx_bucket -= 1;
|
|
|
|
true
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// A fault injector device.
|
|
|
|
///
|
2017-05-29 18:53:30 +08:00
|
|
|
/// A fault injector is a device that alters packets traversing through it to simulate
|
|
|
|
/// adverse network conditions (such as random packet loss or corruption), or software
|
|
|
|
/// or hardware limitations (such as a limited number or size of usable network buffers).
|
2016-12-31 09:04:39 +08:00
|
|
|
#[derive(Debug)]
|
2017-07-23 18:15:56 +08:00
|
|
|
pub struct FaultInjector<D: Device> {
|
2017-07-23 18:20:05 +08:00
|
|
|
inner: D,
|
2017-05-29 18:53:30 +08:00
|
|
|
state: State,
|
2016-12-31 09:04:39 +08:00
|
|
|
config: Config
|
|
|
|
}
|
|
|
|
|
2017-07-23 18:15:56 +08:00
|
|
|
impl<D: Device> FaultInjector<D> {
|
2017-05-29 18:53:30 +08:00
|
|
|
/// Create a fault injector device, using the given random number generator seed.
|
2017-07-23 18:20:05 +08:00
|
|
|
pub fn new(inner: D, seed: u32) -> FaultInjector<D> {
|
2017-05-29 19:04:49 +08:00
|
|
|
let state = State {
|
|
|
|
rng_seed: seed,
|
2017-07-23 23:10:57 +08:00
|
|
|
refilled_at: 0,
|
2017-05-29 19:04:49 +08:00
|
|
|
tx_bucket: 0,
|
|
|
|
rx_bucket: 0,
|
|
|
|
};
|
2016-12-31 09:04:39 +08:00
|
|
|
FaultInjector {
|
2017-07-23 18:20:05 +08:00
|
|
|
inner: inner,
|
2017-05-29 19:04:49 +08:00
|
|
|
state: state,
|
2017-05-29 18:53:30 +08:00
|
|
|
config: Config::default()
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-29 18:53:30 +08:00
|
|
|
/// Return the underlying device, consuming the fault injector.
|
2017-07-23 18:20:05 +08:00
|
|
|
pub fn into_inner(self) -> D {
|
|
|
|
self.inner
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the probability of corrupting a packet, in percents.
|
|
|
|
pub fn corrupt_chance(&self) -> u8 {
|
|
|
|
self.config.corrupt_pct
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the probability of dropping a packet, in percents.
|
|
|
|
pub fn drop_chance(&self) -> u8 {
|
|
|
|
self.config.drop_pct
|
|
|
|
}
|
|
|
|
|
2017-05-29 18:53:30 +08:00
|
|
|
/// Return the maximum packet size, in octets.
|
|
|
|
pub fn max_packet_size(&self) -> usize {
|
|
|
|
self.config.max_size
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the maximum packet transmission rate, in packets per second.
|
|
|
|
pub fn max_tx_rate(&self) -> u64 {
|
|
|
|
self.config.max_rx_rate
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the maximum packet reception rate, in packets per second.
|
|
|
|
pub fn max_rx_rate(&self) -> u64 {
|
|
|
|
self.config.max_tx_rate
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the interval for packet rate limiting, in milliseconds.
|
2017-07-23 23:10:57 +08:00
|
|
|
pub fn bucket_interval(&self) -> u64 {
|
2017-05-29 18:53:30 +08:00
|
|
|
self.config.interval
|
|
|
|
}
|
|
|
|
|
2016-12-31 09:04:39 +08:00
|
|
|
/// Set the probability of corrupting a packet, in percents.
|
|
|
|
///
|
|
|
|
/// # Panics
|
|
|
|
/// This function panics if the probability is not between 0% and 100%.
|
|
|
|
pub fn set_corrupt_chance(&mut self, pct: u8) {
|
|
|
|
if pct > 100 { panic!("percentage out of range") }
|
|
|
|
self.config.corrupt_pct = pct
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set the probability of dropping a packet, in percents.
|
|
|
|
///
|
|
|
|
/// # Panics
|
|
|
|
/// This function panics if the probability is not between 0% and 100%.
|
|
|
|
pub fn set_drop_chance(&mut self, pct: u8) {
|
|
|
|
if pct > 100 { panic!("percentage out of range") }
|
|
|
|
self.config.drop_pct = pct
|
|
|
|
}
|
2017-05-29 18:53:30 +08:00
|
|
|
|
|
|
|
/// Set the maximum packet size, in octets.
|
|
|
|
pub fn set_max_packet_size(&mut self, size: usize) {
|
|
|
|
self.config.max_size = size
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set the maximum packet transmission rate, in packets per interval.
|
|
|
|
pub fn set_max_tx_rate(&mut self, rate: u64) {
|
|
|
|
self.config.max_tx_rate = rate
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set the maximum packet reception rate, in packets per interval.
|
|
|
|
pub fn set_max_rx_rate(&mut self, rate: u64) {
|
|
|
|
self.config.max_rx_rate = rate
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set the interval for packet rate limiting, in milliseconds.
|
2017-07-23 23:10:57 +08:00
|
|
|
pub fn set_bucket_interval(&mut self, interval: u64) {
|
|
|
|
self.state.refilled_at = 0;
|
2017-05-29 18:53:30 +08:00
|
|
|
self.config.interval = interval
|
|
|
|
}
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
|
2017-07-23 18:15:56 +08:00
|
|
|
impl<D: Device> Device for FaultInjector<D>
|
|
|
|
where D::RxBuffer: AsMut<[u8]> {
|
|
|
|
type RxBuffer = D::RxBuffer;
|
|
|
|
type TxBuffer = TxBuffer<D::TxBuffer>;
|
2016-12-31 09:04:39 +08:00
|
|
|
|
2017-03-07 18:56:48 +08:00
|
|
|
fn limits(&self) -> DeviceLimits {
|
2017-07-23 18:20:05 +08:00
|
|
|
let mut limits = self.inner.limits();
|
2017-03-07 18:56:48 +08:00
|
|
|
if limits.max_transmission_unit > MTU {
|
|
|
|
limits.max_transmission_unit = MTU;
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
2017-03-07 18:56:48 +08:00
|
|
|
limits
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
|
2017-07-27 21:51:02 +08:00
|
|
|
fn receive(&mut self, timestamp: u64) -> Result<Self::RxBuffer> {
|
2017-07-23 18:20:05 +08:00
|
|
|
let mut buffer = self.inner.receive(timestamp)?;
|
2017-05-29 18:53:30 +08:00
|
|
|
if self.state.maybe(self.config.drop_pct) {
|
|
|
|
net_trace!("rx: randomly dropping a packet");
|
2016-12-31 09:04:39 +08:00
|
|
|
return Err(Error::Exhausted)
|
|
|
|
}
|
2017-05-29 18:53:30 +08:00
|
|
|
if self.state.maybe(self.config.corrupt_pct) {
|
|
|
|
net_trace!("rx: randomly corrupting a packet");
|
|
|
|
self.state.corrupt(&mut buffer)
|
|
|
|
}
|
|
|
|
if self.config.max_size > 0 && buffer.as_ref().len() > self.config.max_size {
|
|
|
|
net_trace!("rx: dropping a packet that is too large");
|
|
|
|
return Err(Error::Exhausted)
|
|
|
|
}
|
2017-07-23 23:10:57 +08:00
|
|
|
if !self.state.maybe_receive(&self.config, timestamp) {
|
2017-05-29 18:53:30 +08:00
|
|
|
net_trace!("rx: dropping a packet because of rate limiting");
|
|
|
|
return Err(Error::Exhausted)
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
Ok(buffer)
|
|
|
|
}
|
|
|
|
|
2017-07-27 21:51:02 +08:00
|
|
|
fn transmit(&mut self, timestamp: u64, length: usize) -> Result<Self::TxBuffer> {
|
2016-12-31 09:04:39 +08:00
|
|
|
let buffer;
|
2017-05-29 18:53:30 +08:00
|
|
|
if self.state.maybe(self.config.drop_pct) {
|
|
|
|
net_trace!("tx: randomly dropping a packet");
|
|
|
|
buffer = None;
|
|
|
|
} else if self.config.max_size > 0 && length > self.config.max_size {
|
|
|
|
net_trace!("tx: dropping a packet that is too large");
|
|
|
|
buffer = None;
|
2017-07-23 23:10:57 +08:00
|
|
|
} else if !self.state.maybe_transmit(&self.config, timestamp) {
|
2017-05-29 18:53:30 +08:00
|
|
|
net_trace!("tx: dropping a packet because of rate limiting");
|
2016-12-31 09:04:39 +08:00
|
|
|
buffer = None;
|
|
|
|
} else {
|
2017-07-23 18:20:05 +08:00
|
|
|
buffer = Some(self.inner.transmit(timestamp, length)?);
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
Ok(TxBuffer {
|
|
|
|
buffer: buffer,
|
2017-05-29 18:53:30 +08:00
|
|
|
state: self.state.clone(),
|
2016-12-31 09:04:39 +08:00
|
|
|
config: self.config,
|
2016-12-31 09:10:46 +08:00
|
|
|
junk: [0; MTU],
|
|
|
|
length: length
|
2016-12-31 09:04:39 +08:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[doc(hidden)]
|
2017-07-23 18:15:56 +08:00
|
|
|
pub struct TxBuffer<B: AsRef<[u8]> + AsMut<[u8]>> {
|
2017-05-29 18:53:30 +08:00
|
|
|
state: State,
|
2016-12-31 09:04:39 +08:00
|
|
|
config: Config,
|
2017-07-23 18:15:56 +08:00
|
|
|
buffer: Option<B>,
|
2016-12-31 09:10:46 +08:00
|
|
|
junk: [u8; MTU],
|
|
|
|
length: usize
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
|
2017-07-23 18:15:56 +08:00
|
|
|
impl<B: AsRef<[u8]> + AsMut<[u8]>> AsRef<[u8]> for TxBuffer<B> {
|
2016-12-31 09:04:39 +08:00
|
|
|
fn as_ref(&self) -> &[u8] {
|
|
|
|
match self.buffer {
|
|
|
|
Some(ref buf) => buf.as_ref(),
|
2016-12-31 09:10:46 +08:00
|
|
|
None => &self.junk[..self.length]
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-23 18:15:56 +08:00
|
|
|
impl<B: AsRef<[u8]> + AsMut<[u8]>> AsMut<[u8]> for TxBuffer<B> {
|
2016-12-31 09:04:39 +08:00
|
|
|
fn as_mut(&mut self) -> &mut [u8] {
|
|
|
|
match self.buffer {
|
|
|
|
Some(ref mut buf) => buf.as_mut(),
|
2016-12-31 09:10:46 +08:00
|
|
|
None => &mut self.junk[..self.length]
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-23 18:15:56 +08:00
|
|
|
impl<B: AsRef<[u8]> + AsMut<[u8]>> Drop for TxBuffer<B> {
|
2016-12-31 09:04:39 +08:00
|
|
|
fn drop(&mut self) {
|
|
|
|
match self.buffer {
|
|
|
|
Some(ref mut buf) => {
|
2017-05-29 18:53:30 +08:00
|
|
|
if self.state.maybe(self.config.corrupt_pct) {
|
2016-12-31 09:04:39 +08:00
|
|
|
net_trace!("tx: corrupting a packet");
|
2017-05-29 18:53:30 +08:00
|
|
|
self.state.corrupt(buf)
|
2016-12-31 09:04:39 +08:00
|
|
|
}
|
|
|
|
},
|
|
|
|
None => ()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|