probeFile: replace seek with fstatat

One less syscall, and no need to increase surface area of wasi.c

Greetings from 11km above the ground, I really think we are living in
the age of wonderful technology.

Author: motiejus

src/main.zig

@@ -670,18 +670,30 @@ fn probeFile(name: []const u8) !FileType {
             },
         };
 
-    var f = try fs.cwd().openFile(name, .{});
-    std.os.lseek_SET(f.handle, 0) catch {
-        return FileType{
-            .stream = .{
-                .handle = f.handle,
-                .should_close_fd = true,
-            },
-        };
+    // all files are files or directories in windwos. So if it's not stdin,
+    // it's a file.
+    if (builtin.os.tag == .windows)
+        return FileType.regular;
+
+    // we are on POSIX or wasm and need to determine if a given path
+    // is a stream. We have 2 choices here:
+    // 1. open + lseek. If lseek fails, it's a stream. Always 2 syscalls.
+    // 2. fstat + optional open. If fstat tells us it's a file, we return
+    // 'regular'. If it's not a file, we open and return the file descriptor.
+    // One syscall if the file is a regular file, 2 syscalls if it is a stream.
+    // Use the latter.
+
+    var stat_info = try std.os.fstatat(fs.cwd().fd, name, 0);
+    if (stat_info.mode & std.os.S.IFMT == std.os.S.IFREG)
+        return FileType.regular;
+
+    // Not a regular file. Open it and return a file descriptor.
+    return FileType{
+        .stream = .{
+            .handle = try std.os.open(name, std.os.O.RDONLY, 0),
+            .should_close_fd = true,
+        },
     };
-
-    f.close();
-    return FileType.regular;
 }
 
 // Read an open file descriptor to a new file in `dst_dir`. Return a file name

stage1/wasi.c

@@ -727,20 +727,6 @@ uint32_t wasi_snapshot_preview1_fd_readdir(uint32_t fd, uint32_t buf, uint32_t b
     return wasi_errno_success;
 }
 
