Implement designated CLI subcommands for fuzzers

* Re-work, re-organize, and centralize the allocators fuzzer code.
* Refactor the snapshot fuzzer.
* Surface-level refactor for the gossip service fuzzer.
* Small refactor for the gossip table fuzzer.

Author: InKryption

.circleci/config.yml

@@ -221,7 +221,7 @@ jobs:
           at: workspace
       - run:
           name: Run Gossip Service Fuzzer
-          command: workspace/zig-out-release/bin/fuzz --seed 19 gossip-service 10000
+          command: workspace/zig-out-release/bin/fuzz --seed 19 gossip-service --max-messages 10_000
 
   gossip_table_fuzz:
     executor: linux-executor
@@ -231,7 +231,7 @@ jobs:
           at: workspace
       - run:
           name: Run Gossip Table Fuzzer
-          command: workspace/zig-out-release/bin/fuzz --seed 19 gossip-table 100000
+          command: workspace/zig-out-release/bin/fuzz --seed 19 gossip-table --max-actions 100_000
 
   allocators_fuzz:
     executor: linux-executor
@@ -241,7 +241,7 @@ jobs:
           at: workspace
       - run:
           name: Run Allocators Fuzzer
-          command: workspace/zig-out-release/bin/fuzz --seed 19 allocators 10000
+          command: workspace/zig-out-release/bin/fuzz --seed 19 allocators --max-actions 10_000
 
   ledger_fuzz:
     executor: linux-executor
@@ -251,7 +251,7 @@ jobs:
           at: workspace
       - run:
           name: Run Ledger Fuzzer
-          command: workspace/zig-out-release/bin/fuzz --seed 19 ledger 10000
+          command: workspace/zig-out-release/bin/fuzz --seed 19 ledger --max-actions 10_000
 
   solana_conformance:
     executor: linux-executor

scripts/kcov_fuzz_allocators.sh

@@ -23,7 +23,7 @@ kcov \
     --include-pattern=src/utils/allocators.zig \
     --exclude-pattern=$HOME/.cache \
     kcov-output/ \
-    ./zig-out/bin/fuzz --seed 19 allocators 50_000
+    ./zig-out/bin/fuzz --seed 19 allocators --max-actions 50_000
 
 # open report
 echo "=> Opening kcov-output/index.html" 

scripts/kcov_fuzz_gossip.sh

@@ -23,7 +23,7 @@ kcov \
     --include-pattern=src/gossip/ \
     --exclude-pattern=$HOME/.cache \
     kcov-output/ \
-    ./zig-out/bin/fuzz --seed 19 gossip-service 50_000
+    ./zig-out/bin/fuzz --seed 19 gossip-service --max-messages 50_000
 
 # open report
 echo "=> Opening kcov-output/index.html" 

scripts/kcov_fuzz_gossip_table.sh

@@ -23,7 +23,7 @@ kcov \
     --include-pattern=src/gossip/ \
     --exclude-pattern=$HOME/.cache \
     kcov-output/ \
-    ./zig-out/bin/fuzz --seed 19 gossip-table 50_000
+    ./zig-out/bin/fuzz --seed 19 gossip-table --max-actions 50_000
 
 # open report
 echo "=> Opening kcov-output/index.html" 

src/accountsdb/fuzz.zig

