Morph MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

0 0 0 Zig
Normal View History Raw
do Jay's suggestion with posix/os API naming & layout
2019-05-24 18:27:18 -04:00
const std = @import("std.zig");
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
const builtin = @import("builtin");
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
const cstr = std.cstr;
switch most windows calls to use W versions instead of A See #534
2018-09-02 23:25:04 -04:00
const unicode = std.unicode;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
const io = std.io;
clean up references to os
2019-05-26 13:17:34 -04:00
const fs = std.fs;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
const os = std.os;
clean up references to os
2019-05-26 13:17:34 -04:00
const process = std.process;
starting to fix the regressions
2019-05-24 22:52:07 -04:00
const File = std.fs.File;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
const windows = os.windows;
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
const linux = os.linux;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
const mem = std.mem;
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
const math = std.math;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
const debug = std.debug;
const BufMap = std.BufMap;
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
const Os = std.builtin.Os;
std: existing LinkedList is actually a TailQueue
2019-05-04 13:54:28 +10:00
const TailQueue = std.TailQueue;
remove @minValue,@maxValue; add std.math.minInt,maxInt closes #1466 closes #1476
2018-10-26 14:59:58 -04:00
const maxInt = std.math.maxInt;
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
const assert = std.debug.assert;
API for command line args closes #300
2017-04-04 00:17:24 -04:00
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
pub const ChildProcess = struct {
stage2: hot code swapping PoC * CLI supports --listen to accept commands on a socket * make it able to produce an updated executable while it is running
2022-01-14 17:04:03 -07:00
/// Available after calling `spawn()`. It is a race condition to use this
/// value after `wait()`.
introduce operating system version ranges as part of the target * re-introduce `std.build.Target` which is distinct from `std.Target`. `std.build.Target` wraps `std.Target` so that it can be annotated as "the native target" or an explicitly specified target. * `std.Target.Os` is moved to `std.Target.Os.Tag`. The former is now a struct which has the tag as well as version range information. * `std.elf` gains some more ELF header constants. * `std.Target.parse` gains the ability to parse operating system version ranges as well as glibc version. * Added `std.Target.isGnuLibC()`. * self-hosted dynamic linker detection and glibc version detection. This also adds the improved logic using `/usr/bin/env` rather than invoking the system C compiler to find the dynamic linker when zig is statically linked. Related: #2084 Note: this `/usr/bin/env` code is work-in-progress. * `-target-glibc` CLI option is removed in favor of the new `-target` syntax. Example: `-target x86_64-linux-gnu.2.27` closes #1907
2020-02-25 01:52:27 -05:00
pid: if (builtin.os.tag == .windows) void else i32,
handle: if (builtin.os.tag == .windows) windows.HANDLE else void,
thread_handle: if (builtin.os.tag == .windows) windows.HANDLE else void,
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
allocator: mem.Allocator,
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
remove pub syntax for container fields
2019-10-21 22:22:08 +03:00
stdin: ?File,
stdout: ?File,
stderr: ?File,
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
remove pub syntax for container fields
2019-10-21 22:22:08 +03:00
term: ?(SpawnError!Term),
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
remove pub syntax for container fields
2019-10-21 22:22:08 +03:00
argv: []const []const u8,
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
/// Leave as null to use the current env map using the supplied allocator.
remove pub syntax for container fields
2019-10-21 22:22:08 +03:00
env_map: ?*const BufMap,
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
remove pub syntax for container fields
2019-10-21 22:22:08 +03:00
stdin_behavior: StdIo,
stdout_behavior: StdIo,
stderr_behavior: StdIo,
API for command line args closes #300
2017-04-04 00:17:24 -04:00
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
/// Set to change the user id when spawning the child process.
std: fix linux uid_t, use uid_t/gid_t in std.os - correct uid_t from i32 to u32 on linux - define uid_t and gid_t for OSes missing definitions - use uid_t/gid_t instead of plain u32s throughout std.os
2020-09-03 15:08:37 +02:00
uid: if (builtin.os.tag == .windows or builtin.os.tag == .wasi) void else ?os.uid_t,
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
std.os.ChildProcess: ability to set both uid and gid
2017-09-26 02:42:06 -04:00
/// Set to change the group id when spawning the child process.
std: fix linux uid_t, use uid_t/gid_t in std.os - correct uid_t from i32 to u32 on linux - define uid_t and gid_t for OSes missing definitions - use uid_t/gid_t instead of plain u32s throughout std.os
2020-09-03 15:08:37 +02:00
gid: if (builtin.os.tag == .windows or builtin.os.tag == .wasi) void else ?os.gid_t,
std.os.ChildProcess: ability to set both uid and gid
2017-09-26 02:42:06 -04:00
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
/// Set to change the current working directory when spawning the child process.
remove pub syntax for container fields
2019-10-21 22:22:08 +03:00
cwd: ?[]const u8,
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
/// Set to change the current working directory when spawning the child process.
/// This is not yet implemented for Windows. See https://github.com/ziglang/zig/issues/5190
/// Once that is done, `cwd` will be deprecated in favor of this field.
cwd_dir: ?fs.Dir = null,
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
introduce operating system version ranges as part of the target * re-introduce `std.build.Target` which is distinct from `std.Target`. `std.build.Target` wraps `std.Target` so that it can be annotated as "the native target" or an explicitly specified target. * `std.Target.Os` is moved to `std.Target.Os.Tag`. The former is now a struct which has the tag as well as version range information. * `std.elf` gains some more ELF header constants. * `std.Target.parse` gains the ability to parse operating system version ranges as well as glibc version. * Added `std.Target.isGnuLibC()`. * self-hosted dynamic linker detection and glibc version detection. This also adds the improved logic using `/usr/bin/env` rather than invoking the system C compiler to find the dynamic linker when zig is statically linked. Related: #2084 Note: this `/usr/bin/env` code is work-in-progress. * `-target-glibc` CLI option is removed in favor of the new `-target` syntax. Example: `-target x86_64-linux-gnu.2.27` closes #1907
2020-02-25 01:52:27 -05:00
err_pipe: if (builtin.os.tag == .windows) void else [2]os.fd_t,
API for command line args closes #300
2017-04-04 00:17:24 -04:00
expand argv[0] when spawning system C compiler Some C compilers, such as Clang, are known to rely on argv[0] to find the path to their own executable, without even bothering to resolve PATH. This results in the message: error: unable to execute command: Executable "" doesn't exist! So we tell ChildProcess to expand argv[0] to the absolute path to give them a helping hand.
2020-02-17 00:58:30 -05:00
expand_arg0: Arg0Expand,
pub const Arg0Expand = os.Arg0Expand;
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
pub const SpawnError = error{
OutOfMemory,
/// POSIX-only. `StdIo.Ignore` was selected and opening `/dev/null` returned ENODEV.
NoDevice,
/// Windows-only. One of:
/// * `cwd` was provided and it could not be re-encoded into UTF16LE, or
/// * The `PATH` or `PATHEXT` environment variable contained invalid UTF-8.
InvalidUtf8,
/// Windows-only. `cwd` was provided, but the path did not exist when spawning the child process.
CurrentWorkingDirectoryUnlinked,
add missing error set to ChildProsess.SpawnError
2019-11-19 13:13:02 +02:00
} || os.ExecveError || os.SetIdError || os.ChangeCurDirError || windows.CreateProcessError || windows.WaitForSingleObjectError;
*WIP* error sets - support fns called at comptime
2018-02-03 11:51:29 -05:00
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
pub const Term = union(enum) {
Make std.ChildProcess exit code u8 to match std.process.exit This patch adjusts the exit code for a child process to be a u8. Since the WEXITSTATUS macro returns the lower eight bits, it's safe to assume that we can truncate the returned u32.
2021-03-24 18:27:56 -07:00
Exited: u8,
tests passing on linux
2019-05-26 23:35:26 -04:00
Signal: u32,
Stopped: u32,
Unknown: u32,
API for command line args closes #300
2017-04-04 00:17:24 -04:00
};
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
pub const StdIo = enum {
API for command line args closes #300
2017-04-04 00:17:24 -04:00
Inherit,
Ignore,
Pipe,
Close,
};
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
/// First argument in argv is the executable.
/// On success must call deinit.
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
pub fn init(argv: []const []const u8, allocator: mem.Allocator) !*ChildProcess {
`std.mem.Allocator.create` replaced with better API `std.mem.Allocator.createOne` is renamed to `std.mem.Allocator.create`. The problem with the previous API is that even after copy elision, the initalization value passed as a parameter would always be a copy. With the new API, once copy elision is done, initialization functions can directly initialize allocated memory in place. Related: * #1872 * #1873
2019-02-03 16:13:28 -05:00
const child = try allocator.create(ChildProcess);
child.* = ChildProcess{
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
.allocator = allocator,
.argv = argv,
.pid = undefined,
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
.handle = undefined,
use correct integer type for windows BOOL
2017-10-15 14:01:55 -04:00
.thread_handle = undefined,
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
.err_pipe = undefined,
.term = null,
.env_map = null,
.cwd = null,
Correctly set uid and gid to void instead of null on wasi
2020-10-04 19:22:34 +03:00
.uid = if (builtin.os.tag == .windows or builtin.os.tag == .wasi) {} else null,
.gid = if (builtin.os.tag == .windows or builtin.os.tag == .wasi) {} else null,
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
.stdin = null,
.stdout = null,
.stderr = null,
.stdin_behavior = StdIo.Inherit,
.stdout_behavior = StdIo.Inherit,
.stderr_behavior = StdIo.Inherit,
expand argv[0] when spawning system C compiler Some C compilers, such as Clang, are known to rely on argv[0] to find the path to their own executable, without even bothering to resolve PATH. This results in the message: error: unable to execute command: Executable "" doesn't exist! So we tell ChildProcess to expand argv[0] to the absolute path to give them a helping hand.
2020-02-17 00:58:30 -05:00
.expand_arg0 = .no_expand,
`std.mem.Allocator.create` replaced with better API `std.mem.Allocator.createOne` is renamed to `std.mem.Allocator.create`. The problem with the previous API is that even after copy elision, the initalization value passed as a parameter would always be a copy. With the new API, once copy elision is done, initialization functions can directly initialize allocated memory in place. Related: * #1872 * #1873
2019-02-03 16:13:28 -05:00
};
std: update stdlib to match updated allocator create signature; ref #733
2018-06-21 00:40:21 +09:00
errdefer allocator.destroy(child);
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
return child;
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
pub fn setUserName(self: *ChildProcess, name: []const u8) !void {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 16:51:46 -05:00
const user_info = try os.getUserInfo(name);
std.os.ChildProcess: ability to set both uid and gid
2017-09-26 02:42:06 -04:00
self.uid = user_info.uid;
self.gid = user_info.gid;
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
}
/// On success must call `kill` or `wait`.
stage2: hot code swapping PoC * CLI supports --listen to accept commands on a socket * make it able to produce an updated executable while it is running
2022-01-14 17:04:03 -07:00
/// After spawning the `pid` is available.
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
pub fn spawn(self: *ChildProcess) SpawnError!void {
introduce operating system version ranges as part of the target * re-introduce `std.build.Target` which is distinct from `std.Target`. `std.build.Target` wraps `std.Target` so that it can be annotated as "the native target" or an explicitly specified target. * `std.Target.Os` is moved to `std.Target.Os.Tag`. The former is now a struct which has the tag as well as version range information. * `std.elf` gains some more ELF header constants. * `std.Target.parse` gains the ability to parse operating system version ranges as well as glibc version. * Added `std.Target.isGnuLibC()`. * self-hosted dynamic linker detection and glibc version detection. This also adds the improved logic using `/usr/bin/env` rather than invoking the system C compiler to find the dynamic linker when zig is statically linked. Related: #2084 Note: this `/usr/bin/env` code is work-in-progress. * `-target-glibc` CLI option is removed in favor of the new `-target` syntax. Example: `-target x86_64-linux-gnu.2.27` closes #1907
2020-02-25 01:52:27 -05:00
if (builtin.os.tag == .windows) {
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
return self.spawnWindows();
} else {
return self.spawnPosix();
explicitly return from blocks instead of last statement being expression value closes #629
2017-12-22 00:50:30 -05:00
}
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
}
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
pub fn spawnAndWait(self: *ChildProcess) SpawnError!Term {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 16:51:46 -05:00
try self.spawn();
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
return self.wait();
API for command line args closes #300
2017-04-04 00:17:24 -04:00
}
std: add ChildProcess.kill
2017-09-06 18:30:45 -04:00
/// Forcibly terminates child process and then cleans up all resources.
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
pub fn kill(self: *ChildProcess) !Term {
introduce operating system version ranges as part of the target * re-introduce `std.build.Target` which is distinct from `std.Target`. `std.build.Target` wraps `std.Target` so that it can be annotated as "the native target" or an explicitly specified target. * `std.Target.Os` is moved to `std.Target.Os.Tag`. The former is now a struct which has the tag as well as version range information. * `std.elf` gains some more ELF header constants. * `std.Target.parse` gains the ability to parse operating system version ranges as well as glibc version. * Added `std.Target.isGnuLibC()`. * self-hosted dynamic linker detection and glibc version detection. This also adds the improved logic using `/usr/bin/env` rather than invoking the system C compiler to find the dynamic linker when zig is statically linked. Related: #2084 Note: this `/usr/bin/env` code is work-in-progress. * `-target-glibc` CLI option is removed in favor of the new `-target` syntax. Example: `-target x86_64-linux-gnu.2.27` closes #1907
2020-02-25 01:52:27 -05:00
if (builtin.os.tag == .windows) {
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
return self.killWindows(1);
} else {
return self.killPosix();
}
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
pub fn killWindows(self: *ChildProcess, exit_code: windows.UINT) !Term {
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
if (self.term) |term| {
self.cleanupStreams();
return term;
}
starting to fix the regressions
2019-05-24 22:52:07 -04:00
try windows.TerminateProcess(self.handle, exit_code);
fix build runner on windows
2018-02-09 00:24:23 -05:00
try self.waitUnwrappedWindows();
breaking syntax change: ??x to x.? (#1095) See #1023 This also renames Nullable/Maybe to Optional
2018-06-09 23:42:14 -04:00
return self.term.?;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
pub fn killPosix(self: *ChildProcess) !Term {
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
if (self.term) |term| {
std.os.ChildProcess: fix fd leak
2017-09-16 21:07:02 -04:00
self.cleanupStreams();
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
return term;
}
stdlib: fix ChildProcess.killPosix Signed-off-by: Takeshi Yoneda <takeshi@tetrate.io>
2021-09-06 22:16:02 +09:00
try os.kill(self.pid, os.SIG.TERM);
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
self.waitUnwrapped();
breaking syntax change: ??x to x.? (#1095) See #1023 This also renames Nullable/Maybe to Optional
2018-06-09 23:42:14 -04:00
return self.term.?;
std: add ChildProcess.kill
2017-09-06 18:30:45 -04:00
}
zig build system: ability to link against dynamic library step
2017-04-16 14:14:11 -04:00
/// Blocks until child process terminates and then cleans up all resources.
stage2: hot code swapping PoC * CLI supports --listen to accept commands on a socket * make it able to produce an updated executable while it is running
2022-01-14 17:04:03 -07:00
/// TODO: set the pid to undefined in this function.
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
pub fn wait(self: *ChildProcess) !Term {
introduce operating system version ranges as part of the target * re-introduce `std.build.Target` which is distinct from `std.Target`. `std.build.Target` wraps `std.Target` so that it can be annotated as "the native target" or an explicitly specified target. * `std.Target.Os` is moved to `std.Target.Os.Tag`. The former is now a struct which has the tag as well as version range information. * `std.elf` gains some more ELF header constants. * `std.Target.parse` gains the ability to parse operating system version ranges as well as glibc version. * Added `std.Target.isGnuLibC()`. * self-hosted dynamic linker detection and glibc version detection. This also adds the improved logic using `/usr/bin/env` rather than invoking the system C compiler to find the dynamic linker when zig is statically linked. Related: #2084 Note: this `/usr/bin/env` code is work-in-progress. * `-target-glibc` CLI option is removed in favor of the new `-target` syntax. Example: `-target x86_64-linux-gnu.2.27` closes #1907
2020-02-25 01:52:27 -05:00
if (builtin.os.tag == .windows) {
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
return self.waitWindows();
} else {
return self.waitPosix();
}
}
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
pub const ExecResult = struct {
tests passing on linux
2019-05-26 23:35:26 -04:00
term: Term,
self-hosted: move code to std.os.ChildProcess.exec
2017-12-12 14:35:53 -05:00
stdout: []u8,
stderr: []u8,
};
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
fn collectOutputPosix(
child: *const ChildProcess,
stdout: *std.ArrayList(u8),
stderr: *std.ArrayList(u8),
max_output_bytes: usize,
) !void {
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
var poll_fds = [_]os.pollfd{
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
.{ .fd = child.stdout.?.handle, .events = os.POLL.IN, .revents = undefined },
.{ .fd = child.stderr.?.handle, .events = os.POLL.IN, .revents = undefined },
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
};
var dead_fds: usize = 0;
Update all ensureCapacity calls to the relevant non-deprecated version
2021-09-16 18:22:04 -07:00
// We ask for ensureTotalCapacity with this much extra space. This has more of an
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
// effect on small reads because once the reads start to get larger the amount
// of space an ArrayList will allocate grows exponentially.
const bump_amt = 512;
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
const err_mask = os.POLL.ERR | os.POLL.NVAL | os.POLL.HUP;
overhaul elf csu (c-runtime startup) logic - more support for linux, android, freebsd, netbsd, openbsd, dragonfly - centralize musl utils; musl logic is no longer intertwined with csu - fix musl compilation to build crti/crtn for full archs list - fix openbsd to support `zig build-lib -dynamic` - initial dragonfly linking success (with a warning) ancillary: - fix emutls (openbsd) tests to use `try`
2021-05-16 15:59:34 -04:00
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
while (dead_fds < poll_fds.len) {
const events = try os.poll(&poll_fds, std.math.maxInt(i32));
if (events == 0) continue;
std: Better handing of POLLHUP in ChildProcess (#8988) * std: Better handing of POLLHUP in ChildProcess Upon hitting the EOF condition there are two main differences between how Linux and the *BSD-derived systems behave: the former sets POLLHUP and POLLIN and, after reading any residual data, only POLLHUP remains set. The latter signal the EOF condition by setting both flags thus requiring some extra checks to determine if the stream is "done". DragonFly workaround/hack for POLLHUP is no longer required. Closes #8969
2021-06-05 20:26:59 +02:00
var remove_stdout = false;
var remove_stderr = false;
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
// Try reading whatever is available before checking the error
// conditions.
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
// It's still possible to read after a POLL.HUP is received, always
std: Better handing of POLLHUP in ChildProcess (#8988) * std: Better handing of POLLHUP in ChildProcess Upon hitting the EOF condition there are two main differences between how Linux and the *BSD-derived systems behave: the former sets POLLHUP and POLLIN and, after reading any residual data, only POLLHUP remains set. The latter signal the EOF condition by setting both flags thus requiring some extra checks to determine if the stream is "done". DragonFly workaround/hack for POLLHUP is no longer required. Closes #8969
2021-06-05 20:26:59 +02:00
// check if there's some data waiting to be read first.
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
if (poll_fds[0].revents & os.POLL.IN != 0) {
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
// stdout is ready.
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
const new_capacity = std.math.min(stdout.items.len + bump_amt, max_output_bytes);
Update all ensureCapacity calls to the relevant non-deprecated version
2021-09-16 18:22:04 -07:00
try stdout.ensureTotalCapacity(new_capacity);
std.ChildProcess: fix max_output_bytes handling The previous logic had a false positive of returning an error when in fact the maximum number of output bytes had not been exceeded.
2020-12-29 14:02:12 -07:00
const buf = stdout.unusedCapacitySlice();
if (buf.len == 0) return error.StdoutStreamTooLong;
overhaul elf csu (c-runtime startup) logic - more support for linux, android, freebsd, netbsd, openbsd, dragonfly - centralize musl utils; musl logic is no longer intertwined with csu - fix musl compilation to build crti/crtn for full archs list - fix openbsd to support `zig build-lib -dynamic` - initial dragonfly linking success (with a warning) ancillary: - fix emutls (openbsd) tests to use `try`
2021-05-16 15:59:34 -04:00
const nread = try os.read(poll_fds[0].fd, buf);
stdout.items.len += nread;
std: Better handing of POLLHUP in ChildProcess (#8988) * std: Better handing of POLLHUP in ChildProcess Upon hitting the EOF condition there are two main differences between how Linux and the *BSD-derived systems behave: the former sets POLLHUP and POLLIN and, after reading any residual data, only POLLHUP remains set. The latter signal the EOF condition by setting both flags thus requiring some extra checks to determine if the stream is "done". DragonFly workaround/hack for POLLHUP is no longer required. Closes #8969
2021-06-05 20:26:59 +02:00
// Remove the fd when the EOF condition is met.
remove_stdout = nread == 0;
} else {
remove_stdout = poll_fds[0].revents & err_mask != 0;
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
}
std: Better handing of POLLHUP in ChildProcess (#8988) * std: Better handing of POLLHUP in ChildProcess Upon hitting the EOF condition there are two main differences between how Linux and the *BSD-derived systems behave: the former sets POLLHUP and POLLIN and, after reading any residual data, only POLLHUP remains set. The latter signal the EOF condition by setting both flags thus requiring some extra checks to determine if the stream is "done". DragonFly workaround/hack for POLLHUP is no longer required. Closes #8969
2021-06-05 20:26:59 +02:00
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
if (poll_fds[1].revents & os.POLL.IN != 0) {
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
// stderr is ready.
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
const new_capacity = std.math.min(stderr.items.len + bump_amt, max_output_bytes);
Update all ensureCapacity calls to the relevant non-deprecated version
2021-09-16 18:22:04 -07:00
try stderr.ensureTotalCapacity(new_capacity);
std.ChildProcess: fix max_output_bytes handling The previous logic had a false positive of returning an error when in fact the maximum number of output bytes had not been exceeded.
2020-12-29 14:02:12 -07:00
const buf = stderr.unusedCapacitySlice();
if (buf.len == 0) return error.StderrStreamTooLong;
overhaul elf csu (c-runtime startup) logic - more support for linux, android, freebsd, netbsd, openbsd, dragonfly - centralize musl utils; musl logic is no longer intertwined with csu - fix musl compilation to build crti/crtn for full archs list - fix openbsd to support `zig build-lib -dynamic` - initial dragonfly linking success (with a warning) ancillary: - fix emutls (openbsd) tests to use `try`
2021-05-16 15:59:34 -04:00
const nread = try os.read(poll_fds[1].fd, buf);
stderr.items.len += nread;
std: Better handing of POLLHUP in ChildProcess (#8988) * std: Better handing of POLLHUP in ChildProcess Upon hitting the EOF condition there are two main differences between how Linux and the *BSD-derived systems behave: the former sets POLLHUP and POLLIN and, after reading any residual data, only POLLHUP remains set. The latter signal the EOF condition by setting both flags thus requiring some extra checks to determine if the stream is "done". DragonFly workaround/hack for POLLHUP is no longer required. Closes #8969
2021-06-05 20:26:59 +02:00
// Remove the fd when the EOF condition is met.
remove_stderr = nread == 0;
} else {
remove_stderr = poll_fds[1].revents & err_mask != 0;
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
}
// Exclude the fds that signaled an error.
std: Better handing of POLLHUP in ChildProcess (#8988) * std: Better handing of POLLHUP in ChildProcess Upon hitting the EOF condition there are two main differences between how Linux and the *BSD-derived systems behave: the former sets POLLHUP and POLLIN and, after reading any residual data, only POLLHUP remains set. The latter signal the EOF condition by setting both flags thus requiring some extra checks to determine if the stream is "done". DragonFly workaround/hack for POLLHUP is no longer required. Closes #8969
2021-06-05 20:26:59 +02:00
if (remove_stdout) {
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
poll_fds[0].fd = -1;
dead_fds += 1;
}
std: Better handing of POLLHUP in ChildProcess (#8988) * std: Better handing of POLLHUP in ChildProcess Upon hitting the EOF condition there are two main differences between how Linux and the *BSD-derived systems behave: the former sets POLLHUP and POLLIN and, after reading any residual data, only POLLHUP remains set. The latter signal the EOF condition by setting both flags thus requiring some extra checks to determine if the stream is "done". DragonFly workaround/hack for POLLHUP is no longer required. Closes #8969
2021-06-05 20:26:59 +02:00
if (remove_stderr) {
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
poll_fds[1].fd = -1;
dead_fds += 1;
}
}
}
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
fn collectOutputWindows(child: *const ChildProcess, outs: [2]*std.ArrayList(u8), max_output_bytes: usize) !void {
const bump_amt = 512;
const handles = [_]windows.HANDLE{
child.stdout.?.handle,
child.stderr.?.handle,
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
};
std: Uniform polling logic for Windows and Unix Keep polling until there are enough open handles, if the child process terminates closing the handles or explicitly closes them we just quit polling and wait for the process handle to signal the termination condition.
2020-10-21 16:54:38 +02:00
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
var overlapped = [_]windows.OVERLAPPED{
mem.zeroes(windows.OVERLAPPED),
mem.zeroes(windows.OVERLAPPED),
};
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
var wait_objects: [2]windows.HANDLE = undefined;
var wait_object_count: u2 = 0;
// we need to cancel all pending IO before returning so our OVERLAPPED values don't go out of scope
defer for (wait_objects[0..wait_object_count]) |o| {
_ = windows.kernel32.CancelIo(o);
};
// Windows Async IO requires an initial call to ReadFile before waiting on the handle
for ([_]u1{ 0, 1 }) |i| {
Improve ensureTotalCapacity call in ChildProcess.collectOutputWindows Take current len and max_output_bytes into account instead of unconditionally using bump_amt
2021-09-17 12:43:47 -07:00
const new_capacity = std.math.min(outs[i].items.len + bump_amt, max_output_bytes);
try outs[i].ensureTotalCapacity(new_capacity);
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
const buf = outs[i].unusedCapacitySlice();
_ = windows.kernel32.ReadFile(handles[i], buf.ptr, math.cast(u32, buf.len) catch maxInt(u32), null, &overlapped[i]);
wait_objects[wait_object_count] = handles[i];
wait_object_count += 1;
}
while (true) {
const status = windows.kernel32.WaitForMultipleObjects(wait_object_count, &wait_objects, 0, windows.INFINITE);
if (status == windows.WAIT_FAILED) {
switch (windows.kernel32.GetLastError()) {
else => |err| return windows.unexpectedError(err),
}
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
}
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
if (status < windows.WAIT_OBJECT_0 or status > windows.WAIT_OBJECT_0 + wait_object_count - 1)
unreachable;
const wait_idx = status - windows.WAIT_OBJECT_0;
// this extra `i` index is needed to map the wait handle back to the stdout or stderr
// values since the wait_idx can change which handle it corresponds with
const i: u1 = if (wait_objects[wait_idx] == handles[0]) 0 else 1;
// remove completed event from the wait list
wait_object_count -= 1;
if (wait_idx == 0)
wait_objects[0] = wait_objects[1];
var read_bytes: u32 = undefined;
if (windows.kernel32.GetOverlappedResult(handles[i], &overlapped[i], &read_bytes, 0) == 0) {
switch (windows.kernel32.GetLastError()) {
.BROKEN_PIPE => {
if (wait_object_count == 0)
break;
continue;
},
else => |err| return windows.unexpectedError(err),
}
}
outs[i].items.len += read_bytes;
const new_capacity = std.math.min(outs[i].items.len + bump_amt, max_output_bytes);
Update all ensureCapacity calls to the relevant non-deprecated version
2021-09-16 18:22:04 -07:00
try outs[i].ensureTotalCapacity(new_capacity);
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
const buf = outs[i].unusedCapacitySlice();
if (buf.len == 0) return if (i == 0) error.StdoutStreamTooLong else error.StderrStreamTooLong;
_ = windows.kernel32.ReadFile(handles[i], buf.ptr, math.cast(u32, buf.len) catch maxInt(u32), null, &overlapped[i]);
wait_objects[wait_object_count] = handles[i];
wait_object_count += 1;
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
}
}
expand argv[0] when spawning system C compiler Some C compilers, such as Clang, are known to rely on argv[0] to find the path to their own executable, without even bothering to resolve PATH. This results in the message: error: unable to execute command: Executable "" doesn't exist! So we tell ChildProcess to expand argv[0] to the absolute path to give them a helping hand.
2020-02-17 00:58:30 -05:00
/// Spawns a child process, waits for it, collecting stdout and stderr, and then returns.
/// If it succeeds, the caller owns result.stdout and result.stderr memory.
std lib API deprecations for the upcoming 0.6.0 release See #3811
2020-03-30 14:23:22 -04:00
pub fn exec(args: struct {
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
allocator: mem.Allocator,
expand argv[0] when spawning system C compiler Some C compilers, such as Clang, are known to rely on argv[0] to find the path to their own executable, without even bothering to resolve PATH. This results in the message: error: unable to execute command: Executable "" doesn't exist! So we tell ChildProcess to expand argv[0] to the absolute path to give them a helping hand.
2020-02-17 00:58:30 -05:00
argv: []const []const u8,
cwd: ?[]const u8 = null,
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
cwd_dir: ?fs.Dir = null,
expand argv[0] when spawning system C compiler Some C compilers, such as Clang, are known to rely on argv[0] to find the path to their own executable, without even bothering to resolve PATH. This results in the message: error: unable to execute command: Executable "" doesn't exist! So we tell ChildProcess to expand argv[0] to the absolute path to give them a helping hand.
2020-02-17 00:58:30 -05:00
env_map: ?*const BufMap = null,
max_output_bytes: usize = 50 * 1024,
expand_arg0: Arg0Expand = .no_expand,
}) !ExecResult {
const child = try ChildProcess.init(args.argv, args.allocator);
self-hosted: move code to std.os.ChildProcess.exec
2017-12-12 14:35:53 -05:00
defer child.deinit();
expand argv[0] when spawning system C compiler Some C compilers, such as Clang, are known to rely on argv[0] to find the path to their own executable, without even bothering to resolve PATH. This results in the message: error: unable to execute command: Executable "" doesn't exist! So we tell ChildProcess to expand argv[0] to the absolute path to give them a helping hand.
2020-02-17 00:58:30 -05:00
child.stdin_behavior = .Ignore;
child.stdout_behavior = .Pipe;
child.stderr_behavior = .Pipe;
child.cwd = args.cwd;
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
child.cwd_dir = args.cwd_dir;
expand argv[0] when spawning system C compiler Some C compilers, such as Clang, are known to rely on argv[0] to find the path to their own executable, without even bothering to resolve PATH. This results in the message: error: unable to execute command: Executable "" doesn't exist! So we tell ChildProcess to expand argv[0] to the absolute path to give them a helping hand.
2020-02-17 00:58:30 -05:00
child.env_map = args.env_map;
child.expand_arg0 = args.expand_arg0;
self-hosted: move code to std.os.ChildProcess.exec
2017-12-12 14:35:53 -05:00
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 16:51:46 -05:00
try child.spawn();
self-hosted: move code to std.os.ChildProcess.exec
2017-12-12 14:35:53 -05:00
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
// TODO collect output in a deadlock-avoiding way on Windows.
// https://github.com/ziglang/zig/issues/6343
actually fix child process deadlock on windows Looks like I forgot to remove windows from this workaround condition when I finished implementing the child process output collection on windows.
2021-10-16 18:51:50 -06:00
if (builtin.os.tag == .haiku) {
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
const stdout_in = child.stdout.?.reader();
const stderr_in = child.stderr.?.reader();
const stdout = try stdout_in.readAllAlloc(args.allocator, args.max_output_bytes);
errdefer args.allocator.free(stdout);
const stderr = try stderr_in.readAllAlloc(args.allocator, args.max_output_bytes);
errdefer args.allocator.free(stderr);
return ExecResult{
.term = try child.wait(),
.stdout = stdout,
.stderr = stderr,
};
}
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
var stdout = std.ArrayList(u8).init(args.allocator);
var stderr = std.ArrayList(u8).init(args.allocator);
std: Better handing of POLLHUP in ChildProcess (#8988) * std: Better handing of POLLHUP in ChildProcess Upon hitting the EOF condition there are two main differences between how Linux and the *BSD-derived systems behave: the former sets POLLHUP and POLLIN and, after reading any residual data, only POLLHUP remains set. The latter signal the EOF condition by setting both flags thus requiring some extra checks to determine if the stream is "done". DragonFly workaround/hack for POLLHUP is no longer required. Closes #8969
2021-06-05 20:26:59 +02:00
errdefer {
stdout.deinit();
stderr.deinit();
}
self-hosted: move code to std.os.ChildProcess.exec
2017-12-12 14:35:53 -05:00
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
if (builtin.os.tag == .windows) {
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
try collectOutputWindows(child, [_]*std.ArrayList(u8){ &stdout, &stderr }, args.max_output_bytes);
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
} else {
try collectOutputPosix(child, &stdout, &stderr, args.max_output_bytes);
}
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
return ExecResult{
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 16:51:46 -05:00
.term = try child.wait(),
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
.stdout = stdout.toOwnedSlice(),
.stderr = stderr.toOwnedSlice(),
self-hosted: move code to std.os.ChildProcess.exec
2017-12-12 14:35:53 -05:00
};
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
fn waitWindows(self: *ChildProcess) !Term {
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
if (self.term) |term| {
self.cleanupStreams();
return term;
}
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 16:51:46 -05:00
try self.waitUnwrappedWindows();
breaking syntax change: ??x to x.? (#1095) See #1023 This also renames Nullable/Maybe to Optional
2018-06-09 23:42:14 -04:00
return self.term.?;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
fn waitPosix(self: *ChildProcess) !Term {
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
if (self.term) |term| {
std.os.ChildProcess: fix fd leak
2017-09-16 21:07:02 -04:00
self.cleanupStreams();
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
return term;
}
self.waitUnwrapped();
breaking syntax change: ??x to x.? (#1095) See #1023 This also renames Nullable/Maybe to Optional
2018-06-09 23:42:14 -04:00
return self.term.?;
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
pub fn deinit(self: *ChildProcess) void {
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
self.allocator.destroy(self);
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
fn waitUnwrappedWindows(self: *ChildProcess) !void {
std: add alertable argument for windows.WaitForSingleObject
2019-11-19 16:31:24 +11:00
const result = windows.WaitForSingleObjectEx(self.handle, windows.INFINITE, false);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
fix type cast in windows child process code
2019-11-08 17:05:20 -05:00
self.term = @as(SpawnError!Term, x: {
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
var exit_code: windows.DWORD = undefined;
std lib fixes for zig build on windows
2019-05-27 02:00:39 -04:00
if (windows.kernel32.GetExitCodeProcess(self.handle, &exit_code) == 0) {
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
break :x Term{ .Unknown = 0 };
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
} else {
Make std.ChildProcess exit code u8 to match std.process.exit This patch adjusts the exit code for a child process to be a u8. Since the WEXITSTATUS macro returns the lower eight bits, it's safe to assume that we can truncate the returned u32.
2021-03-24 18:27:56 -07:00
break :x Term{ .Exited = @truncate(u8, exit_code) };
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
});
fix windows build from previous commit
2017-10-31 22:24:02 -04:00
os.close(self.handle);
os.close(self.thread_handle);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
self.cleanupStreams();
return result;
}
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
fn waitUnwrapped(self: *ChildProcess) void {
rename WaitpidRet to WaitPidResult
2020-10-16 18:14:39 -07:00
const status = os.waitpid(self.pid, 0).status;
starting to fix the regressions
2019-05-24 22:52:07 -04:00
self.cleanupStreams();
rename WaitpidRet to WaitPidResult
2020-10-16 18:14:39 -07:00
self.handleWaitResult(status);
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
}
tests passing on linux
2019-05-26 23:35:26 -04:00
fn handleWaitResult(self: *ChildProcess, status: u32) void {
update uses of deprecated type field access
2020-09-03 18:09:55 +03:00
self.term = self.cleanupAfterWait(status);
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
}
API for command line args closes #300
2017-04-04 00:17:24 -04:00
use * for pointer type instead of & See #770 To help automatically translate code, see the zig-fmt-pointer-reform-2 branch. This will convert all & into *. Due to the syntax ambiguity (which is why we are making this change), even address-of & will turn into *, so you'll have to manually fix thes instances. You will be guaranteed to get compile errors for them - expected 'type', found 'foo'
2018-05-31 10:56:59 -04:00
fn cleanupStreams(self: *ChildProcess) void {
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
if (self.stdin) |*stdin| {
stdin.close();
self.stdin = null;
}
if (self.stdout) |*stdout| {
stdout.close();
self.stdout = null;
}
if (self.stderr) |*stderr| {
stderr.close();
self.stderr = null;
}
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
}
tests passing on linux
2019-05-26 23:35:26 -04:00
fn cleanupAfterWait(self: *ChildProcess, status: u32) !Term {
Revert "Revert "Use eventfd in ChildProcess on Linux"" This reverts commit 2c7a2aefbfd0dbab190f912b4fbcbda96fb5ac44.
2019-12-16 10:56:53 +01:00
defer destroyPipe(self.err_pipe);
API for command line args closes #300
2017-04-04 00:17:24 -04:00
introduce operating system version ranges as part of the target * re-introduce `std.build.Target` which is distinct from `std.Target`. `std.build.Target` wraps `std.Target` so that it can be annotated as "the native target" or an explicitly specified target. * `std.Target.Os` is moved to `std.Target.Os.Tag`. The former is now a struct which has the tag as well as version range information. * `std.elf` gains some more ELF header constants. * `std.Target.parse` gains the ability to parse operating system version ranges as well as glibc version. * Added `std.Target.isGnuLibC()`. * self-hosted dynamic linker detection and glibc version detection. This also adds the improved logic using `/usr/bin/env` rather than invoking the system C compiler to find the dynamic linker when zig is statically linked. Related: #2084 Note: this `/usr/bin/env` code is work-in-progress. * `-target-glibc` CLI option is removed in favor of the new `-target` syntax. Example: `-target x86_64-linux-gnu.2.27` closes #1907
2020-02-25 01:52:27 -05:00
if (builtin.os.tag == .linux) {
Fix for the error codepath in ChildProcess
2019-12-16 10:57:29 +01:00
var fd = [1]std.os.pollfd{std.os.pollfd{
.fd = self.err_pipe[0],
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
.events = std.os.POLL.IN,
Fix for the error codepath in ChildProcess
2019-12-16 10:57:29 +01:00
.revents = undefined,
}};
// Check if the eventfd buffer stores a non-zero value by polling
// it, that's the error code returned by the child process.
_ = std.os.poll(&fd, 0) catch unreachable;
// According to eventfd(2) the descriptro is readable if the counter
// has a value greater than 0
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
if ((fd[0].revents & std.os.POLL.IN) != 0) {
Fix for the error codepath in ChildProcess
2019-12-16 10:57:29 +01:00
const err_int = try readIntFd(self.err_pipe[0]);
return @errSetCast(SpawnError, @intToError(err_int));
}
} else {
// Write maxInt(ErrInt) to the write end of the err_pipe. This is after
// waitpid, so this write is guaranteed to be after the child
// pid potentially wrote an error. This way we can do a blocking
// read on the error pipe and either get maxInt(ErrInt) (no error) or
// an error code.
try writeIntFd(self.err_pipe[1], maxInt(ErrInt));
const err_int = try readIntFd(self.err_pipe[0]);
// Here we potentially return the fork child's error from the parent
// pid.
if (err_int != maxInt(ErrInt)) {
return @errSetCast(SpawnError, @intToError(err_int));
}
API for command line args closes #300
2017-04-04 00:17:24 -04:00
}
return statusToTerm(status);
}
tests passing on linux
2019-05-26 23:35:26 -04:00
fn statusToTerm(status: u32) Term {
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
return if (os.W.IFEXITED(status))
Term{ .Exited = os.W.EXITSTATUS(status) }
else if (os.W.IFSIGNALED(status))
Term{ .Signal = os.W.TERMSIG(status) }
else if (os.W.IFSTOPPED(status))
Term{ .Stopped = os.W.STOPSIG(status) }
explicitly return from blocks instead of last statement being expression value closes #629
2017-12-22 00:50:30 -05:00
else
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
Term{ .Unknown = status };
API for command line args closes #300
2017-04-04 00:17:24 -04:00
}
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
fn spawnPosix(self: *ChildProcess) SpawnError!void {
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
const pipe_flags = if (io.is_async) os.O.NONBLOCK else 0;
more std lib async I/O integration * `zig test` gainst `--test-evented-io` parameter and gains the ability to seamlessly run async tests. * `std.ChildProcess` opens its child process pipe with O_NONBLOCK when using evented I/O * `std.io.getStdErr()` gives a File that is blocking even in evented I/O mode. * Delete `std.event.fs`. The functionality is now merged into `std.fs` and async file system access (using a dedicated thread) is automatically handled. * `std.fs.File` can be configured to specify whether its handle is expected to block, and whether that is OK to block even when in async I/O mode. This makes async I/O work correctly for e.g. the file system as well as network. * `std.fs.File` has some deprecated functions removed. * Missing readv,writev,pread,pwrite,preadv,pwritev functions are added to `std.os` and `std.fs.File`. They are all integrated with async I/O. * `std.fs.Watch` is still bit rotted and needs to be audited in light of the new async/await syntax. * `std.io.OutStream` integrates with async I/O * linked list nodes in the std lib have default `null` values for `prev` and `next`. * Windows async I/O integration is enabled for reading/writing file handles. * Added `std.os.mode_t`. Integer sizes need to be audited. * Fixed #4403 which was causing compiler to crash. This is working towards: ./zig test ../test/stage1/behavior.zig --test-evented-io Which does not successfully build yet. I'd like to enable behavioral tests and std lib tests with --test-evented-io in the test matrix in the future, to prevent regressions.
2020-02-06 17:56:40 -05:00
const stdin_pipe = if (self.stdin_behavior == StdIo.Pipe) try os.pipe2(pipe_flags) else undefined;
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
errdefer if (self.stdin_behavior == StdIo.Pipe) {
destroyPipe(stdin_pipe);
};
API for command line args closes #300
2017-04-04 00:17:24 -04:00
more std lib async I/O integration * `zig test` gainst `--test-evented-io` parameter and gains the ability to seamlessly run async tests. * `std.ChildProcess` opens its child process pipe with O_NONBLOCK when using evented I/O * `std.io.getStdErr()` gives a File that is blocking even in evented I/O mode. * Delete `std.event.fs`. The functionality is now merged into `std.fs` and async file system access (using a dedicated thread) is automatically handled. * `std.fs.File` can be configured to specify whether its handle is expected to block, and whether that is OK to block even when in async I/O mode. This makes async I/O work correctly for e.g. the file system as well as network. * `std.fs.File` has some deprecated functions removed. * Missing readv,writev,pread,pwrite,preadv,pwritev functions are added to `std.os` and `std.fs.File`. They are all integrated with async I/O. * `std.fs.Watch` is still bit rotted and needs to be audited in light of the new async/await syntax. * `std.io.OutStream` integrates with async I/O * linked list nodes in the std lib have default `null` values for `prev` and `next`. * Windows async I/O integration is enabled for reading/writing file handles. * Added `std.os.mode_t`. Integer sizes need to be audited. * Fixed #4403 which was causing compiler to crash. This is working towards: ./zig test ../test/stage1/behavior.zig --test-evented-io Which does not successfully build yet. I'd like to enable behavioral tests and std lib tests with --test-evented-io in the test matrix in the future, to prevent regressions.
2020-02-06 17:56:40 -05:00
const stdout_pipe = if (self.stdout_behavior == StdIo.Pipe) try os.pipe2(pipe_flags) else undefined;
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
errdefer if (self.stdout_behavior == StdIo.Pipe) {
destroyPipe(stdout_pipe);
};
API for command line args closes #300
2017-04-04 00:17:24 -04:00
more std lib async I/O integration * `zig test` gainst `--test-evented-io` parameter and gains the ability to seamlessly run async tests. * `std.ChildProcess` opens its child process pipe with O_NONBLOCK when using evented I/O * `std.io.getStdErr()` gives a File that is blocking even in evented I/O mode. * Delete `std.event.fs`. The functionality is now merged into `std.fs` and async file system access (using a dedicated thread) is automatically handled. * `std.fs.File` can be configured to specify whether its handle is expected to block, and whether that is OK to block even when in async I/O mode. This makes async I/O work correctly for e.g. the file system as well as network. * `std.fs.File` has some deprecated functions removed. * Missing readv,writev,pread,pwrite,preadv,pwritev functions are added to `std.os` and `std.fs.File`. They are all integrated with async I/O. * `std.fs.Watch` is still bit rotted and needs to be audited in light of the new async/await syntax. * `std.io.OutStream` integrates with async I/O * linked list nodes in the std lib have default `null` values for `prev` and `next`. * Windows async I/O integration is enabled for reading/writing file handles. * Added `std.os.mode_t`. Integer sizes need to be audited. * Fixed #4403 which was causing compiler to crash. This is working towards: ./zig test ../test/stage1/behavior.zig --test-evented-io Which does not successfully build yet. I'd like to enable behavioral tests and std lib tests with --test-evented-io in the test matrix in the future, to prevent regressions.
2020-02-06 17:56:40 -05:00
const stderr_pipe = if (self.stderr_behavior == StdIo.Pipe) try os.pipe2(pipe_flags) else undefined;
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
errdefer if (self.stderr_behavior == StdIo.Pipe) {
destroyPipe(stderr_pipe);
};
API for command line args closes #300
2017-04-04 00:17:24 -04:00
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
const any_ignore = (self.stdin_behavior == StdIo.Ignore or self.stdout_behavior == StdIo.Ignore or self.stderr_behavior == StdIo.Ignore);
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
const dev_null_fd = if (any_ignore)
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
os.openZ("/dev/null", os.O.RDWR, 0) catch |err| switch (err) {
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
error.PathAlreadyExists => unreachable,
error.NoSpaceLeft => unreachable,
error.FileTooBig => unreachable,
error.DeviceBusy => unreachable,
Fix compile errors in stage2
2020-04-02 23:39:25 -06:00
error.FileLocksNotSupported => unreachable,
Add prelim `openW` and `openatW` Added POSIX functions targeting Windows pass `open` and `openat` smoke tests.
2020-07-31 00:54:33 +02:00
error.BadPathName => unreachable, // Windows-only
std: Fix file locking logic for BSD targets
2020-11-22 23:28:40 +01:00
error.WouldBlock => unreachable,
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
else => |e| return e,
}
else
undefined;
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
defer {
if (any_ignore) os.close(dev_null_fd);
}
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
var arena_allocator = std.heap.ArenaAllocator.init(self.allocator);
defer arena_allocator.deinit();
allocgate: renamed getAllocator function to allocator
2021-10-29 02:08:41 +01:00
const arena = arena_allocator.allocator();
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
// The POSIX standard does not allow malloc() between fork() and execve(),
// and `self.allocator` may be a libc allocator.
// I have personally observed the child process deadlocking when it tries
// to call malloc() due to a heap allocation between fork() and execve(),
// in musl v1.1.24.
// Additionally, we want to reduce the number of possible ways things
// can fail between fork() and execve().
// Therefore, we do all the allocation for the execve() before the fork().
// This means we must do the null-termination of argv and env vars here.
std: clean up sentinel handling for argv/environ
2020-12-27 13:00:35 +01:00
const argv_buf = try arena.allocSentinel(?[*:0]u8, self.argv.len, null);
for (self.argv) |arg, i| argv_buf[i] = (try arena.dupeZ(u8, arg)).ptr;
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
const envp = m: {
if (self.env_map) |env_map| {
const envp_buf = try createNullDelimitedEnvMap(arena, env_map);
break :m envp_buf.ptr;
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
} else if (builtin.link_libc) {
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
break :m std.c.environ;
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
} else if (builtin.output_mode == .Exe) {
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
// Then we have Zig start code and this works.
// TODO type-safety for null-termination of `os.environ`.
break :m @ptrCast([*:null]?[*:0]u8, os.environ.ptr);
} else {
// TODO come up with a solution for this.
@compileError("missing std lib enhancement: ChildProcess implementation has no way to collect the environment variables to forward to the child process");
}
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
};
API for command line args closes #300
2017-04-04 00:17:24 -04:00
// This pipe is used to communicate errors between the time of fork
// and execve from the child process to the parent process.
Revert "Revert "Use eventfd in ChildProcess on Linux"" This reverts commit 2c7a2aefbfd0dbab190f912b4fbcbda96fb5ac44.
2019-12-16 10:56:53 +01:00
const err_pipe = blk: {
introduce operating system version ranges as part of the target * re-introduce `std.build.Target` which is distinct from `std.Target`. `std.build.Target` wraps `std.Target` so that it can be annotated as "the native target" or an explicitly specified target. * `std.Target.Os` is moved to `std.Target.Os.Tag`. The former is now a struct which has the tag as well as version range information. * `std.elf` gains some more ELF header constants. * `std.Target.parse` gains the ability to parse operating system version ranges as well as glibc version. * Added `std.Target.isGnuLibC()`. * self-hosted dynamic linker detection and glibc version detection. This also adds the improved logic using `/usr/bin/env` rather than invoking the system C compiler to find the dynamic linker when zig is statically linked. Related: #2084 Note: this `/usr/bin/env` code is work-in-progress. * `-target-glibc` CLI option is removed in favor of the new `-target` syntax. Example: `-target x86_64-linux-gnu.2.27` closes #1907
2020-02-25 01:52:27 -05:00
if (builtin.os.tag == .linux) {
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
const fd = try os.eventfd(0, linux.EFD.CLOEXEC);
Revert "Revert "Use eventfd in ChildProcess on Linux"" This reverts commit 2c7a2aefbfd0dbab190f912b4fbcbda96fb5ac44.
2019-12-16 10:56:53 +01:00
// There's no distinction between the readable and the writeable
// end with eventfd
break :blk [2]os.fd_t{ fd, fd };
} else {
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
break :blk try os.pipe2(os.O.CLOEXEC);
Revert "Revert "Use eventfd in ChildProcess on Linux"" This reverts commit 2c7a2aefbfd0dbab190f912b4fbcbda96fb5ac44.
2019-12-16 10:56:53 +01:00
}
};
replace %defer with errdefer See #632 now we have 1 less sigil
2018-01-23 23:08:09 -05:00
errdefer destroyPipe(err_pipe);
API for command line args closes #300
2017-04-04 00:17:24 -04:00
clean up references to posix
2019-05-25 13:07:44 -04:00
const pid_result = try os.fork();
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
if (pid_result == 0) {
API for command line args closes #300
2017-04-04 00:17:24 -04:00
// we are the child
clean up references to posix
2019-05-25 13:07:44 -04:00
setUpChildIo(self.stdin_behavior, stdin_pipe[0], os.STDIN_FILENO, dev_null_fd) catch |err| forkChildErrReport(err_pipe[1], err);
setUpChildIo(self.stdout_behavior, stdout_pipe[1], os.STDOUT_FILENO, dev_null_fd) catch |err| forkChildErrReport(err_pipe[1], err);
setUpChildIo(self.stderr_behavior, stderr_pipe[1], os.STDERR_FILENO, dev_null_fd) catch |err| forkChildErrReport(err_pipe[1], err);
API for command line args closes #300
2017-04-04 00:17:24 -04:00
clean up references to posix
2019-05-25 13:07:44 -04:00
if (self.stdin_behavior == .Pipe) {
fix child_process piped streams not getting closed
2018-11-28 18:33:55 -05:00
os.close(stdin_pipe[0]);
os.close(stdin_pipe[1]);
}
clean up references to posix
2019-05-25 13:07:44 -04:00
if (self.stdout_behavior == .Pipe) {
fix child_process piped streams not getting closed
2018-11-28 18:33:55 -05:00
os.close(stdout_pipe[0]);
os.close(stdout_pipe[1]);
}
clean up references to posix
2019-05-25 13:07:44 -04:00
if (self.stderr_behavior == .Pipe) {
fix child_process piped streams not getting closed
2018-11-28 18:33:55 -05:00
os.close(stderr_pipe[0]);
os.close(stderr_pipe[1]);
}
add ZIR compare output test case to test suite
2020-04-27 18:26:59 -04:00
if (self.cwd_dir) |cwd| {
os.fchdir(cwd.fd) catch |err| forkChildErrReport(err_pipe[1], err);
} else if (self.cwd) |cwd| {
clean up references to os
2019-05-26 13:17:34 -04:00
os.chdir(cwd) catch |err| forkChildErrReport(err_pipe[1], err);
zig build: organize build artifacts closes #328
2017-04-30 18:56:24 -04:00
}
std.os.ChildProcess: ability to set both uid and gid
2017-09-26 02:42:06 -04:00
if (self.gid) |gid| {
clean up references to os
2019-05-26 13:17:34 -04:00
os.setregid(gid, gid) catch |err| forkChildErrReport(err_pipe[1], err);
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
}
std.os.ChildProcess: setgid before setuid otherwise we thwart our permissions to setuid
2017-09-26 03:17:35 -04:00
if (self.uid) |uid| {
clean up references to os
2019-05-26 13:17:34 -04:00
os.setreuid(uid, uid) catch |err| forkChildErrReport(err_pipe[1], err);
std.os.ChildProcess: setgid before setuid otherwise we thwart our permissions to setuid
2017-09-26 03:17:35 -04:00
}
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
const err = switch (self.expand_arg0) {
std: clean up sentinel handling for argv/environ
2020-12-27 13:00:35 +01:00
.expand => os.execvpeZ_expandArg0(.expand, argv_buf.ptr[0].?, argv_buf.ptr, envp),
.no_expand => os.execvpeZ_expandArg0(.no_expand, argv_buf.ptr[0].?, argv_buf.ptr, envp),
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
};
[breaking] standardize std.os execve functions * `std.os.execve` had the wrong name; it should have been `std.os.execvpe`. This is now corrected. * introduce `std.os.execveC` which does not look at PATH, and uses null terminated parameters, matching POSIX ABIs. It does not require an allocator. * fix typo nonsense doc comment in `std.fs.MAX_PATH_BYTES`. * introduce `std.os.execvpeC`, which is like `execvpe` except it uses null terminated parameters, matching POSIX ABIs, and thus does not require an allocator. * `std.os.execvpe` implementation is reworked to only convert parameters and then delegate to `std.os.execvpeC`. * `std.os.execvpeC` improved to handle `ENOTDIR`. See #3415
2019-10-16 15:10:38 -04:00
forkChildErrReport(err_pipe[1], err);
API for command line args closes #300
2017-04-04 00:17:24 -04:00
}
// we are the parent
remove integer and float casting syntax * add `@intCast` * add `@floatCast` * add `@floatToInt` * add `@intToFloat` See #1061
2018-06-17 02:57:07 -04:00
const pid = @intCast(i32, pid_result);
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
if (self.stdin_behavior == StdIo.Pipe) {
cleanup and fixes. behavior tests passing with evented I/O
2020-05-01 23:17:15 -04:00
self.stdin = File{ .handle = stdin_pipe[1] };
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
} else {
self.stdin = null;
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
}
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
if (self.stdout_behavior == StdIo.Pipe) {
cleanup and fixes. behavior tests passing with evented I/O
2020-05-01 23:17:15 -04:00
self.stdout = File{ .handle = stdout_pipe[0] };
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
} else {
self.stdout = null;
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
}
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
if (self.stderr_behavior == StdIo.Pipe) {
cleanup and fixes. behavior tests passing with evented I/O
2020-05-01 23:17:15 -04:00
self.stderr = File{ .handle = stderr_pipe[0] };
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
} else {
self.stderr = null;
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
}
update std.os.ChildProcess API * add std.os.ChildProcess.setUserName * add std.os.getUserId
2017-09-26 01:01:49 -04:00
self.pid = pid;
self.err_pipe = err_pipe;
self.term = null;
std: os.ChildProcess knows when its child died using signal handlers
2017-09-07 23:10:23 -04:00
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
if (self.stdin_behavior == StdIo.Pipe) {
os.close(stdin_pipe[0]);
}
if (self.stdout_behavior == StdIo.Pipe) {
os.close(stdout_pipe[1]);
}
if (self.stderr_behavior == StdIo.Pipe) {
os.close(stderr_pipe[1]);
}
API for command line args closes #300
2017-04-04 00:17:24 -04:00
}
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
fn spawnWindows(self: *ChildProcess) SpawnError!void {
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
const saAttr = windows.SECURITY_ATTRIBUTES{
use correct integer type for windows BOOL
2017-10-15 14:01:55 -04:00
.nLength = @sizeOf(windows.SECURITY_ATTRIBUTES),
.bInheritHandle = windows.TRUE,
.lpSecurityDescriptor = null,
};
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
const any_ignore = (self.stdin_behavior == StdIo.Ignore or self.stdout_behavior == StdIo.Ignore or self.stderr_behavior == StdIo.Ignore);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
const nul_handle = if (any_ignore)
std.ChildProcess: bypass libc exit() in fork child error case Comment reproduced here: If we're linking libc, some naughty applications may have registered atexit handlers which we really do not want to run in the fork child. I caught LLVM doing this and it caused a deadlock instead of doing an exit syscall. In the words of Avril Lavigne, "Why'd you have to go and make things so complicated?"
2020-09-28 22:17:50 -07:00
// "\Device\Null" or "\??\NUL"
std.ChildProcess: use "\Device\Null" on Windows
2020-09-03 08:51:10 +02:00
windows.OpenFile(&[_]u16{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'N', 'u', 'l', 'l' }, .{
Fix opening NUL device on Windows
2020-07-31 19:16:04 +02:00
.access_mask = windows.GENERIC_READ | windows.SYNCHRONIZE,
Remove CreateDirectoryW and CreateFileW calls Replace them with `std.os.windows.OpenFile` instead. To allow creation/opening of directories, `std.os.windows.OpenFileOptions` now features a `.expect_dir: bool` member which is meant to emualate POSIX's `O_DIRECTORY` flag.
2020-07-30 17:00:50 +02:00
.share_access = windows.FILE_SHARE_READ,
.creation = windows.OPEN_EXISTING,
.io_mode = .blocking,
}) catch |err| switch (err) {
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
error.PathAlreadyExists => unreachable, // not possible for "NUL"
error.PipeBusy => unreachable, // not possible for "NUL"
error.FileNotFound => unreachable, // not possible for "NUL"
error.AccessDenied => unreachable, // not possible for "NUL"
error.NameTooLong => unreachable, // not possible for "NUL"
Remove CreateDirectoryW and CreateFileW calls Replace them with `std.os.windows.OpenFile` instead. To allow creation/opening of directories, `std.os.windows.OpenFileOptions` now features a `.expect_dir: bool` member which is meant to emualate POSIX's `O_DIRECTORY` flag.
2020-07-30 17:00:50 +02:00
error.WouldBlock => unreachable, // not possible for "NUL"
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
else => |e| return e,
}
else
undefined;
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
defer {
if (any_ignore) os.close(nul_handle);
}
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
if (any_ignore) {
std lib fixes for zig build on windows
2019-05-27 02:00:39 -04:00
try windows.SetHandleInformation(nul_handle, windows.HANDLE_FLAG_INHERIT, 0);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
var g_hChildStd_IN_Rd: ?windows.HANDLE = null;
var g_hChildStd_IN_Wr: ?windows.HANDLE = null;
switch (self.stdin_behavior) {
StdIo.Pipe => {
fix windows
2018-10-15 21:38:01 -04:00
try windowsMakePipeIn(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
},
StdIo.Ignore => {
g_hChildStd_IN_Rd = nul_handle;
},
StdIo.Inherit => {
std lib fixes for zig build on windows
2019-05-27 02:00:39 -04:00
g_hChildStd_IN_Rd = windows.GetStdHandle(windows.STD_INPUT_HANDLE) catch null;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
},
StdIo.Close => {
g_hChildStd_IN_Rd = null;
},
}
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
errdefer if (self.stdin_behavior == StdIo.Pipe) {
windowsDestroyPipe(g_hChildStd_IN_Rd, g_hChildStd_IN_Wr);
};
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
var g_hChildStd_OUT_Rd: ?windows.HANDLE = null;
var g_hChildStd_OUT_Wr: ?windows.HANDLE = null;
switch (self.stdout_behavior) {
StdIo.Pipe => {
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
try windowsMakeAsyncPipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
},
StdIo.Ignore => {
g_hChildStd_OUT_Wr = nul_handle;
},
StdIo.Inherit => {
std lib fixes for zig build on windows
2019-05-27 02:00:39 -04:00
g_hChildStd_OUT_Wr = windows.GetStdHandle(windows.STD_OUTPUT_HANDLE) catch null;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
},
StdIo.Close => {
g_hChildStd_OUT_Wr = null;
},
}
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
errdefer if (self.stdin_behavior == StdIo.Pipe) {
windowsDestroyPipe(g_hChildStd_OUT_Rd, g_hChildStd_OUT_Wr);
};
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
var g_hChildStd_ERR_Rd: ?windows.HANDLE = null;
var g_hChildStd_ERR_Wr: ?windows.HANDLE = null;
switch (self.stderr_behavior) {
StdIo.Pipe => {
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
try windowsMakeAsyncPipe(&g_hChildStd_ERR_Rd, &g_hChildStd_ERR_Wr, &saAttr);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
},
StdIo.Ignore => {
g_hChildStd_ERR_Wr = nul_handle;
},
StdIo.Inherit => {
std lib fixes for zig build on windows
2019-05-27 02:00:39 -04:00
g_hChildStd_ERR_Wr = windows.GetStdHandle(windows.STD_ERROR_HANDLE) catch null;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
},
StdIo.Close => {
g_hChildStd_ERR_Wr = null;
},
}
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
errdefer if (self.stdin_behavior == StdIo.Pipe) {
windowsDestroyPipe(g_hChildStd_ERR_Rd, g_hChildStd_ERR_Wr);
};
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 16:51:46 -05:00
const cmd_line = try windowsCreateCommandLine(self.allocator, self.argv);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
defer self.allocator.free(cmd_line);
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
var siStartInfo = windows.STARTUPINFOW{
switch most windows calls to use W versions instead of A See #534
2018-09-02 23:25:04 -04:00
.cb = @sizeOf(windows.STARTUPINFOW),
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
.hStdError = g_hChildStd_ERR_Wr,
.hStdOutput = g_hChildStd_OUT_Wr,
.hStdInput = g_hChildStd_IN_Rd,
.dwFlags = windows.STARTF_USESTDHANDLES,
.lpReserved = null,
.lpDesktop = null,
.lpTitle = null,
.dwX = 0,
.dwY = 0,
.dwXSize = 0,
.dwYSize = 0,
.dwXCountChars = 0,
.dwYCountChars = 0,
.dwFillAttribute = 0,
.wShowWindow = 0,
.cbReserved2 = 0,
.lpReserved2 = null,
};
var piProcInfo: windows.PROCESS_INFORMATION = undefined;
std: sentinel terminated pointers for utf16 apis
2019-12-28 16:40:59 +11:00
const cwd_w = if (self.cwd) |cwd| try unicode.utf8ToUtf16LeWithNull(self.allocator, cwd) else null;
switch most windows calls to use W versions instead of A See #534
2018-09-02 23:25:04 -04:00
defer if (cwd_w) |cwd| self.allocator.free(cwd);
const cwd_w_ptr = if (cwd_w) |cwd| cwd.ptr else null;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
more progress. moving windows API layer to its own file
2019-05-24 00:13:13 -04:00
const maybe_envp_buf = if (self.env_map) |env_map| try createWindowsEnvBlock(self.allocator, env_map) else null;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
defer if (maybe_envp_buf) |envp_buf| self.allocator.free(envp_buf);
const envp_ptr = if (maybe_envp_buf) |envp_buf| envp_buf.ptr else null;
std.os.ChildProcess: on windows cwd affects exe search path to match posix semantics disabling non-passing build-examples tests. See #538
2017-10-16 02:27:51 -04:00
// the cwd set in ChildProcess is in effect when choosing the executable path
// to match posix semantics
Fix std.child_process.ChildProcess.spawnWindow when looking in PATH environment variable, it applied cwd+app_name instead of just using the app_name
2020-01-10 19:25:26 -05:00
const app_path = x: {
fix darwin and windows from previous commit
2017-12-22 02:33:39 -05:00
if (self.cwd) |cwd| {
fix regressions on windows
2019-12-01 21:31:00 -05:00
const resolved = try fs.path.resolve(self.allocator, &[_][]const u8{ cwd, self.argv[0] });
fix darwin and windows from previous commit
2017-12-22 02:33:39 -05:00
defer self.allocator.free(resolved);
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 16:51:46 -05:00
break :x try cstr.addNullByte(self.allocator, resolved);
fix darwin and windows from previous commit
2017-12-22 02:33:39 -05:00
} else {
replace `%return` with `try` See #632 better fits the convention of using keywords for control flow
2018-01-07 16:51:46 -05:00
break :x try cstr.addNullByte(self.allocator, self.argv[0]);
fix darwin and windows from previous commit
2017-12-22 02:33:39 -05:00
}
std.os.ChildProcess: on windows cwd affects exe search path to match posix semantics disabling non-passing build-examples tests. See #538
2017-10-16 02:27:51 -04:00
};
Fix std.child_process.ChildProcess.spawnWindow when looking in PATH environment variable, it applied cwd+app_name instead of just using the app_name
2020-01-10 19:25:26 -05:00
defer self.allocator.free(app_path);
std.os.ChildProcess: on windows cwd affects exe search path to match posix semantics disabling non-passing build-examples tests. See #538
2017-10-16 02:27:51 -04:00
Fix std.child_process.ChildProcess.spawnWindow when looking in PATH environment variable, it applied cwd+app_name instead of just using the app_name
2020-01-10 19:25:26 -05:00
const app_path_w = try unicode.utf8ToUtf16LeWithNull(self.allocator, app_path);
defer self.allocator.free(app_path_w);
switch most windows calls to use W versions instead of A See #534
2018-09-02 23:25:04 -04:00
const cmd_line_w = try unicode.utf8ToUtf16LeWithNull(self.allocator, cmd_line);
defer self.allocator.free(cmd_line_w);
Fix std.child_process.ChildProcess.spawnWindow when looking in PATH environment variable, it applied cwd+app_name instead of just using the app_name
2020-01-10 19:25:26 -05:00
windowsCreateProcess(app_path_w.ptr, cmd_line_w.ptr, envp_ptr, cwd_w_ptr, &siStartInfo, &piProcInfo) catch |no_path_err| {
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
if (no_path_err != error.FileNotFound) return no_path_err;
std.os.ChildProcess: on windows cwd affects exe search path to match posix semantics disabling non-passing build-examples tests. See #538
2017-10-16 02:27:51 -04:00
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
var free_path = true;
const PATH = process.getEnvVarOwned(self.allocator, "PATH") catch |err| switch (err) {
error.EnvironmentVariableNotFound => blk: {
free_path = false;
break :blk "";
},
else => |e| return e,
};
defer if (free_path) self.allocator.free(PATH);
var free_path_ext = true;
const PATHEXT = process.getEnvVarOwned(self.allocator, "PATHEXT") catch |err| switch (err) {
error.EnvironmentVariableNotFound => blk: {
free_path_ext = false;
break :blk "";
},
else => |e| return e,
};
defer if (free_path_ext) self.allocator.free(PATHEXT);
std.os.ChildProcess: on windows cwd affects exe search path to match posix semantics disabling non-passing build-examples tests. See #538
2017-10-16 02:27:51 -04:00
Fix std.child_process.ChildProcess.spawnWindow when looking in PATH environment variable, it applied cwd+app_name instead of just using the app_name
2020-01-10 19:25:26 -05:00
const app_name = self.argv[0];
Update all usages of mem.split/mem.tokenize for generic version
2021-08-06 02:01:47 -07:00
var it = mem.tokenize(u8, PATH, ";");
Fix windows create process retry/path search
2019-06-18 01:40:37 -06:00
retry: while (it.next()) |search_path| {
std: avoid an allocation in inner loop
2020-01-10 15:03:51 +11:00
const path_no_ext = try fs.path.join(self.allocator, &[_][]const u8{ search_path, app_name });
defer self.allocator.free(path_no_ext);
Update all usages of mem.split/mem.tokenize for generic version
2021-08-06 02:01:47 -07:00
var ext_it = mem.tokenize(u8, PATHEXT, ";");
Fix windows create process retry/path search
2019-06-18 01:40:37 -06:00
while (ext_it.next()) |app_ext| {
std: avoid an allocation in inner loop
2020-01-10 15:03:51 +11:00
const joined_path = try mem.concat(self.allocator, u8, &[_][]const u8{ path_no_ext, app_ext });
Fix windows create process retry/path search
2019-06-18 01:40:37 -06:00
defer self.allocator.free(joined_path);
const joined_path_w = try unicode.utf8ToUtf16LeWithNull(self.allocator, joined_path);
defer self.allocator.free(joined_path_w);
if (windowsCreateProcess(joined_path_w.ptr, cmd_line_w.ptr, envp_ptr, cwd_w_ptr, &siStartInfo, &piProcInfo)) |_| {
break :retry;
} else |err| switch (err) {
code formatting
2019-07-05 14:14:25 -04:00
error.FileNotFound => continue,
error.AccessDenied => continue,
else => return err,
Fix windows create process retry/path search
2019-06-18 01:40:37 -06:00
}
std.os.ChildProcess: on windows cwd affects exe search path to match posix semantics disabling non-passing build-examples tests. See #538
2017-10-16 02:27:51 -04:00
}
Notify failure to create a process when the executable is not found even in PATH.
2019-02-05 22:44:14 +01:00
} else {
Fix windows create process retry/path search
2019-06-18 01:40:37 -06:00
return no_path_err; // return the original error
std.os.ChildProcess: on windows cwd affects exe search path to match posix semantics disabling non-passing build-examples tests. See #538
2017-10-16 02:27:51 -04:00
}
};
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
fix windows build from previous commit
2017-10-31 22:24:02 -04:00
if (g_hChildStd_IN_Wr) |h| {
update windows impl of child process to new File API
2020-05-02 04:31:26 -04:00
self.stdin = File{ .handle = h };
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
} else {
self.stdin = null;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
fix windows build from previous commit
2017-10-31 22:24:02 -04:00
if (g_hChildStd_OUT_Rd) |h| {
update windows impl of child process to new File API
2020-05-02 04:31:26 -04:00
self.stdout = File{ .handle = h };
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
} else {
self.stdout = null;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
fix windows build from previous commit
2017-10-31 22:24:02 -04:00
if (g_hChildStd_ERR_Rd) |h| {
update windows impl of child process to new File API
2020-05-02 04:31:26 -04:00
self.stderr = File{ .handle = h };
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
} else {
self.stderr = null;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
self.handle = piProcInfo.hProcess;
use correct integer type for windows BOOL
2017-10-15 14:01:55 -04:00
self.thread_handle = piProcInfo.hThread;
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
self.term = null;
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
if (self.stdin_behavior == StdIo.Pipe) {
breaking syntax change: ??x to x.? (#1095) See #1023 This also renames Nullable/Maybe to Optional
2018-06-09 23:42:14 -04:00
os.close(g_hChildStd_IN_Rd.?);
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
}
if (self.stderr_behavior == StdIo.Pipe) {
breaking syntax change: ??x to x.? (#1095) See #1023 This also renames Nullable/Maybe to Optional
2018-06-09 23:42:14 -04:00
os.close(g_hChildStd_ERR_Wr.?);
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
}
if (self.stdout_behavior == StdIo.Pipe) {
breaking syntax change: ??x to x.? (#1095) See #1023 This also renames Nullable/Maybe to Optional
2018-06-09 23:42:14 -04:00
os.close(g_hChildStd_OUT_Wr.?);
partial conversion to post-fix pointer deref using zig fmt
2018-05-10 00:29:49 -04:00
}
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
*WIP* error sets converting std lib
2018-01-31 22:48:40 -05:00
fn setUpChildIo(stdio: StdIo, pipe_fd: i32, std_fileno: i32, dev_null_fd: i32) !void {
API for command line args closes #300
2017-04-04 00:17:24 -04:00
switch (stdio) {
more std lib async I/O integration * `zig test` gainst `--test-evented-io` parameter and gains the ability to seamlessly run async tests. * `std.ChildProcess` opens its child process pipe with O_NONBLOCK when using evented I/O * `std.io.getStdErr()` gives a File that is blocking even in evented I/O mode. * Delete `std.event.fs`. The functionality is now merged into `std.fs` and async file system access (using a dedicated thread) is automatically handled. * `std.fs.File` can be configured to specify whether its handle is expected to block, and whether that is OK to block even when in async I/O mode. This makes async I/O work correctly for e.g. the file system as well as network. * `std.fs.File` has some deprecated functions removed. * Missing readv,writev,pread,pwrite,preadv,pwritev functions are added to `std.os` and `std.fs.File`. They are all integrated with async I/O. * `std.fs.Watch` is still bit rotted and needs to be audited in light of the new async/await syntax. * `std.io.OutStream` integrates with async I/O * linked list nodes in the std lib have default `null` values for `prev` and `next`. * Windows async I/O integration is enabled for reading/writing file handles. * Added `std.os.mode_t`. Integer sizes need to be audited. * Fixed #4403 which was causing compiler to crash. This is working towards: ./zig test ../test/stage1/behavior.zig --test-evented-io Which does not successfully build yet. I'd like to enable behavioral tests and std lib tests with --test-evented-io in the test matrix in the future, to prevent regressions.
2020-02-06 17:56:40 -05:00
.Pipe => try os.dup2(pipe_fd, std_fileno),
.Close => os.close(std_fileno),
.Inherit => {},
.Ignore => try os.dup2(dev_null_fd, std_fileno),
API for command line args closes #300
2017-04-04 00:17:24 -04:00
}
}
};
std: sentinel terminated pointers for utf16 apis
2019-12-28 16:40:59 +11:00
fn windowsCreateProcess(app_name: [*:0]u16, cmd_line: [*:0]u16, envp_ptr: ?[*]u16, cwd_ptr: ?[*:0]u16, lpStartupInfo: *windows.STARTUPINFOW, lpProcessInformation: *windows.PROCESS_INFORMATION) !void {
switch most windows calls to use W versions instead of A See #534
2018-09-02 23:25:04 -04:00
// TODO the docs for environment pointer say:
// > A pointer to the environment block for the new process. If this parameter
// > is NULL, the new process uses the environment of the calling process.
// > ...
// > An environment block can contain either Unicode or ANSI characters. If
// > the environment block pointed to by lpEnvironment contains Unicode
// > characters, be sure that dwCreationFlags includes CREATE_UNICODE_ENVIRONMENT.
// > If this parameter is NULL and the environment block of the parent process
// > contains Unicode characters, you must also ensure that dwCreationFlags
// > includes CREATE_UNICODE_ENVIRONMENT.
// This seems to imply that we have to somehow know whether our process parent passed
// CREATE_UNICODE_ENVIRONMENT if we want to pass NULL for the environment parameter.
// Since we do not know this information that would imply that we must not pass NULL
// for the parameter.
// However this would imply that programs compiled with -DUNICODE could not pass
// environment variables to programs that were not, which seems unlikely.
// More investigation is needed.
more cleanup. down to just the `@hasDecl` builtin
2019-05-26 13:37:34 -04:00
return windows.CreateProcessW(
fix zig fmt on windows closes #1069
2018-09-12 14:26:21 -04:00
app_name,
cmd_line,
null,
null,
windows.TRUE,
windows.CREATE_UNICODE_ENVIRONMENT,
stage1, stage2: rename c_void to anyopaque (#10316) zig fmt now replaces c_void with anyopaque to make updating code easy.
2021-12-19 06:24:45 +01:00
@ptrCast(?*anyopaque, envp_ptr),
fix zig fmt on windows closes #1069
2018-09-12 14:26:21 -04:00
cwd_ptr,
lpStartupInfo,
lpProcessInformation,
more cleanup. down to just the `@hasDecl` builtin
2019-05-26 13:37:34 -04:00
);
std.os.ChildProcess: on windows cwd affects exe search path to match posix semantics disabling non-passing build-examples tests. See #538
2017-10-16 02:27:51 -04:00
}
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
/// Caller must dealloc.
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
fn windowsCreateCommandLine(allocator: mem.Allocator, argv: []const []const u8) ![:0]u8 {
std: clenup, fixes, fmt
2020-12-23 18:32:39 +02:00
var buf = std.ArrayList(u8).init(allocator);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
defer buf.deinit();
fix windows build system broken by 6e821078f625a03eb8b7794c983da0f7793366ab
2018-05-11 23:04:41 -04:00
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
for (argv) |arg, arg_i| {
move ArrayListSentineled to std lib orphanage
2020-12-23 16:24:22 +02:00
if (arg_i != 0) try buf.append(' ');
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
if (mem.indexOfAny(u8, arg, " \t\n\"") == null) {
move ArrayListSentineled to std lib orphanage
2020-12-23 16:24:22 +02:00
try buf.appendSlice(arg);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
continue;
}
move ArrayListSentineled to std lib orphanage
2020-12-23 16:24:22 +02:00
try buf.append('"');
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
var backslash_count: usize = 0;
for (arg) |byte| {
switch (byte) {
'\\' => backslash_count += 1,
'"' => {
move ArrayListSentineled to std lib orphanage
2020-12-23 16:24:22 +02:00
try buf.appendNTimes('\\', backslash_count * 2 + 1);
try buf.append('"');
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
backslash_count = 0;
},
else => {
move ArrayListSentineled to std lib orphanage
2020-12-23 16:24:22 +02:00
try buf.appendNTimes('\\', backslash_count);
try buf.append(byte);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
backslash_count = 0;
},
}
}
move ArrayListSentineled to std lib orphanage
2020-12-23 16:24:22 +02:00
try buf.appendNTimes('\\', backslash_count * 2);
try buf.append('"');
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
move ArrayListSentineled to std lib orphanage
2020-12-23 16:24:22 +02:00
return buf.toOwnedSliceSentinel(0);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
syntax: functions require return type. remove `->` The purpose of this is: * Only one way to do things * Changing a function with void return type to return a possible error becomes a 1 character change, subtly encouraging people to use errors. See #632 Here are some imperfect sed commands for performing this update: remove arrow: ``` sed -i 's/\(\bfn\b.*\)-> /\1/g' $(find . -name "*.zig") ``` add void: ``` sed -i 's/\(\bfn\b.*\))\s*{/\1) void {/g' $(find ../ -name "*.zig") ``` Some cleanup may be necessary, but this should do the bulk of the work.
2018-01-25 04:10:11 -05:00
fn windowsDestroyPipe(rd: ?windows.HANDLE, wr: ?windows.HANDLE) void {
fix windows build from previous commit
2017-10-31 22:24:02 -04:00
if (rd) |h| os.close(h);
if (wr) |h| os.close(h);
implement std.os.ChildProcess for windows
2017-10-13 09:31:03 -04:00
}
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
fn windowsMakePipeIn(rd: *?windows.HANDLE, wr: *?windows.HANDLE, sattr: *const windows.SECURITY_ATTRIBUTES) !void {
var rd_h: windows.HANDLE = undefined;
var wr_h: windows.HANDLE = undefined;
try windows.CreatePipe(&rd_h, &wr_h, sattr);
errdefer windowsDestroyPipe(rd_h, wr_h);
try windows.SetHandleInformation(wr_h, windows.HANDLE_FLAG_INHERIT, 0);
rd.* = rd_h;
wr.* = wr_h;
}
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
var pipe_name_counter = std.atomic.Atomic(u32).init(1);
fn windowsMakeAsyncPipe(rd: *?windows.HANDLE, wr: *?windows.HANDLE, sattr: *const windows.SECURITY_ATTRIBUTES) !void {
var tmp_bufw: [128]u16 = undefined;
// We must make a named pipe on windows because anonymous pipes do not support async IO
const pipe_path = blk: {
var tmp_buf: [128]u8 = undefined;
// Forge a random path for the pipe.
const pipe_path = std.fmt.bufPrintZ(
&tmp_buf,
"\\\\.\\pipe\\zig-childprocess-{d}-{d}",
.{ windows.kernel32.GetCurrentProcessId(), pipe_name_counter.fetchAdd(1, .Monotonic) },
) catch unreachable;
const len = std.unicode.utf8ToUtf16Le(&tmp_bufw, pipe_path) catch unreachable;
tmp_bufw[len] = 0;
break :blk tmp_bufw[0..len :0];
};
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
// Create the read handle that can be used with overlapped IO ops.
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
const read_handle = windows.kernel32.CreateNamedPipeW(
pipe_path.ptr,
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
windows.PIPE_ACCESS_INBOUND | windows.FILE_FLAG_OVERLAPPED,
windows.PIPE_TYPE_BYTE,
1,
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
4096,
4096,
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
0,
sattr,
);
if (read_handle == windows.INVALID_HANDLE_VALUE) {
switch (windows.kernel32.GetLastError()) {
else => |err| return windows.unexpectedError(err),
}
}
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
errdefer os.close(read_handle);
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
var sattr_copy = sattr.*;
const write_handle = windows.kernel32.CreateFileW(
pipe_path.ptr,
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
windows.GENERIC_WRITE,
0,
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
&sattr_copy,
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
windows.OPEN_EXISTING,
windows.FILE_ATTRIBUTE_NORMAL,
null,
);
if (write_handle == windows.INVALID_HANDLE_VALUE) {
switch (windows.kernel32.GetLastError()) {
else => |err| return windows.unexpectedError(err),
}
}
finish ChildProcess collectOutputWindows This finishes LemonBoy's Draft PR ziglang#6750. It updates ChildProcess to collect the output from stdout/stderr asynchronously using Overlapped IO and named pipes.
2021-06-17 17:36:42 -06:00
errdefer os.close(write_handle);
std: Avoid deadlocking in ChildProcess.exec Reading stdin&stderr at different times may lead to nasty deadlocks (eg. when stdout is read before stderr and the child process doesn't write anything onto stdout). Implement a polling mechanism to make sure this won't happen: we read data from stderr/stdout as it becomes ready and then it's copied into an ArrayList provided by the user, avoiding any kind of blocking read.
2020-10-20 08:51:21 +02:00
try windows.SetHandleInformation(read_handle, windows.HANDLE_FLAG_INHERIT, 0);
rd.* = read_handle;
wr.* = write_handle;
}
fixes for darwin
2019-05-27 14:12:50 -04:00
fn destroyPipe(pipe: [2]os.fd_t) void {
remove implicit cast from T to *const T closes #1465
2018-10-15 18:23:47 -04:00
os.close(pipe[0]);
Revert "Revert "Use eventfd in ChildProcess on Linux"" This reverts commit 2c7a2aefbfd0dbab190f912b4fbcbda96fb5ac44.
2019-12-16 10:56:53 +01:00
if (pipe[0] != pipe[1]) os.close(pipe[1]);
API for command line args closes #300
2017-04-04 00:17:24 -04:00
}
// Child of fork calls this to report an error to the fork parent.
// Then the child exits.
error sets - most tests passing
2018-02-08 02:08:45 -05:00
fn forkChildErrReport(fd: i32, err: ChildProcess.SpawnError) noreturn {
std.ChildProcess.spawn has a consistent error set across targets. Also fix detection of pkg-config not installed on Windows when using zig build.
2019-11-10 14:58:24 -05:00
writeIntFd(fd, @as(ErrInt, @errorToInt(err))) catch {};
std.ChildProcess: bypass libc exit() in fork child error case Comment reproduced here: If we're linking libc, some naughty applications may have registered atexit handlers which we really do not want to run in the fork child. I caught LLVM doing this and it caused a deadlock instead of doing an exit syscall. In the words of Avril Lavigne, "Why'd you have to go and make things so complicated?"
2020-09-28 22:17:50 -07:00
// If we're linking libc, some naughty applications may have registered atexit handlers
// which we really do not want to run in the fork child. I caught LLVM doing this and
// it caused a deadlock instead of doing an exit syscall. In the words of Avril Lavigne,
// "Why'd you have to go and make things so complicated?"
std: add c._exit() and use in ChildProcess This issue with atexit() functions after forking isn't isolated to linux I'm sure, the proper way to do this when linking libc is to use _exit(2)
2020-12-26 22:22:43 +01:00
if (builtin.link_libc) {
// The _exit(2) function does nothing but make the exit syscall, unlike exit(3)
std.c._exit(1);
std.ChildProcess: bypass libc exit() in fork child error case Comment reproduced here: If we're linking libc, some naughty applications may have registered atexit handlers which we really do not want to run in the fork child. I caught LLVM doing this and it caused a deadlock instead of doing an exit syscall. In the words of Avril Lavigne, "Why'd you have to go and make things so complicated?"
2020-09-28 22:17:50 -07:00
}
clean up references to posix
2019-05-25 13:07:44 -04:00
os.exit(1);
API for command line args closes #300
2017-04-04 00:17:24 -04:00
}
Make std.meta.Int accept a signedness parameter
2020-10-17 14:09:59 +02:00
const ErrInt = std.meta.Int(.unsigned, @sizeOf(anyerror) * 8);
progress toward tests passing on MacOS
2017-08-27 00:11:09 -04:00
*WIP* error sets converting std lib
2018-01-31 22:48:40 -05:00
fn writeIntFd(fd: i32, value: ErrInt) !void {
more std lib async I/O integration * `zig test` gainst `--test-evented-io` parameter and gains the ability to seamlessly run async tests. * `std.ChildProcess` opens its child process pipe with O_NONBLOCK when using evented I/O * `std.io.getStdErr()` gives a File that is blocking even in evented I/O mode. * Delete `std.event.fs`. The functionality is now merged into `std.fs` and async file system access (using a dedicated thread) is automatically handled. * `std.fs.File` can be configured to specify whether its handle is expected to block, and whether that is OK to block even when in async I/O mode. This makes async I/O work correctly for e.g. the file system as well as network. * `std.fs.File` has some deprecated functions removed. * Missing readv,writev,pread,pwrite,preadv,pwritev functions are added to `std.os` and `std.fs.File`. They are all integrated with async I/O. * `std.fs.Watch` is still bit rotted and needs to be audited in light of the new async/await syntax. * `std.io.OutStream` integrates with async I/O * linked list nodes in the std lib have default `null` values for `prev` and `next`. * Windows async I/O integration is enabled for reading/writing file handles. * Added `std.os.mode_t`. Integer sizes need to be audited. * Fixed #4403 which was causing compiler to crash. This is working towards: ./zig test ../test/stage1/behavior.zig --test-evented-io Which does not successfully build yet. I'd like to enable behavioral tests and std lib tests with --test-evented-io in the test matrix in the future, to prevent regressions.
2020-02-06 17:56:40 -05:00
const file = File{
.handle = fd,
cleanup and fixes. behavior tests passing with evented I/O
2020-05-01 23:17:15 -04:00
.capable_io_mode = .blocking,
.intended_io_mode = .blocking,
more std lib async I/O integration * `zig test` gainst `--test-evented-io` parameter and gains the ability to seamlessly run async tests. * `std.ChildProcess` opens its child process pipe with O_NONBLOCK when using evented I/O * `std.io.getStdErr()` gives a File that is blocking even in evented I/O mode. * Delete `std.event.fs`. The functionality is now merged into `std.fs` and async file system access (using a dedicated thread) is automatically handled. * `std.fs.File` can be configured to specify whether its handle is expected to block, and whether that is OK to block even when in async I/O mode. This makes async I/O work correctly for e.g. the file system as well as network. * `std.fs.File` has some deprecated functions removed. * Missing readv,writev,pread,pwrite,preadv,pwritev functions are added to `std.os` and `std.fs.File`. They are all integrated with async I/O. * `std.fs.Watch` is still bit rotted and needs to be audited in light of the new async/await syntax. * `std.io.OutStream` integrates with async I/O * linked list nodes in the std lib have default `null` values for `prev` and `next`. * Windows async I/O integration is enabled for reading/writing file handles. * Added `std.os.mode_t`. Integer sizes need to be audited. * Fixed #4403 which was causing compiler to crash. This is working towards: ./zig test ../test/stage1/behavior.zig --test-evented-io Which does not successfully build yet. I'd like to enable behavioral tests and std lib tests with --test-evented-io in the test matrix in the future, to prevent regressions.
2020-02-06 17:56:40 -05:00
};
Reduce use of deprecated IO types Related: #4917
2021-01-05 20:57:18 -05:00
file.writer().writeIntNative(u64, @intCast(u64, value)) catch return error.SystemResources;
API for command line args closes #300
2017-04-04 00:17:24 -04:00
}
*WIP* error sets converting std lib
2018-01-31 22:48:40 -05:00
fn readIntFd(fd: i32) !ErrInt {
more std lib async I/O integration * `zig test` gainst `--test-evented-io` parameter and gains the ability to seamlessly run async tests. * `std.ChildProcess` opens its child process pipe with O_NONBLOCK when using evented I/O * `std.io.getStdErr()` gives a File that is blocking even in evented I/O mode. * Delete `std.event.fs`. The functionality is now merged into `std.fs` and async file system access (using a dedicated thread) is automatically handled. * `std.fs.File` can be configured to specify whether its handle is expected to block, and whether that is OK to block even when in async I/O mode. This makes async I/O work correctly for e.g. the file system as well as network. * `std.fs.File` has some deprecated functions removed. * Missing readv,writev,pread,pwrite,preadv,pwritev functions are added to `std.os` and `std.fs.File`. They are all integrated with async I/O. * `std.fs.Watch` is still bit rotted and needs to be audited in light of the new async/await syntax. * `std.io.OutStream` integrates with async I/O * linked list nodes in the std lib have default `null` values for `prev` and `next`. * Windows async I/O integration is enabled for reading/writing file handles. * Added `std.os.mode_t`. Integer sizes need to be audited. * Fixed #4403 which was causing compiler to crash. This is working towards: ./zig test ../test/stage1/behavior.zig --test-evented-io Which does not successfully build yet. I'd like to enable behavioral tests and std lib tests with --test-evented-io in the test matrix in the future, to prevent regressions.
2020-02-06 17:56:40 -05:00
const file = File{
.handle = fd,
cleanup and fixes. behavior tests passing with evented I/O
2020-05-01 23:17:15 -04:00
.capable_io_mode = .blocking,
.intended_io_mode = .blocking,
more std lib async I/O integration * `zig test` gainst `--test-evented-io` parameter and gains the ability to seamlessly run async tests. * `std.ChildProcess` opens its child process pipe with O_NONBLOCK when using evented I/O * `std.io.getStdErr()` gives a File that is blocking even in evented I/O mode. * Delete `std.event.fs`. The functionality is now merged into `std.fs` and async file system access (using a dedicated thread) is automatically handled. * `std.fs.File` can be configured to specify whether its handle is expected to block, and whether that is OK to block even when in async I/O mode. This makes async I/O work correctly for e.g. the file system as well as network. * `std.fs.File` has some deprecated functions removed. * Missing readv,writev,pread,pwrite,preadv,pwritev functions are added to `std.os` and `std.fs.File`. They are all integrated with async I/O. * `std.fs.Watch` is still bit rotted and needs to be audited in light of the new async/await syntax. * `std.io.OutStream` integrates with async I/O * linked list nodes in the std lib have default `null` values for `prev` and `next`. * Windows async I/O integration is enabled for reading/writing file handles. * Added `std.os.mode_t`. Integer sizes need to be audited. * Fixed #4403 which was causing compiler to crash. This is working towards: ./zig test ../test/stage1/behavior.zig --test-evented-io Which does not successfully build yet. I'd like to enable behavioral tests and std lib tests with --test-evented-io in the test matrix in the future, to prevent regressions.
2020-02-06 17:56:40 -05:00
};
replaced inStream() with reader() `inStream()` is now deprecated and deserves replacing.
2020-10-15 23:19:19 +00:00
return @intCast(ErrInt, file.reader().readIntNative(u64) catch return error.SystemResources);
API for command line args closes #300
2017-04-04 00:17:24 -04:00
}
more progress. moving windows API layer to its own file
2019-05-24 00:13:13 -04:00
/// Caller must free result.
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
pub fn createWindowsEnvBlock(allocator: mem.Allocator, env_map: *const BufMap) ![]u16 {
more progress. moving windows API layer to its own file
2019-05-24 00:13:13 -04:00
// count bytes needed
const max_chars_needed = x: {
var max_chars_needed: usize = 4; // 4 for the final 4 null bytes
var it = env_map.iterator();
while (it.next()) |pair| {
// +1 for '='
// +1 for null byte
Breaking hash map changes for 0.8.0 - hash/eql functions moved into a Context object - *Context functions pass an explicit context - *Adapted functions pass specialized keys and contexts - new getPtr() function returns a pointer to value - remove functions renamed to fetchRemove - new remove functions return bool - removeAssertDiscard deleted, use assert(remove(...)) instead - Keys and values are stored in separate arrays - Entry is now {*K, *V}, the new KV is {K, V} - BufSet/BufMap functions renamed to match other set/map types - fixed iterating-while-modifying bug in src/link/C.zig
2021-06-03 15:39:26 -05:00
max_chars_needed += pair.key_ptr.len + pair.value_ptr.len + 2;
more progress. moving windows API layer to its own file
2019-05-24 00:13:13 -04:00
}
break :x max_chars_needed;
};
const result = try allocator.alloc(u16, max_chars_needed);
errdefer allocator.free(result);
var it = env_map.iterator();
var i: usize = 0;
while (it.next()) |pair| {
Breaking hash map changes for 0.8.0 - hash/eql functions moved into a Context object - *Context functions pass an explicit context - *Adapted functions pass specialized keys and contexts - new getPtr() function returns a pointer to value - remove functions renamed to fetchRemove - new remove functions return bool - removeAssertDiscard deleted, use assert(remove(...)) instead - Keys and values are stored in separate arrays - Entry is now {*K, *V}, the new KV is {K, V} - BufSet/BufMap functions renamed to match other set/map types - fixed iterating-while-modifying bug in src/link/C.zig
2021-06-03 15:39:26 -05:00
i += try unicode.utf8ToUtf16Le(result[i..], pair.key_ptr.*);
more progress. moving windows API layer to its own file
2019-05-24 00:13:13 -04:00
result[i] = '=';
i += 1;
Breaking hash map changes for 0.8.0 - hash/eql functions moved into a Context object - *Context functions pass an explicit context - *Adapted functions pass specialized keys and contexts - new getPtr() function returns a pointer to value - remove functions renamed to fetchRemove - new remove functions return bool - removeAssertDiscard deleted, use assert(remove(...)) instead - Keys and values are stored in separate arrays - Entry is now {*K, *V}, the new KV is {K, V} - BufSet/BufMap functions renamed to match other set/map types - fixed iterating-while-modifying bug in src/link/C.zig
2021-06-03 15:39:26 -05:00
i += try unicode.utf8ToUtf16Le(result[i..], pair.value_ptr.*);
more progress. moving windows API layer to its own file
2019-05-24 00:13:13 -04:00
result[i] = 0;
i += 1;
}
result[i] = 0;
i += 1;
result[i] = 0;
i += 1;
result[i] = 0;
i += 1;
result[i] = 0;
i += 1;
return allocator.shrink(result, i);
}
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
pub fn createNullDelimitedEnvMap(arena: mem.Allocator, env_map: *const std.BufMap) ![:null]?[*:0]u8 {
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
const envp_count = env_map.count();
std: clean up sentinel handling for argv/environ
2020-12-27 13:00:35 +01:00
const envp_buf = try arena.allocSentinel(?[*:0]u8, envp_count, null);
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
{
var it = env_map.iterator();
var i: usize = 0;
while (it.next()) |pair| : (i += 1) {
Breaking hash map changes for 0.8.0 - hash/eql functions moved into a Context object - *Context functions pass an explicit context - *Adapted functions pass specialized keys and contexts - new getPtr() function returns a pointer to value - remove functions renamed to fetchRemove - new remove functions return bool - removeAssertDiscard deleted, use assert(remove(...)) instead - Keys and values are stored in separate arrays - Entry is now {*K, *V}, the new KV is {K, V} - BufSet/BufMap functions renamed to match other set/map types - fixed iterating-while-modifying bug in src/link/C.zig
2021-06-03 15:39:26 -05:00
const env_buf = try arena.allocSentinel(u8, pair.key_ptr.len + pair.value_ptr.len + 1, 0);
mem.copy(u8, env_buf, pair.key_ptr.*);
env_buf[pair.key_ptr.len] = '=';
mem.copy(u8, env_buf[pair.key_ptr.len + 1 ..], pair.value_ptr.*);
std: clean up sentinel handling for argv/environ
2020-12-27 13:00:35 +01:00
envp_buf[i] = env_buf.ptr;
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
}
assert(i == envp_count);
}
std: clean up sentinel handling for argv/environ
2020-12-27 13:00:35 +01:00
return envp_buf;
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
}
std: add test for createNullDelimitedEnvMap()
2020-12-27 12:41:48 +01:00
test "createNullDelimitedEnvMap" {
const testing = std.testing;
const allocator = testing.allocator;
var envmap = BufMap.init(allocator);
defer envmap.deinit();
Breaking hash map changes for 0.8.0 - hash/eql functions moved into a Context object - *Context functions pass an explicit context - *Adapted functions pass specialized keys and contexts - new getPtr() function returns a pointer to value - remove functions renamed to fetchRemove - new remove functions return bool - removeAssertDiscard deleted, use assert(remove(...)) instead - Keys and values are stored in separate arrays - Entry is now {*K, *V}, the new KV is {K, V} - BufSet/BufMap functions renamed to match other set/map types - fixed iterating-while-modifying bug in src/link/C.zig
2021-06-03 15:39:26 -05:00
try envmap.put("HOME", "/home/ifreund");
try envmap.put("WAYLAND_DISPLAY", "wayland-1");
try envmap.put("DISPLAY", ":1");
try envmap.put("DEBUGINFOD_URLS", " ");
try envmap.put("XCURSOR_SIZE", "24");
std: add test for createNullDelimitedEnvMap()
2020-12-27 12:41:48 +01:00
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
allocgate: renamed getAllocator function to allocator
2021-10-29 02:08:41 +01:00
const environ = try createNullDelimitedEnvMap(arena.allocator(), &envmap);
std: add test for createNullDelimitedEnvMap()
2020-12-27 12:41:48 +01:00
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(usize, 5), environ.len);
std: add test for createNullDelimitedEnvMap()
2020-12-27 12:41:48 +01:00
inline for (.{
"HOME=/home/ifreund",
"WAYLAND_DISPLAY=wayland-1",
"DISPLAY=:1",
"DEBUGINFOD_URLS= ",
"XCURSOR_SIZE=24",
}) |target| {
for (environ) |variable| {
if (mem.eql(u8, mem.span(variable orelse continue), target)) break;
} else {
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(false); // Environment variable not found
std: add test for createNullDelimitedEnvMap()
2020-12-27 12:41:48 +01:00
}
}
std: do not call malloc() between fork() and execv() We were violating the POSIX standard which resulted in a deadlock on musl v1.1.24 on aarch64 alpine linux, uncovered with the new ThreadPool usage in the stage2 compiler. std.os execv functions that accept an Allocator parameter are removed because they are footguns. The POSIX standard does not allow calls to malloc() between fork() and execv() and since it is common to both (1) call execv() after fork() and (2) use std.heap.c_allocator, Programmers are encouraged to go through the `std.process` API instead, causing some dissonance when combined with `std.os` APIs. I also slapped a big warning message on all the relevant doc comments.
2020-12-26 13:50:26 -07:00
}
Reference in New Issue Copy Permalink