syz-manager: refactor filtered coverage updates

Simplify code. It does not belong to rpc handler.

4 files changed, 20 insertions, 43 deletions

diff --git a/syz-manager/http.go b/syz-manager/http.go
index 587171d16..7b37bbd70 100644
--- a/syz-manager/http.go
+++ b/syz-manager/http.go
@@ -492,7 +492,7 @@ func (mgr *Manager) modulesInfo(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	// NewCanonicalizer() is initialized with serv.modules.
-	modules, err := json.MarshalIndent(mgr.serv.modules, "", "\t")
+	modules, err := json.MarshalIndent(mgr.modules, "", "\t")
 	if err != nil {
 		fmt.Fprintf(w, "unable to create JSON modules info: %v", err)
 		return
diff --git a/syz-manager/manager.go b/syz-manager/manager.go
index 660fb231e..797c5b600 100644
--- a/syz-manager/manager.go
+++ b/syz-manager/manager.go
@@ -1195,8 +1195,17 @@ func fullReproLog(stats *repro.Stats) []byte {
 
 func (mgr *Manager) corpusInputHandler(updates <-chan corpus.NewItemEvent) {
 	for update := range updates {
-		mgr.serv.updateFilteredCover(update.NewCover)
-
+		if len(update.NewCover) != 0 && mgr.coverFilter != nil {
+			if rg, _ := getReportGenerator(mgr.cfg, mgr.modules); rg != nil {
+				filtered := 0
+				for _, pc := range update.NewCover {
+					if mgr.coverFilter[uint32(rg.RestorePC(pc))] != 0 {
+						filtered++
+					}
+				}
+				mgr.statCoverFiltered.Add(filtered)
+			}
+		}
 		if update.Exists {
 			// We only save new progs into the corpus.db file.
 			continue
@@ -1322,8 +1331,7 @@ func (mgr *Manager) collectSyscallInfo() map[string]*corpus.CallCov {
 	return calls
 }
 
-func (mgr *Manager) fuzzerConnect(modules []host.KernelModule) (
-	BugFrames, map[uint32]uint32, map[uint32]uint32, error) {
+func (mgr *Manager) fuzzerConnect(modules []host.KernelModule) (BugFrames, map[uint32]uint32) {
 	mgr.mu.Lock()
 	defer mgr.mu.Unlock()
 
@@ -1346,7 +1354,7 @@ func (mgr *Manager) fuzzerConnect(modules []host.KernelModule) (
 		}
 		mgr.modulesInitialized = true
 	}
-	return frames, mgr.coverFilter, mgr.execCoverFilter, nil
+	return frames, mgr.execCoverFilter
 }
 
 func (mgr *Manager) machineChecked(features *host.Features, globFiles map[string][]string,
diff --git a/syz-manager/rpc.go b/syz-manager/rpc.go
index 577533cb9..64f3bb83c 100644
--- a/syz-manager/rpc.go
+++ b/syz-manager/rpc.go
@@ -27,10 +27,8 @@ type RPCServer struct {
 	mgr                   RPCManagerView
 	cfg                   *mgrconfig.Config
 	server                *rpctype.RPCServer
-	modules               []host.KernelModule
 	port                  int
 	targetEnabledSyscalls map[*prog.Syscall]bool
-	coverFilter           map[uint32]uint32
 	canonicalModules      *cover.Canonicalizer
 
 	mu            sync.Mutex
@@ -52,7 +50,6 @@ type RPCServer struct {
 	statExchangeProgs         *stats.Val
 	statExchangeServerLatency *stats.Val
 	statExchangeClientLatency *stats.Val
-	statCorpusCoverFiltered   *stats.Val
 }
 
 type Runner struct {
@@ -84,7 +81,7 @@ type BugFrames struct {
 
 // RPCManagerView restricts interface between RPCServer and Manager.
 type RPCManagerView interface {
-	fuzzerConnect([]host.KernelModule) (BugFrames, map[uint32]uint32, map[uint32]uint32, error)
+	fuzzerConnect([]host.KernelModule) (BugFrames, map[uint32]uint32)
 	machineChecked(features *host.Features, globFiles map[string][]string, enabledSyscalls map[*prog.Syscall]bool)
 	getFuzzer() *fuzzer.Fuzzer
 }
@@ -111,7 +108,6 @@ func startRPCServer(mgr *Manager) (*RPCServer, error) {
 			"Manager RPC Exchange call latency (us)", stats.Distribution{}),
 		statExchangeClientLatency: stats.Create("exchange fuzzer latency",
 			"End-to-end fuzzer RPC Exchange call latency (us)", stats.Distribution{}),
-		statCorpusCoverFiltered: stats.Create("filtered coverage", "", stats.NoGraph),
 	}
 	s, err := rpctype.NewRPCServer(mgr.cfg.RPC, "Manager", serv, mgr.netCompression)
 	if err != nil {
@@ -128,23 +124,14 @@ func (serv *RPCServer) Connect(a *rpctype.ConnectArgs, r *rpctype.ConnectRes) er
 	log.Logf(1, "fuzzer %v connected", a.Name)
 	serv.statVMRestarts.Add(1)
 
+	bugFrames, execCoverFilter := serv.mgr.fuzzerConnect(a.Modules)
+
 	serv.mu.Lock()
+	defer serv.mu.Unlock()
 	if serv.canonicalModules == nil {
 		serv.canonicalModules = cover.NewCanonicalizer(a.Modules, serv.cfg.Cover)
-		serv.modules = a.Modules
-	}
-	serv.mu.Unlock()
-
-	bugFrames, coverFilter, execCoverFilter, err := serv.mgr.fuzzerConnect(serv.modules)
-	if err != nil {
-		return err
 	}
 
-	serv.mu.Lock()
-	defer serv.mu.Unlock()
-
-	serv.coverFilter = coverFilter
-
 	runner := serv.findRunner(a.Name)
 	runner.mu.Lock()
 	defer runner.mu.Unlock()
@@ -322,25 +309,6 @@ func (serv *RPCServer) findRunner(name string) *Runner {
 	return nil
 }
 
-func (serv *RPCServer) updateFilteredCover(pcs []uint32) error {
-	if len(pcs) == 0 || serv.coverFilter == nil {
-		return nil
-	}
-	// Note: ReportGenerator is already initialized if coverFilter is enabled.
-	rg, err := getReportGenerator(serv.cfg, serv.modules)
-	if err != nil {
-		return err
-	}
-	filtered := 0
-	for _, pc := range pcs {
-		if serv.coverFilter[uint32(rg.RestorePC(pc))] != 0 {
-			filtered++
-		}
-	}
-	serv.statCorpusCoverFiltered.Add(filtered)
-	return nil
-}
-
 func (serv *RPCServer) createInstance(name string, injectLog chan<- []byte) {
 	runner := &Runner{
 		name:       name,
diff --git a/syz-manager/stats.go b/syz-manager/stats.go
index 41c488f40..69f6483e1 100644
--- a/syz-manager/stats.go
+++ b/syz-manager/stats.go
@@ -18,6 +18,7 @@ type Stats struct {
 	statCrashes        *stats.Val
 	statCrashTypes     *stats.Val
 	statSuppressed     *stats.Val
+	statCoverFiltered  *stats.Val
 	statUptime         *stats.Val
 	statFuzzingTime    *stats.Val
 	statAvgBootTime    *stats.Val
@@ -38,7 +39,7 @@ func (mgr *Manager) initStats() {
 		stats.Simple, stats.Graph("crashes"))
 	mgr.statFuzzingTime = stats.Create("fuzzing", "Total fuzzing time in all VMs (seconds)",
 		stats.NoGraph, func(v int, period time.Duration) string { return fmt.Sprintf("%v sec", v/1e9) })
-
+	mgr.statCoverFiltered = stats.Create("filtered coverage", "", stats.NoGraph)
 	mgr.statUptime = stats.Create("uptime", "Total uptime (seconds)", stats.Simple, stats.NoGraph,
 		func() int {
 			firstConnect := mgr.firstConnect.Load()