feat(kernel): add sysctl section to common Parameter type

systeroid-core/src/docs.rs

@@ -18,6 +18,19 @@ pub enum SysctlSection {
     User,
     /// Documentation for `/proc/sys/vm/*`
     Vm,
+    /// Unknown.
+    Unknown,
+}
+
+impl From<String> for SysctlSection {
+    fn from(value: String) -> Self {
+        for section in Self::variants() {
+            if value.starts_with(&format!("{}.", section)) {
+                return *section;
+            }
+        }
+        Self::Unknown
+    }
 }
 
 impl Display for SysctlSection {

systeroid-core/src/error.rs

@@ -3,15 +3,18 @@ use thiserror::Error as ThisError;
 /// Custom error type.
 #[derive(Debug, ThisError)]
 pub enum Error {
-    /// Error that might occur during I/O operations.
+    /// Error that may occur during I/O operations.
     #[error("IO error: `{0}`")]
     IoError(#[from] std::io::Error),
-    /// Error that might occur whenever a lock is acquired.
+    /// Error that may occur whenever a lock is acquired.
     #[error("Thread lock error: `{0}`")]
     ThreadLockError(String),
-    /// Error that might occur while parsing documents.
+    /// Error that may occur while parsing documents.
     #[error("parse error: `{0}`")]
     ParseError(String),
+    /// Error that may occur while handling sysctl operations.
+    #[error("sysctl error: `{0}`")]
+    SysctlError(#[from] sysctl::SysctlError),
 }
 
 unsafe impl Send for Error {}

systeroid-core/src/sysctl.rs

@@ -1,3 +1,6 @@
+use crate::docs::SysctlSection;
+use crate::error::Result;
+use std::result::Result as StdResult;
 use sysctl::{CtlIter, Sysctl as SysctlImpl};
 
 /// Representation of a kernel parameter.
@@ -8,6 +11,8 @@ pub struct Parameter {
     pub value: String,
     /// Description of the kernel parameter
     pub description: Option<String>,
+    /// Section of the kernel parameter.
+    pub section: SysctlSection,
 }
 
 /// Sysctl wrapper for managing the kernel parameters.
@@ -18,18 +23,16 @@ pub struct Sysctl {
 
 impl Sysctl {
     /// Constructs a new instance by fetching the available kernel parameters.
-    pub fn init() -> Self {
-        Self {
-            parameters: CtlIter::root()
-                .filter_map(Result::ok)
-                .filter_map(|ctl| {
-                    Some(Parameter {
-                        name: ctl.name().ok()?,
-                        value: ctl.value_string().ok()?,
-                        description: ctl.description().ok(),
-                    })
-                })
-                .collect(),
+    pub fn init() -> Result<Self> {
+        let mut parameters = Vec::new();
+        for ctl in CtlIter::root().filter_map(StdResult::ok) {
+            parameters.push(Parameter {
+                name: ctl.name()?,
+                value: ctl.value_string()?,
+                description: ctl.description().ok(),
+                section: SysctlSection::from(ctl.name()?),
+            });
         }
+        Ok(Self { parameters })
     }
 }

systeroid/src/lib.rs

@@ -9,7 +9,7 @@ use crate::args::Args;
 use rayon::prelude::*;
 use std::io::{Error as IoError, ErrorKind as IoErrorKind};
 use std::sync::Mutex;
-use systeroid_core::docs::SysctlSection;
+use systeroid_core::docs::{Documentation, SysctlSection};
 use systeroid_core::error::{Error, Result};
 use systeroid_core::reader;
 use systeroid_core::sysctl::Sysctl;
@@ -17,7 +17,7 @@ use systeroid_parser::parser::RstParser;
 
 /// Runs `systeroid`.
 pub fn run(args: Args) -> Result<()> {
-    let sysctl = Sysctl::init();
+    let sysctl = Sysctl::init()?;
 
     if let Some(kernel_docs) = args.kernel_docs {
         let sysctl_docs = kernel_docs.join("admin-guide").join("sysctl");
@@ -42,18 +42,18 @@ pub fn run(args: Args) -> Result<()> {
             parse(*s)
         })?;
 
-        for param in param_docs
+        let _param_docs = param_docs
             .lock()
             .map_err(|e| Error::ThreadLockError(e.to_string()))?
             .iter()
-        {
-            println!("## {}.{}\n", param.section, param.name);
-            println!("{}\n", param.description);
-        }
+            .collect::<Vec<&Documentation>>();
     }
 
     for param in sysctl.parameters {
-        println!("{}: {} ({:?})", param.name, param.value, param.description);
+        println!(
+            "{} -> {}: {} ({:?})",
+            param.section, param.name, param.value, param.description
+        );
     }
 
     Ok(())