Add redox os check (#100)

* Change conditional compiles to include redox as linux variant and add a compile check for it in CI

* Fix other linux compiles to include redox

* Only check redox on linux

Author: andrewdavidmackenzie

.github/workflows/clippy_build_test.yml

@@ -47,6 +47,12 @@ jobs:
     - name: Clippy
       run: make clippy
 
+    - name: Compile check on redox
+      if: runner.os == 'Linux'
+      run: |
+        rustup target add x86_64-unknown-redox
+        cargo +nightly check --target x86_64-unknown-redox
+
     - name: ConfigureCoverage
       if: matrix.rust == 'nightly'
       run: |
@@ -57,11 +63,11 @@ jobs:
 
     - name: Run Tests on Linux
       if: runner.os == 'Linux'
-      run:  env "PATH=$PATH" cargo test
+      run: env "PATH=$PATH" cargo test
 
     - name: Run Tests as Root on Mac
       if: runner.os == 'macOS'
-      run:  sudo env "PATH=$PATH" cargo test
+      run: sudo env "PATH=$PATH" cargo test
 
     - name: UploadCoverage
       if: matrix.rust == 'nightly'

Cargo.toml

@@ -33,6 +33,9 @@ path = "src/dmesg.rs"
 [build-dependencies]
 bindgen = { version = "0.66.1", default-features = false, features = ["runtime"] }
 
-[target.'cfg(target_os = "linux")'.dev-dependencies]
+# NOTE: This assumes that there is a procfs compatible FS in redox and the procfs crate
+# supports it. It's quite probably that neither of those two things ever happen.
+# But making this assumption for now so that everything compiles at least for redox
+[target.'cfg(any(target_os = "linux", target_os = "redox"))'.dev-dependencies]
 procfs = "0.15.0"
 tempfile = "3.3.0"

build.rs

@@ -19,5 +19,5 @@ fn main() {
         .expect("Failed to write libproc bindings");
 }
 
-#[cfg(not(target_os = "macos"))]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 fn main() {}

src/libproc/file_info.rs

@@ -169,7 +169,7 @@ pub fn pidfdinfo<T: PIDFDInfo>(pid: i32, fd: i32) -> Result<T, String> {
     }
 }
 
-#[cfg(not(target_os = "macos"))]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 pub fn pidfdinfo<T: PIDFDInfo>(_pid: i32, _fd: i32) -> Result<T, String> {
     unimplemented!()
 }

src/libproc/helpers.rs

@@ -1,7 +1,7 @@
 use crate::errno::errno;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use std::fs::File;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use std::io::{BufRead, BufReader};
 
 /// Helper function to get errno and return a String with the passed in return_code, the error
