procthreadattrlisf no

Author: MikailBag

.github/workflows/rust.yml

@@ -91,13 +91,14 @@ jobs:
       - name: Collect logs
         if: always()
         run: |
-          mkdir /tmp/logs
-          cp ./strace* /tmp/logs
+          ls
+          mkdir D:/ci-logs
+          cp ./strace* D:/ci-logs
       - uses: actions/upload-artifact@v1
         if: always()
         with:
-          path: /tmp/logs
-          name: tests-trace
+          path: D:/ci-logs
+          name: tests-ntcalls
 
   nightly-checks:
     runs-on: ubuntu-latest

ci/windows.ps1

@@ -19,7 +19,7 @@ if ($LASTEXITCODE -ne 0) {
 
 Write-Output "::group::Running tests"
 $env:RUST_BACKTRACE = 1
-./out/minion-tests.exe
+./out/minion-tests.exe --trace
 if ($LASTEXITCODE -ne 0) {
     throw "tests failed"
 }

minion-tests/src/master.rs

@@ -73,12 +73,53 @@ fn execute_tests(test_cases: &[&dyn TestCase], exec_opts: ExecuteOptions) -> Out
 fn execute_single_test(case: &dyn TestCase, exec_opts: ExecuteOptions) -> Outcome {
     println!("------ {} ------", case.name());
     let self_exe = std::env::current_exe().unwrap();
+    let tmp = tempfile::tempdir().unwrap();
+    let mut temp_logs_dir = None;
     let mut cmd = if exec_opts.trace {
-        let mut cmd = std::process::Command::new("strace");
-        cmd.arg("-f"); // follow forks
-        cmd.arg("-o").arg(format!("strace-log-{}.txt", case.name()));
-        cmd.arg(self_exe);
-        cmd
+        if cfg!(target_os = "linux") {
+            let mut cmd = std::process::Command::new("strace");
+            cmd.arg("-f"); // follow forks
+            cmd.arg("-o").arg(format!("strace-log-{}.txt", case.name()));
+            cmd.arg(self_exe);
+            cmd
+        } else if cfg!(target_os = "windows") {
+            let mut cmd = std::process::Command::new(
+                "C:\\Program Files (x86)\\Windows Kits\\10\\Debuggers\\x64\\cdb.exe",
+            );
+            // disable debug heap
+            cmd.arg("-hd");
+            // follow children
+            cmd.arg("-o");
+
+            let script_file_path = tmp.path().join("cdb-script.txt");
+            let logs_path: std::path::PathBuf = format!(".\\strace-ntapi-{}", case.name()).into();
+            std::fs::create_dir(&logs_path).unwrap();
+            println!("Saving logs to {}", logs_path.display());
+            std::fs::write(
+                &script_file_path,
+                [
+                    &format!("!logexts.loge {}", logs_path.display()),
+                    "!logexts.logc e *",
+                    "!logexts.logo e d",
+                    "!logexts.logo e t",
+                    "!logexts.logo e v",
+                    "g",
+                    "!logexts.logb f",
+                    "q",
+                ]
+                .join("\n"),
+            )
+            .unwrap();
+
+            temp_logs_dir.replace(logs_path);
+
+            cmd.arg("-cf").arg(&script_file_path);
+
+            cmd.arg(self_exe);
+            cmd
+        } else {
+            panic!("--trace unsupported on this target")
+        }
     } else {
         std::process::Command::new(self_exe)
     };

minion-tests/src/worker.rs

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

src/windows/spawn.rs

@@ -138,12 +138,38 @@ pub(in crate::windows) struct ChildParams {
 // TODO: upstream to winapi: https://github.com/retep998/winapi-rs/pull/933/
 const MAGIC_PROC_THREAD_ATTRIBUTE_SECURITY_CAPABILITIES: usize = 131081;
 
+struct AlignedMemBlock(*mut u8, usize);
+
+impl AlignedMemBlock {
+    fn layout(cnt: usize) -> std::alloc::Layout {
+        assert!(cnt > 0);
+        std::alloc::Layout::from_size_align(cnt, 8).unwrap()
+    }
+
+    fn new(cnt: usize) -> AlignedMemBlock {
+        let ptr = unsafe { std::alloc::alloc_zeroed(Self::layout(cnt)) };
+        AlignedMemBlock(ptr, cnt)
+    }
+
+    fn ptr(&self) -> *mut u8 {
+        self.0
+    }
+}
+
+impl Drop for AlignedMemBlock {
+    fn drop(&mut self) {
+        unsafe {
+            std::alloc::dealloc(self.0, Self::layout(self.1));
+        }
+    }
+}
+
 pub(in crate::windows) fn spawn(
     sandbox: &WindowsSandbox,
     stdio: Stdio,
     params: ChildParams,
 ) -> Result<PROCESS_INFORMATION, Error> {
-    let mut proc_thread_attr_list_storage: Vec<u64>;
+    let proc_thread_attr_list_storage;
     let mut security_capabilities;
     let mut startup_info = unsafe {
         let mut startup_info: STARTUPINFOEXW = std::mem::zeroed();
@@ -160,9 +186,8 @@ pub(in crate::windows) fn spawn(
                 return Err(Error::last());
             }
         }
-        proc_thread_attr_list_storage = Vec::with_capacity((proc_thread_attr_list_len - 1) / 8 + 1);
-        let proc_thread_attr_list: *mut u8 = proc_thread_attr_list_storage.as_mut_ptr().cast();
-        proc_thread_attr_list.write_bytes(0, proc_thread_attr_list_len);
+        proc_thread_attr_list_storage = AlignedMemBlock::new(proc_thread_attr_list_len);
+        let proc_thread_attr_list = proc_thread_attr_list_storage.ptr();
         startup_info.lpAttributeList = proc_thread_attr_list.cast();
         Cvt::nonzero(InitializeProcThreadAttributeList(
             startup_info.lpAttributeList,
@@ -173,11 +198,14 @@ pub(in crate::windows) fn spawn(
         security_capabilities = sandbox.profile.get_security_capabilities();
         Cvt::nonzero(UpdateProcThreadAttribute(
             startup_info.lpAttributeList,
+            // reserved
             0,
             MAGIC_PROC_THREAD_ATTRIBUTE_SECURITY_CAPABILITIES,
             (&mut security_capabilities as *mut SECURITY_CAPABILITIES).cast(),
             std::mem::size_of::<SECURITY_ATTRIBUTES>(),
+            // reserved
             std::ptr::null_mut(),
+            // reserved
             std::ptr::null_mut(),
         ))?;
 
@@ -211,13 +239,12 @@ pub(in crate::windows) fn spawn(
             // inherit handles
             TRUE,
             creation_flags,
-            // TEMP DEBUG
-            std::ptr::null_mut(),
-            //env.as_mut_ptr().cast(),
+            env.as_mut_ptr().cast(),
             cwd.as_ptr(),
             (&mut startup_info as *mut STARTUPINFOEXW).cast(),
             &mut info,
         ))?;
+        DeleteProcThreadAttributeList(startup_info.lpAttributeList);
     }
     Ok(info)
 }

src/windows/wait.rs

@@ -5,8 +5,8 @@ use std::{
     pin::Pin,
     sync::{
         atomic::{
-            AtomicBool, AtomicU32,
-            Ordering::{Acquire, Relaxed, Release},
+            AtomicBool,
+            Ordering::{Acquire, Release},
         },
         Arc,
     },