all: make proc restart frequency configurable

Instead of always using the default value of 600, make it possible to
set it via the manager config. For now in the experimental list of
features.

Author: a-nogikh

executor/executor_runner.h

@@ -90,6 +90,7 @@ class ProcOpts
 	uint32 slowdown = 0;
 	uint32 syscall_timeout_ms = 0;
 	uint32 program_timeout_ms = 0;
+	uint32 proc_restart_freq = 0;
 
 private:
 	friend std::ostream& operator<<(std::ostream& ss, const ProcOpts& opts)
@@ -98,7 +99,8 @@ class ProcOpts
 		   << " is_kernel_64_bit=" << opts.is_kernel_64_bit
 		   << " slowdown=" << opts.slowdown
 		   << " syscall_timeout_ms=" << opts.syscall_timeout_ms
-		   << " program_timeout_ms=" << opts.program_timeout_ms;
+		   << " program_timeout_ms=" << opts.program_timeout_ms
+		   << " proc_restart_freq=" << opts.proc_restart_freq;
 		return ss;
 	}
 };
@@ -140,8 +142,7 @@ class Proc
 			wait_end_ = current_time_ms();
 		// Restart every once in a while to not let too much state accumulate.
 		// Also request if request type differs as it affects program timeout.
-		constexpr uint64 kRestartEvery = 600;
-		if (state_ == State::Idle && ((corpus_triaged_ && restarting_ == 0 && freshness_ >= kRestartEvery) ||
+		if (state_ == State::Idle && ((corpus_triaged_ && restarting_ == 0 && freshness_ >= opts_.proc_restart_freq) ||
 					      req_type_ != msg.type ||
 					      exec_env_ != msg.exec_opts->env_flags() || sandbox_arg_ != msg.exec_opts->sandbox_arg()))
 			Restart();
@@ -662,17 +663,20 @@ class Runner
 		if (conn_reply.debug)
 			flag_debug = true;
 		debug("connected to manager: procs=%d cover_edges=%d kernel_64_bit=%d slowdown=%d syscall_timeout=%u"
-		      " program_timeout=%u features=0x%llx\n",
+		      " program_timeout=%u proc_restart_freq=%d features=0x%llx\n",
 		      conn_reply.procs, conn_reply.cover_edges, conn_reply.kernel_64_bit,
 		      conn_reply.slowdown, conn_reply.syscall_timeout_ms,
-		      conn_reply.program_timeout_ms, static_cast<uint64>(conn_reply.features));
+		      conn_reply.program_timeout_ms, conn_reply.proc_restart_freq, static_cast<uint64>(conn_reply.features));
 		leak_frames_ = conn_reply.leak_frames;
 
 		proc_opts_.use_cover_edges = conn_reply.cover_edges;
 		proc_opts_.is_kernel_64_bit = is_kernel_64_bit = conn_reply.kernel_64_bit;
 		proc_opts_.slowdown = conn_reply.slowdown;
 		proc_opts_.syscall_timeout_ms = conn_reply.syscall_timeout_ms;
 		proc_opts_.program_timeout_ms = conn_reply.program_timeout_ms;
+		proc_opts_.proc_restart_freq = conn_reply.proc_restart_freq;
+		if (proc_opts_.proc_restart_freq == 0)
+			fail("invalid proc_restart_freq value");
 		if (conn_reply.cover)
 			max_signal_.emplace();
 

pkg/flatrpc/flatrpc.fbs

@@ -57,6 +57,7 @@ table ConnectReplyRaw {
 	slowdown		:int32;
 	syscall_timeout_ms	:int32;
 	program_timeout_ms	:int32;
+	proc_restart_freq	:int32;
 	leak_frames		:[string];
 	race_frames		:[string];
 	// Fuzzer sets up these features and returns results in InfoRequest.features.

pkg/flatrpc/flatrpc.go

@@ -1036,6 +1036,7 @@ struct ConnectReplyRawT : public flatbuffers::NativeTable {
   int32_t slowdown = 0;
   int32_t syscall_timeout_ms = 0;
   int32_t program_timeout_ms = 0;
+  int32_t proc_restart_freq = 0;
   std::vector<std::string> leak_frames{};
   std::vector<std::string> race_frames{};
   rpc::Feature features = static_cast<rpc::Feature>(0);
@@ -1054,10 +1055,11 @@ struct ConnectReplyRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_SLOWDOWN = 14,
     VT_SYSCALL_TIMEOUT_MS = 16,
     VT_PROGRAM_TIMEOUT_MS = 18,
-    VT_LEAK_FRAMES = 20,
-    VT_RACE_FRAMES = 22,
-    VT_FEATURES = 24,
-    VT_FILES = 26
+    VT_PROC_RESTART_FREQ = 20,
+    VT_LEAK_FRAMES = 22,
+    VT_RACE_FRAMES = 24,
+    VT_FEATURES = 26,
+    VT_FILES = 28
   };
   bool debug() const {
     return GetField<uint8_t>(VT_DEBUG, 0) != 0;
@@ -1083,6 +1085,9 @@ struct ConnectReplyRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int32_t program_timeout_ms() const {
     return GetField<int32_t>(VT_PROGRAM_TIMEOUT_MS, 0);
   }
+  int32_t proc_restart_freq() const {
+    return GetField<int32_t>(VT_PROC_RESTART_FREQ, 0);
+  }
   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *leak_frames() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_LEAK_FRAMES);
   }
@@ -1105,6 +1110,7 @@ struct ConnectReplyRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyField<int32_t>(verifier, VT_SLOWDOWN, 4) &&
            VerifyField<int32_t>(verifier, VT_SYSCALL_TIMEOUT_MS, 4) &&
            VerifyField<int32_t>(verifier, VT_PROGRAM_TIMEOUT_MS, 4) &&
+           VerifyField<int32_t>(verifier, VT_PROC_RESTART_FREQ, 4) &&
            VerifyOffset(verifier, VT_LEAK_FRAMES) &&
            verifier.VerifyVector(leak_frames()) &&
            verifier.VerifyVectorOfStrings(leak_frames()) &&
@@ -1150,6 +1156,9 @@ struct ConnectReplyRawBuilder {
   void add_program_timeout_ms(int32_t program_timeout_ms) {
     fbb_.AddElement<int32_t>(ConnectReplyRaw::VT_PROGRAM_TIMEOUT_MS, program_timeout_ms, 0);
   }
+  void add_proc_restart_freq(int32_t proc_restart_freq) {
+    fbb_.AddElement<int32_t>(ConnectReplyRaw::VT_PROC_RESTART_FREQ, proc_restart_freq, 0);
+  }
   void add_leak_frames(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> leak_frames) {
     fbb_.AddOffset(ConnectReplyRaw::VT_LEAK_FRAMES, leak_frames);
   }
@@ -1183,6 +1192,7 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(
     int32_t slowdown = 0,
     int32_t syscall_timeout_ms = 0,
     int32_t program_timeout_ms = 0,
+    int32_t proc_restart_freq = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> leak_frames = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> race_frames = 0,
     rpc::Feature features = static_cast<rpc::Feature>(0),
@@ -1192,6 +1202,7 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(
   builder_.add_files(files);
   builder_.add_race_frames(race_frames);
   builder_.add_leak_frames(leak_frames);
+  builder_.add_proc_restart_freq(proc_restart_freq);
   builder_.add_program_timeout_ms(program_timeout_ms);
   builder_.add_syscall_timeout_ms(syscall_timeout_ms);
   builder_.add_slowdown(slowdown);
@@ -1213,6 +1224,7 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRawDirect(
     int32_t slowdown = 0,
     int32_t syscall_timeout_ms = 0,
     int32_t program_timeout_ms = 0,
+    int32_t proc_restart_freq = 0,
     const std::vector<flatbuffers::Offset<flatbuffers::String>> *leak_frames = nullptr,
     const std::vector<flatbuffers::Offset<flatbuffers::String>> *race_frames = nullptr,
     rpc::Feature features = static_cast<rpc::Feature>(0),
@@ -1230,6 +1242,7 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRawDirect(
       slowdown,
       syscall_timeout_ms,
       program_timeout_ms,
+      proc_restart_freq,
       leak_frames__,
       race_frames__,
       features,
@@ -3052,6 +3065,7 @@ inline void ConnectReplyRaw::UnPackTo(ConnectReplyRawT *_o, const flatbuffers::r
   { auto _e = slowdown(); _o->slowdown = _e; }
   { auto _e = syscall_timeout_ms(); _o->syscall_timeout_ms = _e; }
   { auto _e = program_timeout_ms(); _o->program_timeout_ms = _e; }
+  { auto _e = proc_restart_freq(); _o->proc_restart_freq = _e; }
   { auto _e = leak_frames(); if (_e) { _o->leak_frames.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->leak_frames[_i] = _e->Get(_i)->str(); } } }
   { auto _e = race_frames(); if (_e) { _o->race_frames.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->race_frames[_i] = _e->Get(_i)->str(); } } }
   { auto _e = features(); _o->features = _e; }
@@ -3074,6 +3088,7 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(flatbuffers::F
   auto _slowdown = _o->slowdown;
   auto _syscall_timeout_ms = _o->syscall_timeout_ms;
   auto _program_timeout_ms = _o->program_timeout_ms;
+  auto _proc_restart_freq = _o->proc_restart_freq;
   auto _leak_frames = _o->leak_frames.size() ? _fbb.CreateVectorOfStrings(_o->leak_frames) : 0;
   auto _race_frames = _o->race_frames.size() ? _fbb.CreateVectorOfStrings(_o->race_frames) : 0;
   auto _features = _o->features;
@@ -3088,6 +3103,7 @@ inline flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(flatbuffers::F
       _slowdown,
       _syscall_timeout_ms,
       _program_timeout_ms,
+      _proc_restart_freq,
       _leak_frames,
       _race_frames,
       _features,

pkg/flatrpc/flatrpc.h

@@ -255,6 +255,11 @@ type Experimental struct {
 	// with an empty Filter, but non-empty weight.
 	// E.g. "focus_areas": [ {"filter": {"files": ["^net"]}, "weight": 10.0}, {"weight": 1.0} ].
 	FocusAreas []FocusArea `json:"focus_areas,omitempty"`
+
+	// The number of executions per proc before it's restarted.
+	// Lower values may improve bug reproduction rates, but they slow down fuzzing considerably.
+	// The default value is 600.
+	ProcRestartFreq int `json:"proc_restart_freq,omitempty"`
 }
 
 type FocusArea struct {

pkg/mgrconfig/config.go

@@ -47,11 +47,12 @@ type Config struct {
 	FilterSignal      bool
 	PrintMachineCheck bool
 	// Abort early on syz-executor not replying to requests and print extra debugging information.
-	DebugTimeouts bool
-	Procs         int
-	Slowdown      int
-	pcBase        uint64
-	localModules  []*vminfo.KernelModule
+	DebugTimeouts   bool
+	Procs           int
+	Slowdown        int
+	ProcRestartFreq int
+	pcBase          uint64
+	localModules    []*vminfo.KernelModule
 
 	// RPCServer closes the channel once the machine check has begun. Used for fault injection during testing.
 	machineCheckStarted chan struct{}
@@ -184,6 +185,7 @@ func New(cfg *RemoteConfig) (Server, error) {
 		PrintMachineCheck: true,
 		Procs:             cfg.Procs,
 		Slowdown:          cfg.Timeouts.Slowdown,
+		ProcRestartFreq:   cfg.Experimental.ProcRestartFreq,
 		pcBase:            pcBase,
 		localModules:      cfg.LocalModules,
 	}, cfg.Manager), nil
@@ -328,12 +330,18 @@ func (serv *server) handleConn(ctx context.Context, conn *flatrpc.Conn) error {
 	return nil
 }
 
+const defaultProcRestartFreq = 600
+
 func (serv *server) handleRunnerConn(ctx context.Context, runner *Runner, conn *flatrpc.Conn) error {
 	opts := &handshakeConfig{
-		VMLess:   serv.cfg.VMLess,
-		Files:    serv.checker.RequiredFiles(),
-		Timeouts: serv.timeouts,
-		Callback: serv.handleMachineInfo,
+		VMLess:          serv.cfg.VMLess,
+		Files:           serv.checker.RequiredFiles(),
+		Timeouts:        serv.timeouts,
+		Callback:        serv.handleMachineInfo,
+		ProcRestartFreq: defaultProcRestartFreq,
+	}
+	if serv.cfg.ProcRestartFreq != 0 {
+		opts.ProcRestartFreq = serv.cfg.ProcRestartFreq
 	}
 	opts.LeakFrames, opts.RaceFrames = serv.mgr.BugFrames()
 	if serv.checkDone.Load() {