remove util.zig and politely call msync

Author: ProkopRandacek

lib/fuzzer.zig

@@ -3,11 +3,10 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const fatal = std.process.fatal;
-const util = @import("fuzzer/util.zig");
-const check = util.check;
+const check = @import("fuzzer/main.zig").check;
 const Fuzzer = @import("fuzzer/main.zig").Fuzzer;
+const Slice = @import("fuzzer/main.zig").Slice;
 const fc = @import("fuzzer/feature_capture.zig");
-const Slice = util.Slice;
 
 // ==== global state ====
 
@@ -114,6 +113,10 @@ export fn fuzzer_init(cache_dir_struct: Slice) void {
     fuzzer = Fuzzer.init(general_purpose_allocator.allocator(), cache_dir, pc_counters, pcs);
 }
 
+export fn fuzzer_deinit() void {
+    fuzzer.deinit();
+}
+
 // ==== log ====
 
 pub const std_options = .{

lib/fuzzer/InputPoolPosix.zig

@@ -13,8 +13,7 @@
 
 const std = @import("std");
 const assert = std.debug.assert;
-const util = @import("util.zig");
-const check = util.check;
+const check = @import("main.zig").check;
 const MemoryMappedList = @import("memory_mapped_list.zig").MemoryMappedList;
 
 /// maximum 2GiB of input data should be enough. 32th bit is delete flag
@@ -107,7 +106,7 @@ pub fn init(dir: std.fs.Dir, pc_digest: u64) InputPoolPosix {
     };
 }
 
