Implement windows support

Author: MikailBag

.github/workflows/rust.yml

@@ -101,6 +101,35 @@ jobs:
           path: /tmp/logs
           name: tests-trace-${{ matrix.cgroups }}-${{ matrix.os }}
 
+  tests-windows:
+    strategy:
+      matrix:
+        rust-target:
+          - 'x86_64-pc-windows-gnu'
+          - 'x86_64-pc-windows-msvc'
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1.0.6
+        with: 
+          toolchain: stable
+          override: true
+      - name: Test
+        run: powershell ci/windows.ps1
+        timeout-minutes: 5
+        env:
+          CI_TARGET: ${{ matrix.rust-target }}
+      - name: Collect logs
+        if: always()
+        run: |
+          mkdir /tmp/logs
+          cp ./strace* /tmp/logs
+      - uses: actions/upload-artifact@v1
+        if: always()
+        with:
+          path: /tmp/logs
+          name: tests-trace
+
   nightly-checks:
     runs-on: ubuntu-20.04
     steps:

Cargo.lock

@@ -20,6 +20,25 @@ futures-util = "0.3.12"
 tokio = { version = "1.1.0", features = ["net"] }
 tracing = "0.1.22"
 itoa = "0.4.7"
+serde = { version = "1.0.106", features = ["derive"] }
+thiserror = "1.0.19"
+anyhow = "1.0.32"
+futures-util = "0.3.6"
+once_cell = "1.4.1"
+backtrace = "0.3.46"
+
+[target.'cfg(target_os="linux")'.dependencies]
+tiny-nix-ipc = { git = "https://github.com/myfreeweb/tiny-nix-ipc", features = ["ser_json", "zero_copy"] }
+procfs = "0.7.8"
+nix = {git = "https://github.com/nix-rust/nix"}
+libc = "0.2.68"
+errno = "0.2.5"
+serde_json = "1.0.51"
+tokio = { version = "0.3.2", features = ["net"] }
+
+[target.'cfg(target_os="windows")'.dependencies]
+winapi = { version = "0.3.9", features = ["std", "processthreadsapi", "jobapi2", "errhandlingapi",
+ "namedpipeapi", "fileapi", "synchapi", "winnt", "userenv", "handleapi", "securitybaseapi", "sddl"] }
 
 [workspace]
 members = ["minion-ffi", ".", "minion-tests", "minion-cli"]

Cargo.toml

@@ -0,0 +1,25 @@
+$ErrorActionPreference = "Stop"
+
+Write-Output "::group::Info"
+Write-Output "Target: $env:CI_TARGET"
+Write-Output "::group::Preparing"
+rustup target add $env:CI_TARGET
+Write-Output @'
+[build]
+rustflags=["--cfg", "minion_ci"]
+'@ | Out-File -FilePath ./.cargo/config -Encoding 'utf8'
+
+Write-Output "::group::Compiling tests"
+$env:RUSTC_BOOTSTRAP = 1
+cargo build -p minion-tests -Zunstable-options --out-dir=./out --target=$env:CI_TARGET
+
+if ($LASTEXITCODE -ne 0) {
+    throw "build failure" 
+}
+
+Write-Output "::group::Running tests"
+$env:RUST_BACKTRACE = 1
+./out/minion-tests.exe
+if ($LASTEXITCODE -ne 0) {
+    throw "tests failed"
+}

ci/windows.ps1