@@ -57,7 +57,7 @@ pub const RunCmd = struct {
             .max_slots = .{
                 .kind = .named,
                 .name_override = null,
-                .alias = .none,
+                .alias = .m,
                 .default_value = null,
                 .config = {},
                 .help = "The number of slots number which, when surpassed, will exit the fuzzer.",

src/accountsdb/fuzz_snapshot.zig

@@ -1,5 +1,6 @@
 const std = @import("std");
 const sig = @import("../sig.zig");
+const cli = @import("cli");
 
 const bincode = sig.bincode;
 
@@ -15,42 +16,40 @@ const SnapshotManifest = sig.accounts_db.Manifest;
 
 const MAX_FUZZ_TIME_NS = std.time.ns_per_s * 100_000;
 
-pub fn run() !void {
-    const seed = std.crypto.random.int(u64);
-
-    var gpa: std.heap.DebugAllocator(.{}) = .init;
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
-
-    {
-        // open and append seed
-        const SEED_FILE_PATH = sig.TEST_DATA_DIR ++ "fuzz_snapshot_seeds.txt";
-        const seed_file = try std.fs.cwd().createFile(SEED_FILE_PATH, .{ .truncate = false });
-        defer seed_file.close();
+pub const RunCmd = struct {
+    pub const cmd_info: cli.CommandInfo(RunCmd) = .{
+        .help = .{
+            .short = "Fuzz snapshots.",
+            .long = null,
+        },
+        .sub = .{},
+    };
+};
 
-        try seed_file.writer().print("{}\n", .{seed});
-    }
-    std.debug.print("seed: {}\n", .{seed});
+pub fn run(
+    allocator: std.mem.Allocator,
+    seed: u64,
+    run_cmd: RunCmd,
+) !void {
+    _ = run_cmd;
 
-    var prng = std.Random.DefaultPrng.init(seed);
-    const random = prng.random();
+    var prng_state: std.Random.DefaultPrng = .init(seed);
+    const prng = prng_state.random();
 
-    var bytes_buffer = std.ArrayList(u8).init(allocator);
-    defer bytes_buffer.deinit();
+    var bytes_buffer: std.ArrayListUnmanaged(u8) = .empty;
+    defer bytes_buffer.deinit(allocator);
 
     var i: u64 = 0;
-
-    var timer = try std.time.Timer.start();
+    var timer: std.time.Timer = try .start();
     while (timer.read() < MAX_FUZZ_TIME_NS) : (i += 1) {
         bytes_buffer.clearRetainingCapacity();
 
-        const manifest_original: SnapshotManifest = try randomSnapshotManifest(allocator, random);
+        const manifest_original: SnapshotManifest = try randomSnapshotManifest(allocator, prng);
         defer manifest_original.deinit(allocator);
 
-        try bytes_buffer.ensureUnusedCapacity(bincode.sizeOf(manifest_original, .{}) * 2);
-
+        try bytes_buffer.ensureUnusedCapacity(allocator, bincode.sizeOf(manifest_original, .{}) * 2);
         const original_bytes_start = bytes_buffer.items.len;
-        try bincode.write(bytes_buffer.writer(), manifest_original, .{});
+        try bincode.write(bytes_buffer.writer(allocator), manifest_original, .{});
         const original_bytes_end = bytes_buffer.items.len;
 
         const snapshot_deserialized = try bincode.readFromSlice(
@@ -62,7 +61,7 @@ pub fn run() !void {
         defer snapshot_deserialized.deinit(allocator);
 
         const serialized_bytes_start = bytes_buffer.items.len;
-        try bincode.write(bytes_buffer.writer(), snapshot_deserialized, .{});
+        try bincode.write(bytes_buffer.writer(allocator), snapshot_deserialized, .{});
         const serialized_bytes_end = bytes_buffer.items.len;
 
         const original_bytes = bytes_buffer.items[original_bytes_start..original_bytes_end];

src/fuzz.zig

@@ -7,6 +7,7 @@ const gossip_service_fuzz = sig.gossip.fuzz_service;
 const gossip_table_fuzz = sig.gossip.fuzz_table;
 const snapshot_fuzz = sig.accounts_db.fuzz_snapshot;
 const ledger_fuzz = sig.ledger.fuzz_ledger;
+const allocators_fuzz = sig.utils.allocators.fuzzer;
 
 // Supported fuzz filters.
 // NOTE: changing these enum variants will require a change to the fuzz/kcov in `scripts/`
@@ -24,34 +25,13 @@ const Cmd = struct {
     seed: ?u64,
     fuzzer: ?union(FuzzFilter) {
         accountsdb: accountsdb_fuzz.RunCmd,
-        snapshot: FuzzerTodo,
-        gossip_service: FuzzerTodo,
-        gossip_table: FuzzerTodo,
-        ledger: FuzzerTodo,
-        allocators: FuzzerTodo,
+        snapshot: snapshot_fuzz.RunCmd,
+        gossip_service: gossip_service_fuzz.RunCmd,
+        gossip_table: gossip_table_fuzz.RunCmd,
+        ledger: ledger_fuzz.RunCmd,
+        allocators: allocators_fuzz.RunCmd,
     },
 
-    const FuzzerTodo = struct {
-        args: []const []const u8,
-
-        pub const cmd_info: cli.CommandInfo(FuzzerTodo) = .{
-            .help = .{
-                .short = "TODO: implement bespoke CLI integration for this fuzzer.",
-                .long = null,
-            },
-            .sub = .{
-                .args = .{
-                    .kind = .positional,
-                    .name_override = null,
-                    .alias = .none,
-                    .default_value = &.{},
-                    .config = .string,
-                    .help = "Args to pass to the specified fuzzer.",
-                },
-            },
-        };
-    };
-
     const parser = cli.Parser(Cmd, .{
         .help = .{
             .short = "Fuzz a component of the validator.",
@@ -61,33 +41,33 @@ const Cmd = struct {
             .data_dir = .{
                 .kind = .named,
                 .name_override = null,
-                .alias = .none,
+                .alias = .d,
                 .default_value = null,
                 .config = .string,
                 .help = "Directory for all fuzzers to store their on-disk data relative to.",
             },
             .seed = .{
                 .kind = .named,
                 .name_override = null,
-                .alias = .none,
+                .alias = .s,
                 .default_value = null,
                 .config = {},
                 .help = "Seed for the PRNG for all random actions taken during fuzzing.",
             },
             .fuzzer = .{
                 .accountsdb = accountsdb_fuzz.RunCmd.cmd_info,
-                .snapshot = FuzzerTodo.cmd_info,
-                .gossip_service = FuzzerTodo.cmd_info,
-                .gossip_table = FuzzerTodo.cmd_info,
-                .ledger = FuzzerTodo.cmd_info,
-                .allocators = FuzzerTodo.cmd_info,
+                .snapshot = snapshot_fuzz.RunCmd.cmd_info,
+                .gossip_service = gossip_service_fuzz.RunCmd.cmd_info,
+                .gossip_table = gossip_table_fuzz.RunCmd.cmd_info,
+                .ledger = ledger_fuzz.RunCmd.cmd_info,
+                .allocators = allocators_fuzz.RunCmd.cmd_info,
             },
         },
     });
 };
 
 pub fn main() !void {
-    var gpa_state: std.heap.DebugAllocator(.{}) = .init;
+    var gpa_state: std.heap.DebugAllocator(.{ .safety = true }) = .init;
     defer _ = gpa_state.deinit();
     const gpa = gpa_state.allocator();
 
@@ -165,10 +145,19 @@ pub fn main() !void {
             run_cmd,
         ),
 
-        .snapshot => try snapshot_fuzz.run(),
-        .gossip_service => |run_cmd| try gossip_service_fuzz.run(seed, run_cmd.args),
-        .gossip_table => |run_cmd| try gossip_table_fuzz.run(seed, run_cmd.args),
-        .ledger => |run_cmd| try ledger_fuzz.run(seed, run_cmd.args),
-        .allocators => |run_cmd| try sig.utils.allocators.runFuzzer(seed, run_cmd.args),
+        .snapshot,
+        => |run_cmd| try snapshot_fuzz.run(gpa, seed, run_cmd),
+
+        .gossip_service,
+        => |run_cmd| try gossip_service_fuzz.run(gpa, seed, run_cmd),
+
+        .gossip_table,
+        => |run_cmd| try gossip_table_fuzz.run(gpa, .from(logger), seed, run_cmd),
+
+        .allocators,
+        => |run_cmd| try allocators_fuzz.run(gpa, seed, run_cmd),
+
+        .ledger,
+        => |run_cmd| try ledger_fuzz.run(seed, run_cmd),
     }
 }

src/gossip/fuzz_service.zig

@@ -2,6 +2,7 @@
 //!     ./zig-out/bin/fuzz <seed> <num_messages>
 const std = @import("std");
 const sig = @import("../sig.zig");
+const cli = @import("cli");
 
 const bincode = sig.bincode;
 
@@ -36,31 +37,38 @@ const SLEEP_TIME = Duration.zero();
 
 const Logger = sig.trace.Logger("gossip.fuzz_service");
 
-pub fn run(seed: u64, args: []const []const u8) !void {
-    var gpa: std.heap.DebugAllocator(.{}) = .init;
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
-
-    // logs
-    var std_logger = try sig.trace.ChannelPrintLogger.init(.{
-        .allocator = std.heap.c_allocator,
-        .max_level = sig.trace.Level.debug,
-        .max_buffer = 1 << 20,
-    }, null);
-    defer std_logger.deinit();
+pub const RunCmd = struct {
+    max_messages: ?u64,
+
+    pub const cmd_info: cli.CommandInfo(@This()) = .{
+        .help = .{
+            .short = "Fuzz gossip.",
+            .long = null,
+        },
+        .sub = .{
+            .max_messages = .{
+                .kind = .named,
+                .name_override = null,
+                .alias = .m,
+                .default_value = null,
+                .config = {},
+                .help = "Maximum number of messages before exiting the fuzzer.",
+            },
+        },
+    };
+};
 
+pub fn run(
+    allocator: std.mem.Allocator,
+    seed: u64,
+    args: RunCmd,
+) !void {
     // setup randomness
-    var prng = std.Random.DefaultPrng.init(seed);
+    var prng_state: std.Random.DefaultPrng = .init(seed);
+    const prng = prng_state.random();
 
     // parse cli args to define where to send packets
-    const maybe_max_messages_string: ?[]const u8 = if (args.len == 0) null else args[0];
-    const maybe_max_messages = blk: {
-        if (maybe_max_messages_string) |max_messages_str| {
-            break :blk try std.fmt.parseInt(u64, max_messages_str, 10);
-        } else {
-            break :blk null;
-        }
-    };
+    const maybe_max_messages = args.max_messages;
 
     // we need two clients:
     //  1) fuzz_client: attacker
@@ -113,12 +121,7 @@ pub fn run(seed: u64, args: []const []const u8) !void {
     }
 
     // start fuzzing
-    try fuzz(
-        dirty_allocator,
-        maybe_max_messages,
-        prng.random(),
-        fuzz_client,
-    );
+    try fuzz(dirty_allocator, maybe_max_messages, prng, fuzz_client);
 }
 
 pub fn fuzz(