Handle WSL kernel version strings

Fixes #654.
pull/656/head
Tamir Duberstein 1 year ago
parent 961f45da37
commit 35ed85a87f
No known key found for this signature in database

@ -24,7 +24,6 @@ object = { version = "0.31", default-features = false, features = [
"std", "std",
] } ] }
parking_lot = { version = "0.12.0", features = ["send_guard"] } parking_lot = { version = "0.12.0", features = ["send_guard"] }
text_io = "0.1.12"
thiserror = "1" thiserror = "1"
tokio = { version = "1.24.0", features = ["rt"], optional = true } tokio = { version = "1.24.0", features = ["rt"], optional = true }

@ -25,18 +25,14 @@ pub struct KernelVersion {
pub(crate) patch: u16, pub(crate) patch: u16,
} }
/// An error encountered while fetching the current kernel version.
#[derive(thiserror::Error, Debug)] #[derive(thiserror::Error, Debug)]
pub enum CurrentKernelVersionError { enum CurrentKernelVersionError {
/// The kernel version string could not be read.
#[error("failed to read kernel version")] #[error("failed to read kernel version")]
IOError(#[from] io::Error), IO(#[from] io::Error),
/// The kernel version string could not be parsed.
#[error("failed to parse kernel version")] #[error("failed to parse kernel version")]
ParseError(#[from] text_io::Error), ParseError(String),
/// The kernel version string was not valid UTF-8.
#[error("kernel version string is not valid UTF-8")] #[error("kernel version string is not valid UTF-8")]
Utf8Error(#[from] Utf8Error), Utf8(#[from] Utf8Error),
} }
impl KernelVersion { impl KernelVersion {
@ -74,7 +70,7 @@ impl KernelVersion {
fn get_ubuntu_kernel_version() -> Result<Option<Self>, CurrentKernelVersionError> { fn get_ubuntu_kernel_version() -> Result<Option<Self>, CurrentKernelVersionError> {
const UBUNTU_KVER_FILE: &str = "/proc/version_signature"; const UBUNTU_KVER_FILE: &str = "/proc/version_signature";
let s = match fs::read(UBUNTU_KVER_FILE) { let s = match fs::read_to_string(UBUNTU_KVER_FILE) {
Ok(s) => s, Ok(s) => s,
Err(e) => { Err(e) => {
if e.kind() == io::ErrorKind::NotFound { if e.kind() == io::ErrorKind::NotFound {
@ -83,13 +79,16 @@ impl KernelVersion {
return Err(e.into()); return Err(e.into());
} }
}; };
let ubuntu: String; let mut parts = s.split_terminator(char::is_whitespace);
let ubuntu_version: String; let mut next = || {
let major: u8; parts
let minor: u8; .next()
let patch: u16; .ok_or_else(|| CurrentKernelVersionError::ParseError(s.to_string()))
text_io::try_scan!(s.iter().copied() => "{} {} {}.{}.{}\n", ubuntu, ubuntu_version, major, minor, patch); };
Ok(Some(Self::new(major, minor, patch))) let _ubuntu: &str = next()?;
let _ubuntu_version: &str = next()?;
let kernel_version_string = next()?;
Self::parse_kernel_version_string(kernel_version_string).map(Some)
} }
fn get_debian_kernel_version( fn get_debian_kernel_version(
@ -99,17 +98,13 @@ impl KernelVersion {
// //
// The length of the arrays in a struct utsname is unspecified (see NOTES); the fields are // The length of the arrays in a struct utsname is unspecified (see NOTES); the fields are
// terminated by a null byte ('\0'). // terminated by a null byte ('\0').
let p = unsafe { CStr::from_ptr(info.version.as_ptr()) }; let s = unsafe { CStr::from_ptr(info.version.as_ptr()) };
let p = p.to_str()?; let s = s.to_str()?;
let p = match p.split_once("Debian ") { let kernel_version_string = match s.split_once("Debian ") {
Some((_prefix, suffix)) => suffix, Some((_prefix, suffix)) => suffix,
None => return Ok(None), None => return Ok(None),
}; };
let major: u8; Self::parse_kernel_version_string(kernel_version_string).map(Some)
let minor: u8;
let patch: u16;
text_io::try_scan!(p.bytes() => "{}.{}.{}", major, minor, patch);
Ok(Some(Self::new(major, minor, patch)))
} }
fn get_kernel_version() -> Result<Self, CurrentKernelVersionError> { fn get_kernel_version() -> Result<Self, CurrentKernelVersionError> {
@ -130,17 +125,23 @@ impl KernelVersion {
// //
// The length of the arrays in a struct utsname is unspecified (see NOTES); the fields are // The length of the arrays in a struct utsname is unspecified (see NOTES); the fields are
// terminated by a null byte ('\0'). // terminated by a null byte ('\0').
let p = unsafe { CStr::from_ptr(info.release.as_ptr()) }; let s = unsafe { CStr::from_ptr(info.release.as_ptr()) };
let p = p.to_str()?; let s = s.to_str()?;
// Unlike sscanf, text_io::try_scan! does not stop at the first non-matching character. Self::parse_kernel_version_string(s)
let p = match p.split_once(|c: char| c != '.' && !c.is_ascii_digit()) { }
Some((prefix, _suffix)) => prefix,
None => p, fn parse_kernel_version_string(s: &str) -> Result<Self, CurrentKernelVersionError> {
}; fn parse<T: FromStr<Err = std::num::ParseIntError>>(s: Option<&str>) -> Option<T> {
let major: u8; match s.map(str::parse).transpose() {
let minor: u8; Ok(option) => option,
let patch: u16; Err(std::num::ParseIntError { .. }) => None,
text_io::try_scan!(p.bytes() => "{}.{}.{}", major, minor, patch); }
}
let error = || CurrentKernelVersionError::ParseError(s.to_string());
let mut parts = s.split(|c: char| c == '.' || !c.is_ascii_digit());
let major = parse(parts.next()).ok_or_else(error)?;
let minor = parse(parts.next()).ok_or_else(error)?;
let patch = parse(parts.next()).ok_or_else(error)?;
Ok(Self::new(major, minor, patch)) Ok(Self::new(major, minor, patch))
} }
} }
@ -331,6 +332,19 @@ pub(crate) fn bytes_of_slice<T: Pod>(val: &[T]) -> &[u8] {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use assert_matches::assert_matches;
#[test]
fn test_parse_kernel_version_string() {
// WSL.
assert_matches!(KernelVersion::parse_kernel_version_string("5.15.90.1-microsoft-standard-WSL2"), Ok(kernel_version) => {
assert_eq!(kernel_version, KernelVersion::new(5, 15, 90))
});
// uname -r on Fedora.
assert_matches!(KernelVersion::parse_kernel_version_string("6.3.11-200.fc38.x86_64"), Ok(kernel_version) => {
assert_eq!(kernel_version, KernelVersion::new(6, 3, 11))
});
}
#[test] #[test]
fn test_parse_online_cpus() { fn test_parse_online_cpus() {

Loading…
Cancel
Save