@@ -30,7 +30,7 @@ pub fn check_errno(ret: i32, buf: &mut Vec<u8>) -> Result<String, String> {
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 /// A helper function for finding named fields in specific /proc FS files for processes
 /// This will be more useful when implementing more linux functions
 pub fn procfile_field(filename: &str, field_name: &str) -> Result<String, String> {
@@ -53,7 +53,7 @@ pub fn procfile_field(filename: &str, field_name: &str) -> Result<String, String
     Err(format!("Could not find the field named '{field_name}' in the /proc FS file name '{filename}'"))
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 /// Parse a memory amount string into integer number of bytes
 /// e.g. 220844 kB -->
 pub fn parse_memory_string(line: &str) -> Result<u64, String> {
@@ -83,7 +83,7 @@ mod test {
     use crate::errno::{set_errno, Errno};
     use super::check_errno;
 
-    #[cfg(target_os = "linux")]
+    #[cfg(any(target_os = "linux", target_os = "redox"))]
     mod linux {
         use crate::libproc::helpers::parse_memory_string;
 
@@ -143,7 +143,7 @@ mod test {
         if let Err(mes) = check_errno(-1, &mut buf) {
             #[cfg(target_os = "macos")]
             assert_eq!(mes, "return code = -1, errno = -1, message = 'Unknown error: -1'");
-            #[cfg(target_os = "linux")]
+            #[cfg(any(target_os = "linux", target_os = "redox"))]
             assert_eq!(mes, "return code = -1, errno = -1, message = 'Unknown error -1'");
         }
     }

src/libproc/kmesg_buffer.rs

@@ -7,15 +7,15 @@ use std::str;
 #[cfg(target_os = "macos")]
 use self::libc::c_void;
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use std::fs::File;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use std::io::{BufRead, BufReader};
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use std::sync::mpsc;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use std::sync::mpsc::Receiver;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use std::{thread, time};
 
 #[cfg(target_os = "macos")]
@@ -56,7 +56,7 @@ pub fn kmsgbuf() -> Result<String, String> {
 /// reading methods will block at the end of file, so a workaround is required. Do the blocking
 /// reads on a thread that sends lines read back through a channel, and then return when the thread
 /// has blocked and can't send anymore. Returning will end the thread and the channel.
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 pub fn kmsgbuf() -> Result<String, String> {
     let mut file = File::open("/dev/kmsg");
     if file.is_err() {
@@ -75,7 +75,7 @@ pub fn kmsgbuf() -> Result<String, String> {
 
 // Create a channel to return lines read from a file on, then create a thread that reads the lines
 // and sends them back on the channel one by one. Eventually it will get to EOF or block
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 fn spawn_kmsg_channel(file: File) -> Receiver<String> {
     let mut reader = BufReader::new(file);
     let (tx, rx) = mpsc::channel::<String>();

src/libproc/pid_rusage.rs

@@ -6,7 +6,7 @@ use crate::libproc::helpers;
 #[cfg(target_os = "macos")]
 use self::libc::c_void;
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use crate::libproc::helpers::{procfile_field, parse_memory_string};
 #[cfg(target_os = "macos")]
 use crate::osx_libproc_bindings::proc_pid_rusage;
@@ -386,7 +386,7 @@ pub fn pidrusage<T: PIDRUsage>(pid : i32) -> Result<T, String> {
     }
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 /// Returns the information about resources of the process that match pid passed in.
 ///
 /// # Examples

src/libproc/proc_pid.rs

@@ -1,16 +1,16 @@
 extern crate libc;
 
 use std::env;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use std::ffi::CString;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use std::fs;
 #[cfg(target_os = "macos")]
 use std::mem;
 use std::path::PathBuf;
 
 use libc::pid_t;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use libc::PATH_MAX;
 
 #[cfg(target_os = "macos")]
@@ -29,7 +29,7 @@ use crate::osx_libproc_bindings::{
 
 #[cfg(target_os = "macos")]
 use self::libc::c_void;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 use self::libc::{c_char, readlink};
 
 use crate::processes;
@@ -242,7 +242,7 @@ pub fn pidinfo<T: PIDInfo>(pid: i32, arg: u64) -> Result<T, String> {
 }
 
 /// pidinfo not implemented on linux - Pull Requests welcome - TODO
-#[cfg(not(target_os = "macos"))]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 pub fn pidinfo<T: PIDInfo>(_pid: i32, _arg: u64) -> Result<T, String> {
     unimplemented!()
 }
@@ -295,7 +295,7 @@ pub fn regionfilename(pid: i32, address: u64) -> Result<String, String> {
 ///     }
 /// }
 /// ```
-#[cfg(not(target_os = "macos"))]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 pub fn regionfilename(_pid: i32, _address: u64) -> Result<String, String> {
     Err("'regionfilename' not implemented on linux".to_owned())
 }
@@ -340,7 +340,7 @@ pub fn pidpath(pid: i32) -> Result<String, String> {
 ///     _ => panic!("Unknown error")
 /// }
 /// ```
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 pub fn pidpath(pid: i32) -> Result<String, String> {
     let exe_path = CString::new(format!("/proc/{pid}/exe"))
         .map_err(|_| "Could not create CString")?;
@@ -396,7 +396,7 @@ pub fn libversion() -> Result<(i32, i32), String> {
 ///     Err(err) => eprintln!("Error: {}", err)
 /// }
 /// ```
-#[cfg(not(target_os = "macos"))]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 pub fn libversion() -> Result<(i32, i32), String> {
     Err("Linux does not use a library, so no library version number".to_owned())
 }
@@ -440,7 +440,7 @@ pub fn name(pid: i32) -> Result<String, String> {
 
 
 /// Get the name of a process, using it's process id (pid)
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 pub fn name(pid: i32) -> Result<String, String> {
     helpers::procfile_field(&format!("/proc/{pid}/status"), "Name")
 }
@@ -495,7 +495,7 @@ pub fn listpidinfo<T: ListPIDInfo>(pid: i32, max_len: usize) -> Result<Vec<T::It
 }
 
 /// listpidinfo is not implemented on Linux - Pull Requests welcome - TODO
-#[cfg(not(target_os = "macos"))]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 pub fn listpidinfo<T: ListPIDInfo>(_pid: i32, _max_len: usize) -> Result<Vec<T::Item>, String> {
     unimplemented!()
 }
@@ -517,7 +517,7 @@ pub fn pidcwd(_pid: pid_t) -> Result<PathBuf, String> {
     Err("pidcwd is not implemented for macos".into())
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 /// Gets the path of current working directory for the process with the provided pid.
 ///
 /// # Examples
@@ -573,7 +573,7 @@ pub fn am_root() -> bool {
 }
 
 /// Return true if the calling process is being run by the root user, false otherwise
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 pub fn am_root() -> bool {
     // when this becomes stable in rust libc then we can remove this function or combine for mac and linux
     unsafe { libc::geteuid() == 0 }
@@ -595,10 +595,10 @@ mod test {
     #[cfg(target_os = "macos")]
     use super::{libversion, listpidinfo, ListThreads, pidinfo};
     use super::{name, cwdself, pidpath};
-    #[cfg(target_os = "linux")]
+    #[cfg(any(target_os = "linux", target_os = "redox"))]
     use super::pidcwd;
     use super::am_root;
-    #[cfg(target_os = "linux")]
+    #[cfg(any(target_os = "linux", target_os = "redox"))]
     use crate::libproc::helpers;
     #[cfg(target_os = "macos")]
     use crate::libproc::task_info::TaskInfo;
@@ -687,7 +687,7 @@ mod test {
 
     #[test]
     fn name_test() {
-        if am_root() || cfg!(target_os = "linux") {
+        if am_root() || cfg!(any(target_os = "linux", target_os = "redox")) {
             assert!(&name(process::id() as i32).expect("Could not get the process name")
                 .starts_with("libproc"), "Incorrect process name");
         } else {
@@ -700,7 +700,7 @@ mod test {
     fn pidpath_test_unknown_pid_test() {
         #[cfg(target_os = "macos")]
             let error_message = "No such process";
-        #[cfg(target_os = "linux")]
+        #[cfg(any(target_os = "linux", target_os = "redox"))]
             let error_message = "No such file or directory";
 
         match pidpath(-1) {
@@ -724,7 +724,7 @@ mod test {
                    cwdself().expect("cwdself() failed"));
     }
 
-    #[cfg(target_os = "linux")]
+    #[cfg(any(target_os = "linux", target_os = "redox"))]
     #[test]
     fn pidcwd_of_self_test() {
         assert_eq!(env::current_dir().expect("Could not get current directory"),
@@ -741,7 +741,7 @@ mod test {
     }
 
     #[test]
-    #[cfg(target_os = "linux")]
+    #[cfg(any(target_os = "linux", target_os = "redox"))]
     fn procfile_field_test() {
         if am_root() {
             assert!(helpers::procfile_field("/proc/1/status", "invalid").is_err());

src/libproc/sys/mod.rs

@@ -1,7 +1,7 @@
 // OS-specific implementations of process-related functions
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 mod linux;
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "redox"))]
 pub(crate) use self::linux::*;
 
 #[cfg(target_os = "macos")]