gpui_rn_util 0.1.1

Utility structs and functions (fork for React Native GPUI)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use std::ffi::OsStr;

#[cfg(target_os = "windows")]
const CREATE_NO_WINDOW: u32 = 0x0800_0000_u32;

#[cfg(target_os = "windows")]
pub fn new_std_command(program: impl AsRef<OsStr>) -> std::process::Command {
    use std::os::windows::process::CommandExt;

    let mut command = std::process::Command::new(program);
    command.creation_flags(CREATE_NO_WINDOW);
    command
}

#[cfg(not(target_os = "windows"))]
pub fn new_std_command(program: impl AsRef<OsStr>) -> std::process::Command {
    std::process::Command::new(program)
}

#[cfg(target_os = "windows")]
pub fn new_smol_command(program: impl AsRef<OsStr>) -> smol::process::Command {
    use smol::process::windows::CommandExt;

    let mut command = smol::process::Command::new(program);
    command.creation_flags(CREATE_NO_WINDOW);
    command
}

#[cfg(target_os = "macos")]
pub fn new_smol_command(program: impl AsRef<OsStr>) -> smol::process::Command {
    use std::os::unix::process::CommandExt;

    // Create a std::process::Command first so we can use pre_exec
    let mut std_cmd = std::process::Command::new(program);

    // WORKAROUND: Reset exception ports before exec to prevent inheritance of
    // crash handler exception ports. Due to a timing issue, child processes can
    // inherit the parent's exception ports before they're fully stabilized,
    // which can block child process spawning.
    // See: https://github.com/zed-industries/zed/issues/36754
    unsafe {
        std_cmd.pre_exec(|| {
            // Reset all exception ports to system defaults for this task.
            // This prevents the child from inheriting the parent's crash handler
            // exception ports.
            reset_exception_ports();
            Ok(())
        });
    }

    // Convert to async_process::Command via From trait
    smol::process::Command::from(std_cmd)
}

#[cfg(all(not(target_os = "windows"), not(target_os = "macos")))]
pub fn new_smol_command(program: impl AsRef<OsStr>) -> smol::process::Command {
    smol::process::Command::new(program)
}

#[cfg(target_os = "macos")]
pub fn reset_exception_ports() {
    use mach2::exception_types::{
        EXC_MASK_ALL, EXCEPTION_DEFAULT, exception_behavior_t, exception_mask_t,
    };
    use mach2::kern_return::{KERN_SUCCESS, kern_return_t};
    use mach2::mach_types::task_t;
    use mach2::port::{MACH_PORT_NULL, mach_port_t};
    use mach2::thread_status::{THREAD_STATE_NONE, thread_state_flavor_t};
    use mach2::traps::mach_task_self;

    // FFI binding for task_set_exception_ports (not exposed by mach2 crate)
    unsafe extern "C" {
        fn task_set_exception_ports(
            task: task_t,
            exception_mask: exception_mask_t,
            new_port: mach_port_t,
            behavior: exception_behavior_t,
            new_flavor: thread_state_flavor_t,
        ) -> kern_return_t;
    }

    unsafe {
        let task = mach_task_self();
        // Reset all exception ports to MACH_PORT_NULL (system default)
        // This prevents the child process from inheriting the parent's crash handler
        let kr = task_set_exception_ports(
            task,
            EXC_MASK_ALL,
            MACH_PORT_NULL,
            EXCEPTION_DEFAULT as exception_behavior_t,
            THREAD_STATE_NONE,
        );

        if kr != KERN_SUCCESS {
            // Log but don't fail - the process can still work without this workaround
            eprintln!(
                "Warning: failed to reset exception ports in child process (kern_return: {})",
                kr
            );
        }
    }
}