use std::path::PathBuf;
use crate::error::{Error, Result};
use crate::util::parse;
use crate::util::{Bytes, Milliseconds};
#[derive(Debug)]
pub struct BlockStat {
pub reads_completed: u64,
pub reads_merged: u64,
pub sectors_read: u64,
pub time_reading: Milliseconds,
pub writes_completed: u64,
pub writes_merged: u64,
pub sectors_written: u64,
pub time_writing: Milliseconds,
pub io_in_progress: u64,
pub time_io: Milliseconds,
}
#[derive(Debug)]
pub struct QueueParams {
pub scheduler: Option<Box<str>>,
pub nr_requests: u32,
pub rotational: bool,
pub read_ahead_kb: u32,
}
pub struct BlockDevice {
pub name: Box<str>,
base: PathBuf,
}
impl BlockDevice {
pub fn all() -> impl Iterator<Item = Result<Self>> {
let entries = match std::fs::read_dir("/sys/block") {
Ok(iter) => iter,
Err(e) => {
return vec![Err(Error::Io {
path: Some(std::path::PathBuf::from("/sys/block")),
error: e,
})]
.into_iter();
}
};
entries
.filter_map(|entry| match entry {
Ok(e) => {
let name = e.file_name();
let name_str = name.to_string_lossy();
if !name_str.is_empty() {
Some(Ok(BlockDevice {
name: name_str.into_owned().into_boxed_str(),
base: e.path(),
}))
} else {
None
}
}
Err(e) => Some(Err(Error::Io {
path: Some(std::path::PathBuf::from("/sys/block")),
error: e,
})),
})
.collect::<Vec<_>>()
.into_iter()
}
pub fn stat(&self) -> Result<BlockStat> {
let path = self.base.join("stat");
let bytes = parse::read_file(&path)?;
let fields: Vec<&[u8]> = parse::split_spaces(&bytes);
if fields.len() < 11 {
return Err(Error::Parse {
path,
line: 0,
msg: "not enough fields in stat",
});
}
let get = |i: usize| parse::parse_dec_u64(fields[i]).unwrap_or(0);
Ok(BlockStat {
reads_completed: get(0),
reads_merged: get(1),
sectors_read: get(2),
time_reading: Milliseconds(get(3)),
writes_completed: get(4),
writes_merged: get(5),
sectors_written: get(6),
time_writing: Milliseconds(get(7)),
io_in_progress: get(8),
time_io: Milliseconds(get(9)),
})
}
pub fn size(&self) -> Result<Bytes> {
let path = self.base.join("size");
let bytes = parse::read_file(&path)?;
let sectors = parse::parse_dec_u64(&bytes)?;
Ok(Bytes(sectors * 512))
}
pub fn queue_params(&self) -> Result<QueueParams> {
let queue = self.base.join("queue");
let scheduler = {
let path = queue.join("scheduler");
match parse::read_file(&path) {
Ok(bytes) => {
let s = std::str::from_utf8(&bytes).unwrap_or("").trim();
if let Some(start) = s.find('[') {
s.find(']')
.map(|end| s[start + 1..end].to_string().into_boxed_str())
} else {
None
}
}
Err(_) => None,
}
};
let nr_requests = {
let path = queue.join("nr_requests");
match parse::read_file(&path) {
Ok(bytes) => parse::parse_dec_u32(&bytes).unwrap_or(128),
Err(_) => 128,
}
};
let rotational = {
let path = queue.join("rotational");
match parse::read_file(&path) {
Ok(bytes) => parse::parse_dec_u32(&bytes).unwrap_or(0) != 0,
Err(_) => false,
}
};
let read_ahead_kb = {
let path = queue.join("read_ahead_kb");
match parse::read_file(&path) {
Ok(bytes) => parse::parse_dec_u32(&bytes).unwrap_or(256),
Err(_) => 256,
}
};
Ok(QueueParams {
scheduler,
nr_requests,
rotational,
read_ahead_kb,
})
}
}