third_party/rust/procfs-core/src/sys/kernel/mod.rs

   1 //! Global kernel info / tuning miscellaneous stuff
   2 //!
   3 //! The files in this directory can be used to tune and monitor miscellaneous
   4 //! and general things in the operation of the Linux kernel.
   5
   6 use std::cmp;
   7 use std::collections::HashSet;
   8 use std::str::FromStr;
   9
  10 use bitflags::bitflags;
  11
  12 use crate::{ProcError, ProcResult};
  13
  14 /// Represents a kernel version, in major.minor.release version.
  15 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
  16 pub struct Version {
  17     pub major: u8,
  18     pub minor: u8,
  19     pub patch: u16,
  20 }
  21
  22 impl Version {
  23     pub fn new(major: u8, minor: u8, patch: u16) -> Version {
  24         Version { major, minor, patch }
  25     }
  26
  27     /// Parses a kernel version string, in major.minor.release syntax.
  28     ///
  29     /// Note that any extra information (stuff after a dash) is ignored.
  30     ///
  31     /// # Example
  32     ///
  33     /// ```
  34     /// # use procfs_core::KernelVersion;
  35     /// let a = KernelVersion::from_str("3.16.0-6-amd64").unwrap();
  36     /// let b = KernelVersion::new(3, 16, 0);
  37     /// assert_eq!(a, b);
  38     ///
  39     /// ```
  40     #[allow(clippy::should_implement_trait)]
  41     pub fn from_str(s: &str) -> Result<Self, &'static str> {
  42         let pos = s.find(|c: char| c != '.' && !c.is_ascii_digit());
  43         let kernel = if let Some(pos) = pos {
  44             let (s, _) = s.split_at(pos);
  45             s
  46         } else {
  47             s
  48         };
  49         let mut kernel_split = kernel.split('.');
  50
  51         let major = kernel_split.next().ok_or("Missing major version component")?;
  52         let minor = kernel_split.next().ok_or("Missing minor version component")?;
  53         let patch = kernel_split.next().ok_or("Missing patch version component")?;
  54
  55         let major = major.parse().map_err(|_| "Failed to parse major version")?;
  56         let minor = minor.parse().map_err(|_| "Failed to parse minor version")?;
  57         let patch = patch.parse().map_err(|_| "Failed to parse patch version")?;
  58
  59         Ok(Version { major, minor, patch })
  60     }
  61 }
  62
  63 impl FromStr for Version {
  64     type Err = &'static str;
  65
  66     /// Parses a kernel version string, in major.minor.release syntax.
  67     ///
  68     /// Note that any extra information (stuff after a dash) is ignored.
  69     ///
  70     /// # Example
  71     ///
  72     /// ```
  73     /// # use procfs_core::KernelVersion;
  74     /// let a: KernelVersion = "3.16.0-6-amd64".parse().unwrap();
  75     /// let b = KernelVersion::new(3, 16, 0);
  76     /// assert_eq!(a, b);
  77     ///
  78     /// ```
  79     fn from_str(s: &str) -> Result<Self, Self::Err> {
  80         Version::from_str(s)
  81     }
  82 }
  83
  84 impl cmp::Ord for Version {
  85     fn cmp(&self, other: &Self) -> cmp::Ordering {
  86         match self.major.cmp(&other.major) {
  87             cmp::Ordering::Equal => match self.minor.cmp(&other.minor) {
  88                 cmp::Ordering::Equal => self.patch.cmp(&other.patch),
  89                 x => x,
  90             },
  91             x => x,
  92         }
  93     }
  94 }
  95
  96 impl cmp::PartialOrd for Version {
  97     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
  98         Some(self.cmp(other))
  99     }
 100 }
 101
 102 /// Represents a kernel type
 103 #[derive(Debug, Clone, Eq, PartialEq)]
 104 pub struct Type {
 105     pub sysname: String,
 106 }
 107
 108 impl Type {
 109     pub fn new(sysname: String) -> Type {
 110         Type { sysname }
 111     }
 112 }
 113
 114 impl FromStr for Type {
 115     type Err = &'static str;
 116
 117     /// Parse a kernel type string
 118     ///
 119     /// Notice that in Linux source code, it is defined as a single string.
 120     fn from_str(s: &str) -> Result<Self, Self::Err> {
 121         Ok(Type::new(s.to_string()))
 122     }
 123 }
 124
 125 /// Represents a kernel build information
 126 #[derive(Debug, Clone, Eq, PartialEq)]
 127 pub struct BuildInfo {
 128     pub version: String,
 129     pub flags: HashSet<String>,
 130     /// This field contains any extra data from the /proc/sys/kernel/version file. It generally contains the build date of the kernel, but the format of the date can vary.
 131     ///
 132     /// A method named `extra_date` is provided which would try to parse some date formats. When the date format is not supported, an error will be returned. It depends on chrono feature.
 133     pub extra: String,
 134 }
 135
 136 impl BuildInfo {
 137     pub fn new(version: &str, flags: HashSet<String>, extra: String) -> BuildInfo {
 138         BuildInfo {
 139             version: version.to_string(),
 140             flags,
 141             extra,
 142         }
 143     }
 144
 145     /// Check if SMP is ON
 146     pub fn smp(&self) -> bool {
 147         self.flags.contains("SMP")
 148     }
 149
 150     /// Check if PREEMPT is ON
 151     pub fn preempt(&self) -> bool {
 152         self.flags.contains("PREEMPT")
 153     }
 154
 155     /// Check if PREEMPTRT is ON
 156     pub fn preemptrt(&self) -> bool {
 157         self.flags.contains("PREEMPTRT")
 158     }
 159
 160     /// Return version number
 161     ///
 162     /// This would parse number from first digits of version string. For example, #21~1 to 21.
 163     pub fn version_number(&self) -> ProcResult<u32> {
 164         let mut version_str = String::new();
 165         for c in self.version.chars() {
 166             if c.is_ascii_digit() {
 167                 version_str.push(c);
 168             } else {
 169                 break;
 170             }
 171         }
 172         let version_number: u32 = version_str.parse().map_err(|_| "Failed to parse version number")?;
 173         Ok(version_number)
 174     }
 175
 176     /// Parse extra field to `DateTime` object
 177     ///
 178     /// This function may fail as TIMESTAMP can be various formats.
 179     #[cfg(feature = "chrono")]
 180     pub fn extra_date(&self) -> ProcResult<chrono::DateTime<chrono::Local>> {
 181         if let Ok(dt) =
 182             chrono::DateTime::parse_from_str(&format!("{} +0000", &self.extra), "%a %b %d %H:%M:%S UTC %Y %z")
 183         {
 184             return Ok(dt.with_timezone(&chrono::Local));
 185         }
 186         if let Ok(dt) = chrono::DateTime::parse_from_str(&self.extra, "%a, %d %b %Y %H:%M:%S %z") {
 187             return Ok(dt.with_timezone(&chrono::Local));
 188         }
 189         Err(ProcError::Other("Failed to parse extra field to date".to_string()))
 190     }
 191 }
 192
 193 impl FromStr for BuildInfo {
 194     type Err = &'static str;
 195
 196     /// Parse a kernel build information string
 197     fn from_str(s: &str) -> Result<Self, Self::Err> {
 198         let mut version = String::new();
 199         let mut flags: HashSet<String> = HashSet::new();
 200         let mut extra: String = String::new();
 201
 202         let mut splited = s.split(' ');
 203         let version_str = splited.next();
 204         if let Some(version_str) = version_str {
 205             if let Some(stripped) = version_str.strip_prefix('#') {
 206                 version.push_str(stripped);
 207             } else {
 208                 return Err("Failed to parse kernel build version");
 209             }
 210         } else {
 211             return Err("Failed to parse kernel build version");
 212         }
 213
 214         for s in &mut splited {
 215             if s.chars().all(char::is_uppercase) {
 216                 flags.insert(s.to_string());
 217             } else {
 218                 extra.push_str(s);
 219                 extra.push(' ');
 220                 break;
 221             }
 222         }
 223         let remains: Vec<&str> = splited.collect();
 224         extra.push_str(&remains.join(" "));
 225
 226         Ok(BuildInfo { version, flags, extra })
 227     }
 228 }
 229
 230 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 231 /// Represents the data from `/proc/sys/kernel/sem`
 232 pub struct SemaphoreLimits {
 233     /// The maximum semaphores per semaphore set
 234     pub semmsl: u64,
 235     /// A system-wide limit on the number of semaphores in all semaphore sets
 236     pub semmns: u64,
 237     /// The maximum number of operations that may be specified in a semop(2) call
 238     pub semopm: u64,
 239     /// A system-wide limit on the maximum number of semaphore identifiers
 240     pub semmni: u64,
 241 }
 242
 243 impl SemaphoreLimits {
 244     fn from_str(s: &str) -> Result<Self, &'static str> {
 245         let mut s = s.split_ascii_whitespace();
 246
 247         let semmsl = s.next().ok_or("Missing SEMMSL")?;
 248         let semmns = s.next().ok_or("Missing SEMMNS")?;
 249         let semopm = s.next().ok_or("Missing SEMOPM")?;
 250         let semmni = s.next().ok_or("Missing SEMMNI")?;
 251
 252         let semmsl = semmsl.parse().map_err(|_| "Failed to parse SEMMSL")?;
 253         let semmns = semmns.parse().map_err(|_| "Failed to parse SEMMNS")?;
 254         let semopm = semopm.parse().map_err(|_| "Failed to parse SEMOPM")?;
 255         let semmni = semmni.parse().map_err(|_| "Failed to parse SEMMNI")?;
 256
 257         Ok(SemaphoreLimits {
 258             semmsl,
 259             semmns,
 260             semopm,
 261             semmni,
 262         })
 263     }
 264 }
 265
 266 impl FromStr for SemaphoreLimits {
 267     type Err = &'static str;
 268
 269     fn from_str(s: &str) -> Result<Self, Self::Err> {
 270         SemaphoreLimits::from_str(s)
 271     }
 272 }
 273
 274 bitflags! {
 275     /// Flags representing allowed sysrq functions
 276     #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, PartialOrd, Ord)]
 277     pub struct AllowedFunctions : u16 {
 278         /// Enable control of console log level
 279         const ENABLE_CONTROL_LOG_LEVEL = 2;
 280         /// Enable control of keyboard (SAK, unraw)
 281         const ENABLE_CONTROL_KEYBOARD = 4;
 282         /// Enable debugging dumps of processes etc
 283         const ENABLE_DEBUGGING_DUMPS = 8;
 284         /// Enable sync command
 285         const ENABLE_SYNC_COMMAND = 16;
 286         /// Enable remound read-only
 287         const ENABLE_REMOUNT_READ_ONLY = 32;
 288         /// Enable signaling of processes (term, kill, oom-kill)
 289         const ENABLE_SIGNALING_PROCESSES = 64;
 290         /// Allow reboot/poweroff
 291         const ALLOW_REBOOT_POWEROFF = 128;
 292         /// Allow nicing of all real-time tasks
 293         const ALLOW_NICING_REAL_TIME_TASKS = 256;
 294     }
 295 }
 296
 297 /// Values controlling functions allowed to be invoked by the SysRq key
 298 #[derive(Copy, Clone, Debug)]
 299 pub enum SysRq {
 300     /// Disable sysrq completely
 301     Disable,
 302     /// Enable all functions of sysrq
 303     Enable,
 304     /// Bitmask of allowed sysrq functions
 305     AllowedFunctions(AllowedFunctions),
 306 }
 307
 308 impl SysRq {
 309     pub fn to_number(self) -> u16 {
 310         match self {
 311             SysRq::Disable => 0,
 312             SysRq::Enable => 1,
 313             SysRq::AllowedFunctions(allowed) => allowed.bits(),
 314         }
 315     }
 316
 317     fn from_str(s: &str) -> ProcResult<Self> {
 318         match s.parse::<u16>()? {
 319             0 => Ok(SysRq::Disable),
 320             1 => Ok(SysRq::Enable),
 321             x => match AllowedFunctions::from_bits(x) {
 322                 Some(allowed) => Ok(SysRq::AllowedFunctions(allowed)),
 323                 None => Err("Invalid value".into()),
 324             },
 325         }
 326     }
 327 }
 328
 329 impl FromStr for SysRq {
 330     type Err = ProcError;
 331
 332     fn from_str(s: &str) -> Result<Self, Self::Err> {
 333         SysRq::from_str(s)
 334     }
 335 }
 336
 337 /// The minimum value that can be written to `/proc/sys/kernel/threads-max` on Linux 4.1 or later
 338 pub const THREADS_MIN: u32 = 20;
 339 /// The maximum value that can be written to `/proc/sys/kernel/threads-max` on Linux 4.1 or later
 340 pub const THREADS_MAX: u32 = 0x3fff_ffff;
 341
 342 #[cfg(test)]
 343 mod tests {
 344     use super::*;
 345
 346     #[test]
 347     fn test_version() {
 348         let a = Version::from_str("3.16.0-6-amd64").unwrap();
 349         let b = Version::new(3, 16, 0);
 350         assert_eq!(a, b);
 351
 352         let a = Version::from_str("3.16.0").unwrap();
 353         let b = Version::new(3, 16, 0);
 354         assert_eq!(a, b);
 355
 356         let a = Version::from_str("3.16.0_1").unwrap();
 357         let b = Version::new(3, 16, 0);
 358         assert_eq!(a, b);
 359     }
 360
 361     #[test]
 362     fn test_type() {
 363         let a = Type::from_str("Linux").unwrap();
 364         assert_eq!(a.sysname, "Linux");
 365     }
 366
 367     #[test]
 368     fn test_build_info() {
 369         // For Ubuntu, Manjaro, CentOS and others:
 370         let a = BuildInfo::from_str("#1 SMP PREEMPT Thu Sep 30 15:29:01 UTC 2021").unwrap();
 371         let mut flags: HashSet<String> = HashSet::new();
 372         flags.insert("SMP".to_string());
 373         flags.insert("PREEMPT".to_string());
 374         assert_eq!(a.version, "1");
 375         assert_eq!(a.version_number().unwrap(), 1);
 376         assert_eq!(a.flags, flags);
 377         assert!(a.smp());
 378         assert!(a.preempt());
 379         assert!(!a.preemptrt());
 380         assert_eq!(a.extra, "Thu Sep 30 15:29:01 UTC 2021");
 381         #[cfg(feature = "chrono")]
 382         let _ = a.extra_date().unwrap();
 383
 384         // For Arch and others:
 385         let b = BuildInfo::from_str("#1 SMP PREEMPT Fri, 12 Nov 2021 19:22:10 +0000").unwrap();
 386         assert_eq!(b.version, "1");
 387         assert_eq!(b.version_number().unwrap(), 1);
 388         assert_eq!(b.flags, flags);
 389         assert_eq!(b.extra, "Fri, 12 Nov 2021 19:22:10 +0000");
 390         assert!(b.smp());
 391         assert!(b.preempt());
 392         assert!(!b.preemptrt());
 393         #[cfg(feature = "chrono")]
 394         let _ = b.extra_date().unwrap();
 395
 396         // For Debian and others:
 397         let c = BuildInfo::from_str("#1 SMP Debian 5.10.46-4 (2021-08-03)").unwrap();
 398         let mut flags: HashSet<String> = HashSet::new();
 399         flags.insert("SMP".to_string());
 400         assert_eq!(c.version, "1");
 401         assert_eq!(c.version_number().unwrap(), 1);
 402         assert_eq!(c.flags, flags);
 403         assert_eq!(c.extra, "Debian 5.10.46-4 (2021-08-03)");
 404         assert!(c.smp());
 405         assert!(!c.preempt());
 406         assert!(!c.preemptrt());
 407         // Skip the date parsing for now
 408     }
 409
 410     #[test]
 411     fn test_semaphore_limits() {
 412         // Note that the below string has tab characters in it. Make sure to not remove them.
 413         let a = SemaphoreLimits::from_str("32000        1024000000      500     32000").unwrap();
 414         let b = SemaphoreLimits {
 415             semmsl: 32_000,
 416             semmns: 1_024_000_000,
 417             semopm: 500,
 418             semmni: 32_000,
 419         };
 420         assert_eq!(a, b);
 421
 422         let a = SemaphoreLimits::from_str("1");
 423         assert!(a.is_err() && a.err().unwrap() == "Missing SEMMNS");
 424
 425         let a = SemaphoreLimits::from_str("1 string 500 3200");
 426         assert!(a.is_err() && a.err().unwrap() == "Failed to parse SEMMNS");
 427     }
 428 }