Debian Codegraph @

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

raw
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 }