-pub fn deinit(ip: InputPoolPosix) void {
+pub fn deinit(ip: *InputPoolPosix) void {
     ip.buffer.deinit();
     ip.meta.deinit();
 }

lib/fuzzer/main.zig

@@ -9,12 +9,173 @@ const MemoryMappedList = @import("memory_mapped_list.zig").MemoryMappedList;
 const mutate = @import("mutate.zig");
 const InputPool = @import("input_pool.zig").InputPool;
 const feature_capture = @import("feature_capture.zig");
-const util = @import("util.zig");
-const check = util.check;
 
 // current unused
 export threadlocal var __sancov_lowest_stack: usize = std.math.maxInt(usize);
 
+/// Returns error union payload or void if error set
+fn StripError(comptime T: type) type {
+    return switch (@typeInfo(T)) {
+        .error_union => |eu| eu.payload,
+        .error_set => void,
+        else => @compileError("no error to strip"),
+    };
+}
+
+/// Checks that the value is not error. If it is error, it logs the args and
+/// terminates
+pub fn check(src: std.builtin.SourceLocation, v: anytype, args: anytype) StripError(@TypeOf(v)) {
+    return v catch |e| {
+        var buffer: [4096]u8 = undefined;
+        var fbs = std.io.fixedBufferStream(&buffer);
+        var cw = std.io.countingWriter(fbs.writer());
+        const w = cw.writer();
+        if (@typeInfo(@TypeOf(args)).@"struct".fields.len != 0) {
+            w.writeAll(" (") catch {};
+            inline for (@typeInfo(@TypeOf(args)).@"struct".fields, 0..) |field, i| {
+                const Field = @TypeOf(@field(args, field.name));
+                if (i != 0) {
+                    w.writeAll(", ") catch {};
+                }
+                if (Field == []const u8 or Field == []u8) {
+                    w.print("{s}='{s}'", .{ field.name, @field(args, field.name) }) catch {};
+                } else {
+                    w.print("{s}={any}", .{ field.name, @field(args, field.name) }) catch {};
+                }
+            }
+            w.writeAll(")") catch {};
+        }
+        std.process.fatal("{s}:{}: {s}{s}", .{ src.file, src.line, @errorName(e), buffer[0..cw.bytes_written] });
+    };
+}
+
+/// Type for passing slices across extern functions where we can't use zig
+/// types
+pub const Slice = extern struct {
+    ptr: [*]const u8,
+    len: usize,
+
+    pub fn toZig(s: Slice) []const u8 {
+        return s.ptr[0..s.len];
+    }
+
+    pub fn fromZig(s: []const u8) Slice {
+        return .{
+            .ptr = s.ptr,
+            .len = s.len,
+        };
+    }
+};
+
+fn createFileBail(dir: std.fs.Dir, sub_path: []const u8, flags: std.fs.File.CreateFlags) std.fs.File {
+    return dir.createFile(sub_path, flags) catch |err| switch (err) {
+        error.FileNotFound => {
+            const dir_name = std.fs.path.dirname(sub_path).?;
+            check(@src(), dir.makePath(dir_name), .{ .dir_name = dir_name });
+            return check(@src(), dir.createFile(sub_path, flags), .{ .sub_path = sub_path, .flags = flags });
+        },
+        else => |e| std.process.fatal("create file '{s}' failed: {}", .{ sub_path, e }),
+    };
+}
+
+/// Sorts array of features
+fn sort(a: []u32) void {
+    std.mem.sort(u32, a, void{}, std.sort.asc(u32));
+}
+
+/// Deduplicates array of sorted features
+fn uniq(a: []u32) []u32 {
+    var write: usize = 0;
+
+    if (a.len == 0) return a;
+
+    var last: u32 = a[0];
+    a[write] = last;
+    write += 1;
+
+    for (a[1..]) |v| {
+        if (v != last) {
+            a[write] = v;
+            write += 1;
+            last = v;
+        }
+    }
+
+    return a[0..write];
+}
+
+test uniq {
+    var data: [9]u32 = (&[_]u32{ 0, 0, 1, 2, 2, 2, 3, 4, 4 }).*;
+    const cropped = uniq(&data);
+    try std.testing.expectEqualSlices(u32, &[_]u32{ 0, 1, 2, 3, 4 }, cropped);
+}
+
+pub const CmpResult = struct { only_a: u32, only_b: u32, both: u32 };
+
+/// Compares two sorted lists of features
+fn cmp(a: []const u32, b: []const u32) CmpResult {
+    var ai: u32 = 0;
+    var bi: u32 = 0;
+
+    var only_a: u32 = 0;
+    var only_b: u32 = 0;
+    var both: u32 = 0;
+
+    while (true) {
+        if (ai == a.len) {
+            only_b += @intCast(b[bi..].len);
+            break;
+        } else if (bi == b.len) {
+            only_a += @intCast(a[ai..].len);
+            break;
+        }
+
+        const i = a[ai];
+        const j = b[bi];
+
+        if (i < j) {
+            only_a += 1;
+            ai += 1;
+        } else if (i > j) {
+            only_b += 1;
+            bi += 1;
+        } else {
+            both += 1;
+            ai += 1;
+            bi += 1;
+        }
+    }
+
+    return .{
+        .only_a = only_a,
+        .only_b = only_b,
+        .both = both,
+    };
+}
+
+test cmp {
+    const e = std.testing.expectEqual;
+    const R = CmpResult;
+    try e(R{ .only_a = 0, .only_b = 0, .both = 0 }, cmp(&.{}, &.{}));
+    try e(R{ .only_a = 1, .only_b = 0, .both = 0 }, cmp(&.{1}, &.{}));
+    try e(R{ .only_a = 0, .only_b = 1, .both = 0 }, cmp(&.{}, &.{1}));
+    try e(R{ .only_a = 0, .only_b = 0, .both = 1 }, cmp(&.{1}, &.{1}));
+    try e(R{ .only_a = 1, .only_b = 1, .both = 0 }, cmp(&.{1}, &.{2}));
+    try e(R{ .only_a = 1, .only_b = 0, .both = 1 }, cmp(&.{ 1, 2 }, &.{1}));
+    try e(R{ .only_a = 0, .only_b = 1, .both = 1 }, cmp(&.{1}, &.{ 1, 2 }));
+    try e(R{ .only_a = 0, .only_b = 0, .both = 2 }, cmp(&.{ 1, 2 }, &.{ 1, 2 }));
+    try e(R{ .only_a = 3, .only_b = 3, .both = 0 }, cmp(&.{ 1, 2, 3 }, &.{ 4, 5, 6 }));
+}
+
+/// Merges the second sorted list of features into the first list of sorted
+/// features
+fn merge(dest: *std.ArrayList(u32), src: []const u32) !void {
+    // TODO: can be in O(n) time and O(1) space
+    try dest.appendSlice(src);
+    sort(dest.items);
+    dest.items = uniq(dest.items);
+}
+
 fn hashPCs(pcs: []const usize) u64 {
     var hasher = std.hash.Wyhash.init(0);
     hasher.update(std.mem.asBytes(pcs));
@@ -26,7 +187,7 @@ fn hashPCs(pcs: []const usize) u64 {
 /// - list of PC addresses (usize elements)
 /// - list of hit flag, 1 bit per address (stored in u8 elements)
 fn initCoverageFile(cache_dir: std.fs.Dir, coverage_file_path: []const u8, pcs: []const usize) MemoryMappedList(u8) {
-    const coverage_file = util.createFileBail(cache_dir, coverage_file_path, .{
+    const coverage_file = createFileBail(cache_dir, coverage_file_path, .{
         .read = true,
         .truncate = false,
     });
@@ -184,6 +345,11 @@ pub const Fuzzer = struct {
         };
     }
 
+    pub fn deinit(f: *Fuzzer) void {
+        f.input_pool.deinit();
+        f.seen_pcs.deinit();
+    }
+
     fn readOptions(f: *Fuzzer, options: *const std.testing.FuzzInputOptions) void {
         // Otherwise the options corpus would be re-added every time we restart
         // the fuzzer
@@ -194,7 +360,7 @@ pub const Fuzzer = struct {
         }
     }
 
-    pub fn makeUpInitialCorpus(f: *Fuzzer) void {
+    fn makeUpInitialCorpus(f: *Fuzzer) void {
         var buffer: [256]u8 = undefined;
         for (0..256) |len| {
             const slice = buffer[0..len];
@@ -283,10 +449,10 @@ pub const Fuzzer = struct {
 
     fn analyzeLastRun(f: *Fuzzer) void {
         var features = feature_capture.values();
-        util.sort(features);
-        features = util.uniq(features);
+        sort(features);
+        features = uniq(features);
 
-        const analysis = util.cmp(features, f.all_features.items);
+        const analysis = cmp(features, f.all_features.items);
 
         if (analysis.only_a == 0) {
             return; // bad input
@@ -310,7 +476,7 @@ pub const Fuzzer = struct {
         }
 
         var ar = f.all_features.toManaged(f.gpa);
-        check(@src(), util.merge(&ar, features), .{});
+        check(@src(), merge(&ar, features), .{});
         f.all_features = ar.moveToUnmanaged();
         updateGlobalCoverage(f.pc_counters, f.seen_pcs);
     }

lib/fuzzer/memory_mapped_list_posix.zig

@@ -5,13 +5,10 @@
 // previously mmaped pages become automatically valid without needing to
 // mremap.
 //
-// We don't bother munmaping since all current uses of this datastructure use
-// it for the entire duration of the program.
 
 const std = @import("std");
 const assert = std.debug.assert;
-const util = @import("util.zig");
-const check = util.check;
+const check = @import("main.zig").check;
 
 pub fn MemoryMappedList(comptime T: type) type {
     return struct {
@@ -48,6 +45,22 @@ pub fn MemoryMappedList(comptime T: type) type {
             };
         }
 
+        pub fn deinit(self: *Self) void {
+            // volatileCast is safe. mem is never used to actually write to or
+            // read from
+            const startT: [*]align(std.mem.page_size) T = @volatileCast(self.items.ptr);
+            const start8: [*]align(std.mem.page_size) u8 = @ptrCast(startT);
+            const len8: usize = self.items.len * @sizeOf(T);
+            // We don't bother munmaping since all current uses of this struct
+            // use it until the end of the program. Even this msync is more of
+            // a politeness than a necessity:
+            // https://stackoverflow.com/questions/31539208/posix-shared-memory-and-msync
+            check(@src(), std.posix.msync(start8[0..len8], std.posix.MSF.ASYNC), .{
+                .ptr = start8,
+                .len = len8,
+            });
+        }
+
         pub fn append(self: *Self, item: T) void {
             return self.appendSlice(&[1]T{item});
         }