diff --git a/lib/std/fs.zig b/lib/std/fs.zig index 052343599e..f7a9249f1c 100644 --- a/lib/std/fs.zig +++ b/lib/std/fs.zig @@ -2547,6 +2547,15 @@ pub const SelfExePathError = os.ReadLinkError || os.SysCtlError || os.RealPathEr /// `selfExePath` except allocates the result on the heap. /// Caller owns returned memory. pub fn selfExePathAlloc(allocator: Allocator) ![]u8 { + if (builtin.os.tag == .wasi) { + var args = try std.process.argsWithAllocator(allocator); + defer args.deinit(); + // On WASI, argv[0] is always just the basename of the current executable + const exe_name = args.next() orelse return error.FileNotFound; + + var buf: [MAX_PATH_BYTES]u8 = undefined; + return allocator.dupe(u8, try selfExePathWasi(&buf, exe_name)); + } // Use of MAX_PATH_BYTES here is justified as, at least on one tested Linux // system, readlink will completely fail to return a result larger than // PATH_MAX even if given a sufficiently large buffer. This makes it @@ -2643,10 +2652,48 @@ pub fn selfExePath(out_buffer: []u8) SelfExePathError![]u8 { const end_index = std.unicode.utf16leToUtf8(out_buffer, utf16le_slice) catch unreachable; return out_buffer[0..end_index]; }, + .wasi => @compileError("std.fs.selfExePath not supported for WASI. Use std.fs.selfExePathAlloc instead."), else => @compileError("std.fs.selfExePath not supported for this target"), } } +/// WASI-specific implementation of selfExePath +/// +/// On WASI argv0 is always just the executable basename, so this function relies +/// using a fixed executable directory path: "/zig" +/// +/// This path can be configured in wasmtime using `--mapdir=/zig::/path/to/zig/dir/` +fn selfExePathWasi(out_buffer: []u8, argv0: []const u8) SelfExePathError![]const u8 { + var allocator = std.heap.FixedBufferAllocator.init(out_buffer); + var alloc = allocator.allocator(); + + // Check these paths: + // 1. "/zig/{exe_name}" + // 2. "/zig/bin/{exe_name}" + const base_paths_to_check = &[_][]const u8{ "/zig", "/zig/bin" }; + const exe_names_to_check = &[_][]const u8{ path.basename(argv0), "zig.wasm" }; + + for (base_paths_to_check) |base_path| { + for (exe_names_to_check) |exe_name| { + const test_path = path.join(alloc, &.{ base_path, exe_name }) catch continue; + + // Make sure it's a file we're pointing to + const file = os.fstatat(os.wasi.AT.FDCWD, test_path, 0) catch continue; + if (file.filetype != .REGULAR_FILE) continue; + + // Path seems to be valid, let's try to turn it into an absolute path + var real_path_buf: [MAX_PATH_BYTES]u8 = undefined; + if (os.realpath(test_path, &real_path_buf)) |real_path| { + if (real_path.len > out_buffer.len) + return error.NameTooLong; + mem.copy(u8, out_buffer, real_path); + return out_buffer[0..real_path.len]; + } else |_| continue; + } + } + return error.FileNotFound; +} + /// The result is UTF16LE-encoded. pub fn selfExePathW() [:0]const u16 { const image_path_name = &os.windows.peb().ProcessParameters.ImagePathName; diff --git a/src/Cache.zig b/src/Cache.zig index 993114905e..37cd7a7529 100644 --- a/src/Cache.zig +++ b/src/Cache.zig @@ -762,18 +762,22 @@ pub const Manifest = struct { fn downgradeToSharedLock(self: *Manifest) !void { if (!self.have_exclusive_lock) return; - const manifest_file = self.manifest_file.?; - try manifest_file.downgradeLock(); + if (std.process.can_spawn or !builtin.single_threaded) { // Some targets (WASI) do not support flock + const manifest_file = self.manifest_file.?; + try manifest_file.downgradeLock(); + } self.have_exclusive_lock = false; } fn upgradeToExclusiveLock(self: *Manifest) !void { if (self.have_exclusive_lock) return; - const manifest_file = self.manifest_file.?; - // Here we intentionally have a period where the lock is released, in case there are - // other processes holding a shared lock. - manifest_file.unlock(); - try manifest_file.lock(.Exclusive); + if (std.process.can_spawn or !builtin.single_threaded) { // Some targets (WASI) do not support flock + const manifest_file = self.manifest_file.?; + // Here we intentionally have a period where the lock is released, in case there are + // other processes holding a shared lock. + manifest_file.unlock(); + try manifest_file.lock(.Exclusive); + } self.have_exclusive_lock = true; } diff --git a/src/introspect.zig b/src/introspect.zig index 562d6b04f4..c0de4dc7f5 100644 --- a/src/introspect.zig +++ b/src/introspect.zig @@ -1,6 +1,7 @@ const std = @import("std"); const builtin = @import("builtin"); const mem = std.mem; +const os = std.os; const fs = std.fs; const Compilation = @import("Compilation.zig"); @@ -80,5 +81,15 @@ pub fn resolveGlobalCacheDir(allocator: mem.Allocator) ![]u8 { } } - return fs.getAppDataDir(allocator, appname); + if (builtin.os.tag == .wasi) { + // On WASI, we have no way to get an App data dir, so we try to use a fixed + // Preopen path "/cache" as a last resort + const path = "/cache"; + + const file = os.fstatat(os.wasi.AT.FDCWD, path, 0) catch return error.CacheDirUnavailable; + if (file.filetype != .DIRECTORY) return error.CacheDirUnavailable; + return allocator.dupe(u8, path); + } else { + return fs.getAppDataDir(allocator, appname); + } } diff --git a/src/main.zig b/src/main.zig index e341a10f99..823eb91f33 100644 --- a/src/main.zig +++ b/src/main.zig @@ -162,6 +162,16 @@ pub fn main() anyerror!void { return mainArgs(gpa_tracy.allocator(), arena, args); } + // WASI: `--dir` instructs the WASM runtime to "preopen" a directory, making + // it available to the us, the guest program. This is the only way for us to + // access files/dirs on the host filesystem + if (builtin.os.tag == .wasi) { + // This sets our CWD to "/preopens/cwd" + // Dot-prefixed preopens like `--dir=.` are "mounted" at "/preopens/cwd" + // Other preopens like `--dir=lib` are "mounted" at "/" + try std.os.initPreopensWasi(std.heap.page_allocator, "/preopens/cwd"); + } + return mainArgs(gpa, arena, args); }