syz-manager: refactor fuzzerConnect signature

We try to keep manager.go free of rpc details as much as possible.
fuzzerConnect specifically returned data rather than filled reply.
Pass in only modules and return cover filter bitmap as return value.

2 files changed, 14 insertions, 12 deletions

diff --git a/syz-manager/manager.go b/syz-manager/manager.go
index f62f3d579..517ed0052 100644
--- a/syz-manager/manager.go
+++ b/syz-manager/manager.go
@@ -1041,8 +1041,8 @@ func (mgr *Manager) collectSyscallInfoUnlocked() map[string]*CallCov {
 	return calls
 }
 
-func (mgr *Manager) fuzzerConnect(a *rpctype.ConnectArgs, r *rpctype.ConnectRes) (
-	[]rpctype.RPCInput, BugFrames, map[uint32]uint32, error) {
+func (mgr *Manager) fuzzerConnect(modules []host.KernelModule) (
+	[]rpctype.RPCInput, BugFrames, map[uint32]uint32, []byte, error) {
 	mgr.mu.Lock()
 	defer mgr.mu.Unlock()
 
@@ -1051,25 +1051,26 @@ func (mgr *Manager) fuzzerConnect(a *rpctype.ConnectArgs, r *rpctype.ConnectRes)
 	for _, inp := range mgr.corpus {
 		corpus = append(corpus, inp)
 	}
-	memoryLeakFrames := make([]string, 0, len(mgr.memoryLeakFrames))
+	frames := BugFrames{
+		memoryLeaks: make([]string, 0, len(mgr.memoryLeakFrames)),
+		dataRaces:   make([]string, 0, len(mgr.dataRaceFrames)),
+	}
 	for frame := range mgr.memoryLeakFrames {
-		memoryLeakFrames = append(memoryLeakFrames, frame)
+		frames.memoryLeaks = append(frames.memoryLeaks, frame)
 	}
-	dataRaceFrames := make([]string, 0, len(mgr.dataRaceFrames))
 	for frame := range mgr.dataRaceFrames {
-		dataRaceFrames = append(dataRaceFrames, frame)
+		frames.dataRaces = append(frames.dataRaces, frame)
 	}
 	if !mgr.modulesInitialized {
 		var err error
-		mgr.modules = a.Modules
+		mgr.modules = modules
 		mgr.coverFilterBitmap, mgr.coverFilter, err = mgr.createCoverageFilter()
 		if err != nil {
 			log.Fatalf("failed to create coverage filter: %v", err)
 		}
 		mgr.modulesInitialized = true
 	}
-	r.CoverFilterBitmap = mgr.coverFilterBitmap
-	return corpus, BugFrames{memoryLeaks: memoryLeakFrames, dataRaces: dataRaceFrames}, mgr.coverFilter, nil
+	return corpus, frames, mgr.coverFilter, mgr.coverFilterBitmap, nil
 }
 
 func (mgr *Manager) machineChecked(a *rpctype.CheckArgs, enabledSyscalls map[*prog.Syscall]bool) {
diff --git a/syz-manager/rpc.go b/syz-manager/rpc.go
index 42fff75a2..ca4edbbb8 100644
--- a/syz-manager/rpc.go
+++ b/syz-manager/rpc.go
@@ -55,8 +55,8 @@ type BugFrames struct {
 
 // RPCManagerView restricts interface between RPCServer and Manager.
 type RPCManagerView interface {
-	fuzzerConnect(a *rpctype.ConnectArgs, r *rpctype.ConnectRes) (
-		[]rpctype.RPCInput, BugFrames, map[uint32]uint32, error)
+	fuzzerConnect([]host.KernelModule) (
+		[]rpctype.RPCInput, BugFrames, map[uint32]uint32, []byte, error)
 	machineChecked(result *rpctype.CheckArgs, enabledSyscalls map[*prog.Syscall]bool)
 	newInput(inp rpctype.RPCInput, sign signal.Signal) bool
 	candidateBatch(size int) []rpctype.RPCCandidate
@@ -89,7 +89,7 @@ func (serv *RPCServer) Connect(a *rpctype.ConnectArgs, r *rpctype.ConnectRes) er
 	log.Logf(1, "fuzzer %v connected", a.Name)
 	serv.stats.vmRestarts.inc()
 
-	corpus, bugFrames, coverFilter, err := serv.mgr.fuzzerConnect(a, r)
+	corpus, bugFrames, coverFilter, coverBitmap, err := serv.mgr.fuzzerConnect(a.Modules)
 	if err != nil {
 		return err
 	}
@@ -106,6 +106,7 @@ func (serv *RPCServer) Connect(a *rpctype.ConnectArgs, r *rpctype.ConnectRes) er
 	serv.fuzzers[a.Name] = f
 	r.MemoryLeakFrames = bugFrames.memoryLeaks
 	r.DataRaceFrames = bugFrames.dataRaces
+	r.CoverFilterBitmap = coverBitmap
 	r.EnabledCalls = serv.cfg.Syscalls
 	r.GitRevision = prog.GitRevision
 	r.TargetRevision = serv.cfg.Target.Revision