-uint32_t wasi_snapshot_preview1_fd_seek(uint32_t fd, uint64_t size, char whence, uint32_t res_size) {
-    (void)fd;
-    (void)size;
-    (void)whence;
-    (void)res_size;
-#if LOG_TRACE
-    fprintf(stderr, "wasi_snapshot_preview1_fd_seek(%u, %llu, %d, %d\n", fd, (unsigned long long)size, whence, res_size);
-#endif
-
-    panic("unimplemented");
-    return wasi_errno_success;
-}
-
-
 uint32_t wasi_snapshot_preview1_fd_write(uint32_t fd, uint32_t iovs, uint32_t iovs_len, uint32_t res_size) {
     uint8_t *const m = *wasm_memory;
     struct wasi_ciovec *iovs_ptr = (struct wasi_ciovec *)&m[iovs];

test/cli.zig

@@ -43,11 +43,8 @@ pub fn main() !void {
         .{ .func = testGodboltApi, .name = "godbolt API" },
         .{ .func = testMissingOutputPath, .name = "missing output path" },
         .{ .func = testZigFmt, .name = "zig fmt" },
-    }
-    // Test writer was not able to figure out how to start a child process and
-    // give an fd to it's stdin. fork/exec works, but we are limiting ourselves
-    // to POSIX.
-    ++ if (builtin.os.tag == .windows) [0]Test{} else [1]Test{.{ .func = testZigCC, .name = "zig cc" }};
+        .{ .func = testZigCC, .name = "zig cc" },
+    };
     inline for (tests) |t| {
         try fs.cwd().deleteTree(dir_path);
         try fs.cwd().makeDir(dir_path);
@@ -68,7 +65,7 @@ fn printCmd(cwd: []const u8, argv: []const []const u8) void {
     std.debug.print("\n", .{});
 }
 
-fn exec(cwd: []const u8, expect_0: bool, argv: []const []const u8) !ChildProcess.ExecResult {
+fn exec(cwd: []const u8, expect_code: u8, argv: []const []const u8) !ChildProcess.ExecResult {
     const max_output_size = 100 * 1024;
     const result = ChildProcess.exec(.{
         .allocator = a,
@@ -82,8 +79,11 @@ fn exec(cwd: []const u8, expect_0: bool, argv: []const []const u8) !ChildProcess
     };
     switch (result.term) {
         .Exited => |code| {
-            if ((code != 0) == expect_0) {
-                std.debug.print("The following command exited with error code {}:\n", .{code});
+            if (code != expect_code) {
+                std.debug.print(
+                    "The following command exited with error code {}, expected {}:\n",
+                    .{ code, expect_code },
+                );
                 printCmd(cwd, argv);
                 std.debug.print("stderr:\n{s}\n", .{result.stderr});
                 return error.CommandFailed;
@@ -100,34 +100,45 @@ fn exec(cwd: []const u8, expect_0: bool, argv: []const []const u8) !ChildProcess
 }
 
 fn testZigInitLib(zig_exe: []const u8, dir_path: []const u8) !void {
-    _ = try exec(dir_path, true, &[_][]const u8{ zig_exe, "init-lib" });
-    const test_result = try exec(dir_path, true, &[_][]const u8{ zig_exe, "build", "test" });
+    _ = try exec(dir_path, 0, &[_][]const u8{ zig_exe, "init-lib" });
+    const test_result = try exec(dir_path, 0, &[_][]const u8{ zig_exe, "build", "test" });
     try testing.expectStringEndsWith(test_result.stderr, "All 1 tests passed.\n");
 }
 
 fn testZigInitExe(zig_exe: []const u8, dir_path: []const u8) !void {
-    _ = try exec(dir_path, true, &[_][]const u8{ zig_exe, "init-exe" });
-    const run_result = try exec(dir_path, true, &[_][]const u8{ zig_exe, "build", "run" });
+    _ = try exec(dir_path, 0, &[_][]const u8{ zig_exe, "init-exe" });
+    const run_result = try exec(dir_path, 0, &[_][]const u8{ zig_exe, "build", "run" });
     try testing.expectEqualStrings("All your codebase are belong to us.\n", run_result.stderr);
     try testing.expectEqualStrings("Run `zig build test` to run the tests.\n", run_result.stdout);
 }
 
 fn testZigCC(zig_exe: []const u8, dir_path: []const u8) !void {
+    // Test writer was not able to figure out how to start a child process and
+    // give an fd to it's stdin. fork/exec works, but we are limiting ourselves
+    // to POSIX.
+    if (builtin.os.tag != .windows)
+        // no error.SkipZigTest, because this is not a "test {...}" block.
+        return;
+
+    return testZigCCPosix(zig_exe, dir_path);
+}
+
+fn testZigCCPosix(zig_exe: []const u8, dir_path: []const u8) !void {
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
-    try tmp.dir.writeFile("truth.c", "int truth = 42;");
+    try tmp.dir.writeFile("truth.c", "int main() { return 42; }");
     var infile = try tmp.dir.openFile("truth.c", .{});
 
     const pid_result = try std.os.fork();
     const zig_exe0 = try a.dupeZ(u8, zig_exe);
-    const outfile = try fs.path.join(a, &[_][]const u8{ dir_path, "truth.o" });
+    const outfile = try fs.path.joinZ(a, &[_][]const u8{ dir_path, "truth" });
     if (pid_result == 0) {
         try std.os.dup2(infile.handle, std.os.STDIN_FILENO);
         const argv = &[_:null]?[*:0]const u8{
             zig_exe0, "cc",
-            "-o",     try a.dupeZ(u8, outfile),
+            "-o",     outfile,
             "-x",     "c",
-            "-c",     "-",
+            "-",
         };
         const envp = &[_:null]?[*:0]const u8{
             try std.fmt.allocPrintZ(a, "ZIG_GLOBAL_CACHE_DIR={s}", .{dir_path}),
@@ -144,9 +155,8 @@ fn testZigCC(zig_exe: []const u8, dir_path: []const u8) !void {
 
     try testing.expectEqual(@as(u32, 0), res.status);
 
-    // absence of failure to open the file means success
-    const outf = try fs.cwd().openFile(outfile, .{});
-    outf.close();
+    // run the compiled executable and check if it's telling the truth.
+    _ = try exec(dir_path, 42, &[_][]const u8{outfile});
 }
 
 fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {
@@ -181,7 +191,7 @@ fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {
     const emit_asm_arg = try std.fmt.allocPrint(a, "-femit-asm={s}", .{example_s_path});
     try args.append(emit_asm_arg);
 
-    _ = try exec(dir_path, true, args.items);
+    _ = try exec(dir_path, 0, args.items);
 
     const out_asm = try std.fs.cwd().readFileAlloc(a, example_s_path, std.math.maxInt(usize));
     try testing.expect(std.mem.indexOf(u8, out_asm, "square:") != null);
@@ -190,38 +200,38 @@ fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {
 }
 
 fn testMissingOutputPath(zig_exe: []const u8, dir_path: []const u8) !void {
-    _ = try exec(dir_path, true, &[_][]const u8{ zig_exe, "init-exe" });
+    _ = try exec(dir_path, 0, &[_][]const u8{ zig_exe, "init-exe" });
     const output_path = try fs.path.join(a, &[_][]const u8{ "does", "not", "exist", "foo.exe" });
     const output_arg = try std.fmt.allocPrint(a, "-femit-bin={s}", .{output_path});
     const source_path = try fs.path.join(a, &[_][]const u8{ "src", "main.zig" });
-    const result = try exec(dir_path, false, &[_][]const u8{ zig_exe, "build-exe", source_path, output_arg });
+    const result = try exec(dir_path, 1, &[_][]const u8{ zig_exe, "build-exe", source_path, output_arg });
     const s = std.fs.path.sep_str;
     const expected: []const u8 = "error: unable to open output directory 'does" ++ s ++ "not" ++ s ++ "exist': FileNotFound\n";
     try testing.expectEqualStrings(expected, result.stderr);
 }
 
 fn testZigFmt(zig_exe: []const u8, dir_path: []const u8) !void {
-    _ = try exec(dir_path, true, &[_][]const u8{ zig_exe, "init-exe" });
+    _ = try exec(dir_path, 0, &[_][]const u8{ zig_exe, "init-exe" });
 
     const unformatted_code = "    // no reason for indent";
 
     const fmt1_zig_path = try fs.path.join(a, &[_][]const u8{ dir_path, "fmt1.zig" });
     try fs.cwd().writeFile(fmt1_zig_path, unformatted_code);
 
-    const run_result1 = try exec(dir_path, true, &[_][]const u8{ zig_exe, "fmt", fmt1_zig_path });
+    const run_result1 = try exec(dir_path, 0, &[_][]const u8{ zig_exe, "fmt", fmt1_zig_path });
     // stderr should be file path + \n
     try testing.expect(std.mem.startsWith(u8, run_result1.stdout, fmt1_zig_path));
     try testing.expect(run_result1.stdout.len == fmt1_zig_path.len + 1 and run_result1.stdout[run_result1.stdout.len - 1] == '\n');
 
     const fmt2_zig_path = try fs.path.join(a, &[_][]const u8{ dir_path, "fmt2.zig" });
     try fs.cwd().writeFile(fmt2_zig_path, unformatted_code);
 
-    const run_result2 = try exec(dir_path, true, &[_][]const u8{ zig_exe, "fmt", dir_path });
+    const run_result2 = try exec(dir_path, 0, &[_][]const u8{ zig_exe, "fmt", dir_path });
     // running it on the dir, only the new file should be changed
     try testing.expect(std.mem.startsWith(u8, run_result2.stdout, fmt2_zig_path));
     try testing.expect(run_result2.stdout.len == fmt2_zig_path.len + 1 and run_result2.stdout[run_result2.stdout.len - 1] == '\n');
 
-    const run_result3 = try exec(dir_path, true, &[_][]const u8{ zig_exe, "fmt", dir_path });
+    const run_result3 = try exec(dir_path, 0, &[_][]const u8{ zig_exe, "fmt", dir_path });
     // both files have been formatted, nothing should change now
     try testing.expect(run_result3.stdout.len == 0);
 
@@ -230,7 +240,7 @@ fn testZigFmt(zig_exe: []const u8, dir_path: []const u8) !void {
     var unformatted_code_utf16 = "\xff\xfe \x00 \x00 \x00 \x00/\x00/\x00 \x00n\x00o\x00 \x00r\x00e\x00a\x00s\x00o\x00n\x00";
     try fs.cwd().writeFile(fmt4_zig_path, unformatted_code_utf16);
 
-    const run_result4 = try exec(dir_path, true, &[_][]const u8{ zig_exe, "fmt", dir_path });
+    const run_result4 = try exec(dir_path, 0, &[_][]const u8{ zig_exe, "fmt", dir_path });
     try testing.expect(std.mem.startsWith(u8, run_result4.stdout, fmt4_zig_path));
     try testing.expect(run_result4.stdout.len == fmt4_zig_path.len + 1 and run_result4.stdout[run_result4.stdout.len - 1] == '\n');
 }