pkg/instance, syz-runner, syz-verifier: add option to create a new environment for each program

4 files changed, 34 insertions, 6 deletions

diff --git a/pkg/instance/instance.go b/pkg/instance/instance.go
index c65d97cce..e0c1e3ce8 100644
--- a/pkg/instance/instance.go
+++ b/pkg/instance/instance.go
@@ -500,8 +500,7 @@ var MakeBin = func() string {
 	return "make"
 }()
 
-func RunnerCmd(prog, fwdAddr, os, arch string, poolIdx, vmIdx int, collide, threaded bool) string {
+func RunnerCmd(prog, fwdAddr, os, arch string, poolIdx, vmIdx int, collide, threaded, newEnv bool) string {
 	return fmt.Sprintf("%s -addr=%s -os=%s -arch=%s -pool=%d -vm=%d "+
-		"-collide=%t -threaded=%t", prog, fwdAddr, os, arch, poolIdx, vmIdx,
-		collide, threaded)
+		"-collide=%t -threaded=%t -new-env=%t", prog, fwdAddr, os, arch, poolIdx, vmIdx, collide, threaded, newEnv)
 }
diff --git a/pkg/instance/instance_test.go b/pkg/instance/instance_test.go
index 7d2ce3031..5b0bcd4e6 100644
--- a/pkg/instance/instance_test.go
+++ b/pkg/instance/instance_test.go
@@ -151,8 +151,9 @@ func TestRunnerCmd(t *testing.T) {
 	flagVM := flags.Int("vm", 0, "index of VM that started the Runner")
 	flagCollide := flags.Bool("collide", true, "collide syscalls to provoke data races")
 	flagThreaded := flags.Bool("threaded", true, "use threaded mode in executor")
+	flagEnv := flags.Bool("new-env", true, "create a new environment for each program")
 
-	cmdLine := RunnerCmd(os.Args[0], "localhost:1234", targets.Linux, targets.AMD64, 0, 0, false, false)
+	cmdLine := RunnerCmd(os.Args[0], "localhost:1234", targets.Linux, targets.AMD64, 0, 0, false, false, false)
 	args := strings.Split(cmdLine, " ")[1:]
 	if err := flags.Parse(args); err != nil {
 		t.Fatalf("error parsing flags: %v, want: nil", err)
@@ -185,4 +186,8 @@ func TestRunnerCmd(t *testing.T) {
 	if got, want := *flagThreaded, false; got != want {
 		t.Errorf("bad threaded: %t, want: %t", got, want)
 	}
+
+	if got, want := *flagEnv, false; got != want {
+		t.Errorf("bad new-env: %t, want: %t", got, want)
+	}
 }
diff --git a/syz-runner/runner.go b/syz-runner/runner.go
index 95dc99f39..033c01525 100644
--- a/syz-runner/runner.go
+++ b/syz-runner/runner.go
@@ -23,6 +23,7 @@ type Runner struct {
 	opts     *ipc.ExecOpts
 	config   *ipc.Config
 	pool, vm int
+	newEnv   bool
 }
 
 func main() {
@@ -31,6 +32,8 @@ func main() {
 	flagAddr := flag.String("addr", "", "verifier rpc address")
 	flagOS := flag.String("os", runtime.GOOS, "target OS")
 	flagArch := flag.String("arch", runtime.GOARCH, "target arch")
+	flagEnv := flag.Bool("new-env", true, "create a new environment for each program")
+
 	flag.Parse()
 
 	target, err := prog.GetTarget(*flagOS, *flagArch)
@@ -56,6 +59,7 @@ func main() {
 		config: config,
 		pool:   *flagPool,
 		vm:     *flagVM,
+		newEnv: *flagEnv,
 	}
 
 	a := &rpctype.RunnerConnectArgs{
@@ -97,9 +101,10 @@ func main() {
 // TODO: Implement functionality to execute several programs at once and send back a slice of results.
 func (rn *Runner) Run(firstProg []byte, idx int) {
 	p, pIdx := firstProg, idx
+
 	env, err := ipc.MakeEnv(rn.config, 0)
 	if err != nil {
-		log.Fatalf("failed to create execution environment: %v", err)
+		log.Fatalf("failed to create initial execution environment: %v", err)
 	}
 
 	for {
@@ -112,6 +117,7 @@ func (rn *Runner) Run(firstProg []byte, idx int) {
 		if err != nil {
 			log.Fatalf("failed to execute the program: %v", err)
 		}
+
 		a := &rpctype.NextExchangeArgs{
 			Pool:    rn.pool,
 			VM:      rn.vm,
@@ -125,5 +131,19 @@ func (rn *Runner) Run(firstProg []byte, idx int) {
 		}
 		p = r.Prog
 		pIdx = r.ProgIdx
+
+		if !rn.newEnv {
+			continue
+		}
+
+		err = env.Close()
+		if err != nil {
+			log.Fatalf("failed to close the execution environment: %v", err)
+		}
+
+		env, err = ipc.MakeEnv(rn.config, 0)
+		if err != nil {
+			log.Fatalf("failed to create new execution environmentL %v", err)
+		}
 	}
 }
diff --git a/syz-verifier/main.go b/syz-verifier/main.go
index 00929573f..b29bf4d1e 100755
--- a/syz-verifier/main.go
+++ b/syz-verifier/main.go
@@ -59,6 +59,7 @@ type Verifier struct {
 	reportReasons bool
 	stats         *stats.Stats
 	statsWrite    io.Writer
+	newEnv        bool
 }
 
 // RPCServer is a wrapper around the rpc.Server. It communicates with  Runners,
@@ -108,7 +109,9 @@ func main() {
 	flagDebug := flag.Bool("debug", false, "dump all VM output to console")
 	flagStats := flag.String("stats", "", "where stats will be written when"+
 		"execution of syz-verifier finishes, defaults to stdout")
+	flagEnv := flag.Bool("new-env", true, "create a new environment for each program")
 	flag.Parse()
+
 	pools := make(map[int]*poolInfo)
 	for idx, cfg := range cfgs {
 		var err error
@@ -211,6 +214,7 @@ func main() {
 		addr:          addr,
 		reportReasons: len(cfg.EnabledSyscalls) != 0 || len(cfg.DisabledSyscalls) != 0,
 		statsWrite:    sw,
+		newEnv:        *flagEnv,
 	}
 
 	vrf.srv, err = startRPCServer(vrf)
@@ -244,7 +248,7 @@ func (vrf *Verifier) startInstances() {
 					log.Fatalf("failed to copy executor binary: %v", err)
 				}
 
-				cmd := instance.RunnerCmd(runnerBin, fwdAddr, vrf.target.OS, vrf.target.Arch, idx, 0, false, false)
+				cmd := instance.RunnerCmd(runnerBin, fwdAddr, vrf.target.OS, vrf.target.Arch, idx, 0, false, false, vrf.newEnv)
 				outc, errc, err := inst.Run(pi.cfg.Timeouts.VMRunningTime, vrf.vmStop, cmd)
 				if err != nil {
 					log.Fatalf("failed to start runner: %v", err)