@@ -2,7 +2,7 @@
 #![cfg_attr(minion_nightly, warn(unsafe_op_in_unsafe_fn))]
 use minion::{self};
 use std::{
-    ffi::{CStr, OsStr, OsString},
+    ffi::{CStr, OsString},
     mem::{self},
     os::raw::c_char,
     sync::Arc,
@@ -42,11 +42,23 @@ pub enum WaitOutcome {
 
 /// # Safety
 /// `buf` must be valid, readable pointer
+#[cfg(target_os = "linux")]
 unsafe fn get_string(buf: *const c_char) -> OsString {
     use std::os::unix::ffi::OsStrExt;
     let buf = unsafe { CStr::from_ptr(buf) };
     let buf = buf.to_bytes();
-    let s = OsStr::from_bytes(buf);
+    let s = std::ffi::OsStr::from_bytes(buf);
+    s.to_os_string()
+}
+/// # Safety
+/// `buf` must be valid, readable pointer
+#[cfg(target_os = "windows")]
+unsafe fn get_string(buf: *const c_char) -> OsString {
+    use std::os::windows::ffi::OsStringExt;
+    let buf = unsafe { CStr::from_ptr(buf) };
+    let buf = buf.to_bytes();
+    assert!(buf.len() % 2 == 0);
+    let s = OsString::from_wide(unsafe { buf.align_to::<u16>().1 });
     s.to_os_string()
 }
 

minion-ffi/src/lib.rs

@@ -8,7 +8,13 @@ edition = "2018"
 once_cell = "1.5.2"
 minion = {path = ".."}
 clap = "2.33.3"
-nix = "0.19.1"
 tempfile = "3.2.0"
 tokio = { version = "1.1.0", features = ["macros", "rt"] }
 tracing-subscriber = "0.2.15"
+tracing-subscriber = "0.2.15"
+
+[target.'cfg(target_os="linux")'.dependencies]
+nix = "0.17.0"
+
+[target.'cfg(target_os="windows")'.dependencies]
+winapi = { version = "0.3.9", features = ["processthreadsapi"] }

minion-tests/Cargo.toml

@@ -50,8 +50,18 @@ impl crate::TestCase for TTlFork {
         (TODO: verify this is not wall-clock time limit)"
     }
     fn test(&self) -> ! {
+        #[cfg(target_os = "linux")]
+        nix::unistd::fork().unwrap();
+        #[cfg(target_os = "winfows")]
         unsafe {
-            nix::unistd::fork().unwrap();
+            winapi::um::processthreadsapi::CreateThread(
+                std::ptr::null_mut(),
+                0,
+                exceed_time_limit,
+                self,
+                0,
+                std::ptr::null_mut(),
+            );
         }
         exceed_time_limit()
     }
@@ -73,7 +83,12 @@ impl crate::TestCase for TIdle {
         checks that it still will be killed"
     }
     fn test(&self) -> ! {
+        #[cfg(target_os = "linux")]
         nix::unistd::sleep(1_000_000_000);
+        #[cfg(target_os = "windows")]
+        unsafe {
+            winapi::um::synchapi::Sleep(1_000_000_000);
+        };
         std::process::exit(0)
     }
     fn check(&self, cp: crate::CompletedChild, _: &dyn Sandbox) {
@@ -149,6 +164,7 @@ impl crate::TestCase for TSecurity {
     fn description(&self) -> &'static str {
         "verifies that isolated program can not make certain bad things"
     }
+    #[cfg(target_os = "linux")]
     fn test(&self) -> ! {
         // Check we can not read pid1's environment.
         let err = std::fs::read("/proc/1/environ").unwrap_err();
@@ -166,6 +182,12 @@ impl crate::TestCase for TSecurity {
         assert!(matches!(err, nix::Error::Sys(nix::errno::Errno::EPERM)));
         std::process::exit(24)
     }
+
+    #[cfg(target_os = "windows")]
+    fn test(&self) -> ! {
+        std::process::exit(24)
+    }
+
     fn check(&self, mut cp: crate::CompletedChild, _sb: &dyn Sandbox) {
         super::assert_exit_code(cp.by_ref(), minion::ExitCode(24));
         super::assert_empty(cp.stdout);

minion-tests/src/tests/simple.rs

@@ -58,6 +58,7 @@ async fn inner_main(test_cases: &[&'static dyn TestCase]) {
 }
 
 pub fn main(test_cases: &[&'static dyn TestCase]) {
+    tracing_subscriber::fmt().pretty().init();
     let rt = tokio::runtime::Builder::new_current_thread()
         .enable_all()
         .build()

minion-tests/src/worker.rs

@@ -1,2 +1,2 @@
 unstable_features = true
-imports_granularity = "Crate"
+imports_granularity = "Crate"

rustfmt.toml

@@ -18,7 +18,7 @@ pub trait Sandbox: std::fmt::Debug + Send + Sync + 'static {
 }
 
 impl<S: crate::Sandbox> Sandbox for S {
-    fn id(&self) -> String {
+    fn id(&self) -> &str {
         self.id()
     }
     fn check_cpu_tle(&self) -> anyhow::Result<bool> {
@@ -107,7 +107,11 @@ pub type ChildProcessOptions = crate::ChildProcessOptions<dyn Sandbox>;
 
 /// Returns backend instance
 pub fn setup() -> anyhow::Result<Box<dyn Backend>> {
-    Ok(Box::new(crate::linux::LinuxBackend::new(
+    #[cfg(target_os = "linux")]
+    return Ok(Box::new(crate::linux::LinuxBackend::new(
         crate::linux::Settings::new(),
-    )?))
+    )?));
+
+    #[cfg(target_os = "windows")]
+    return Ok(Box::new(crate::windows::WindowsBackend::new()));
 }