pkg/report: support multiple OSes

Introduce report.Reporter interface.
Add an implementation per-OS.
Make users be explicit about OS they are testing.

4 files changed, 56 insertions, 96 deletions

diff --git a/tools/syz-crush/crush.go b/tools/syz-crush/crush.go
index 6deeeffd8..8e7e2b974 100644
--- a/tools/syz-crush/crush.go
+++ b/tools/syz-crush/crush.go
@@ -10,15 +10,14 @@ import (
 	"flag"
 	"fmt"
 	"io/ioutil"
-	"os"
-	"os/signal"
 	"path/filepath"
 	"sync"
 	"sync/atomic"
-	"syscall"
 	"time"
 
-	. "github.com/google/syzkaller/pkg/log"
+	"github.com/google/syzkaller/pkg/log"
+	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/report"
 	"github.com/google/syzkaller/prog"
 	"github.com/google/syzkaller/syz-manager/mgrconfig"
 	"github.com/google/syzkaller/vm"
@@ -32,21 +31,25 @@ func main() {
 	flag.Parse()
 	cfg, err := mgrconfig.LoadFile(*flagConfig)
 	if err != nil {
-		Fatalf("%v", err)
+		log.Fatalf("%v", err)
 	}
 	if len(flag.Args()) != 1 {
-		Fatalf("usage: syz-crush -config=config.file execution.log")
+		log.Fatalf("usage: syz-crush -config=config.file execution.log")
 	}
 	if _, err := prog.GetTarget(cfg.TargetOS, cfg.TargetArch); err != nil {
-		Fatalf("%v", err)
+		log.Fatalf("%v", err)
 	}
 	env := mgrconfig.CreateVMEnv(cfg, false)
 	vmPool, err := vm.Create(cfg.Type, env)
 	if err != nil {
-		Fatalf("%v", err)
+		log.Fatalf("%v", err)
+	}
+	reporter, err := report.NewReporter(cfg.TargetOS, cfg.Kernel_Src, "", nil, cfg.ParsedIgnores)
+	if err != nil {
+		log.Fatalf("%v", err)
 	}
 
-	Logf(0, "booting test machines...")
+	log.Logf(0, "booting test machines...")
 	var shutdown uint32
 	var wg sync.WaitGroup
 	wg.Add(vmPool.Count() + 1)
@@ -55,7 +58,7 @@ func main() {
 		go func() {
 			defer wg.Done()
 			for {
-				runInstance(cfg, vmPool, i)
+				runInstance(cfg, reporter, vmPool, i)
 				if atomic.LoadUint32(&shutdown) != 0 {
 					break
 				}
@@ -63,42 +66,37 @@ func main() {
 		}()
 	}
 
+	shutdownC := make(chan struct{})
+	osutil.HandleInterrupts(shutdownC)
 	go func() {
-		c := make(chan os.Signal, 2)
-		signal.Notify(c, syscall.SIGINT)
-		<-c
+		<-shutdownC
 		wg.Done()
 		atomic.StoreUint32(&shutdown, 1)
-		close(vm.Shutdown)
-		Logf(-1, "shutting down...")
-		atomic.StoreUint32(&shutdown, 1)
-		<-c
-		Fatalf("terminating")
 	}()
 	wg.Wait()
 }
 
-func runInstance(cfg *mgrconfig.Config, vmPool *vm.Pool, index int) {
+func runInstance(cfg *mgrconfig.Config, reporter report.Reporter, vmPool *vm.Pool, index int) {
 	inst, err := vmPool.Create(index)
 	if err != nil {
-		Logf(0, "failed to create instance: %v", err)
+		log.Logf(0, "failed to create instance: %v", err)
 		return
 	}
 	defer inst.Close()
 
 	execprogBin, err := inst.Copy(filepath.Join(cfg.Syzkaller, "bin", "syz-execprog"))
 	if err != nil {
-		Logf(0, "failed to copy execprog: %v", err)
+		log.Logf(0, "failed to copy execprog: %v", err)
 		return
 	}
 	executorBin, err := inst.Copy(filepath.Join(cfg.Syzkaller, "bin", "syz-executor"))
 	if err != nil {
-		Logf(0, "failed to copy executor: %v", err)
+		log.Logf(0, "failed to copy executor: %v", err)
 		return
 	}
 	logFile, err := inst.Copy(flag.Args()[0])
 	if err != nil {
-		Logf(0, "failed to copy log: %v", err)
+		log.Logf(0, "failed to copy log: %v", err)
 		return
 	}
 
@@ -106,15 +104,15 @@ func runInstance(cfg *mgrconfig.Config, vmPool *vm.Pool, index int) {
 		execprogBin, executorBin, cfg.Procs, cfg.Sandbox, logFile)
 	outc, errc, err := inst.Run(time.Hour, nil, cmd)
 	if err != nil {
-		Logf(0, "failed to run execprog: %v", err)
+		log.Logf(0, "failed to run execprog: %v", err)
 		return
 	}
 
-	Logf(0, "vm-%v: crushing...", index)
-	desc, _, output, crashed, timedout := vm.MonitorExecution(outc, errc, true, cfg.ParsedIgnores)
+	log.Logf(0, "vm-%v: crushing...", index)
+	desc, _, output, crashed, timedout := vm.MonitorExecution(outc, errc, true, reporter)
 	if timedout {
 		// This is the only "OK" outcome.
-		Logf(0, "vm-%v: running long enough, restarting", index)
+		log.Logf(0, "vm-%v: running long enough, restarting", index)
 	} else {
 		if !crashed {
 			// syz-execprog exited, but it should not.
@@ -122,11 +120,11 @@ func runInstance(cfg *mgrconfig.Config, vmPool *vm.Pool, index int) {
 		}
 		f, err := ioutil.TempFile(".", "syz-crush")
 		if err != nil {
-			Logf(0, "failed to create temp file: %v", err)
+			log.Logf(0, "failed to create temp file: %v", err)
 			return
 		}
 		defer f.Close()
-		Logf(0, "vm-%v: crashed: %v, saving to %v", index, desc, f.Name())
+		log.Logf(0, "vm-%v: crashed: %v, saving to %v", index, desc, f.Name())
 		f.Write(output)
 	}
 	return
diff --git a/tools/syz-report/syz-report.go b/tools/syz-report/syz-report.go
deleted file mode 100644
index ab57d927a..000000000
--- a/tools/syz-report/syz-report.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2016 syzkaller project authors. All rights reserved.
-// Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
-
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-
-	"github.com/google/syzkaller/pkg/report"
-)
-
-func main() {
-	if len(os.Args) != 3 {
-		fmt.Fprintf(os.Stderr, "usage: syz-report vmlinux report (args %+v)\n", os.Args)
-		os.Exit(1)
-	}
-	output, err := ioutil.ReadFile(os.Args[2])
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to read report file: %v\n", err)
-		os.Exit(1)
-	}
-	desc, text, _, _ := report.Parse(output, nil)
-	if desc == "" {
-		fmt.Fprintf(os.Stderr, "report file does not contain a crash\n")
-		os.Exit(1)
-	}
-	symbolized, err := report.Symbolize(os.Args[1], text, nil)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to symbolize report: %v\n", err)
-	} else {
-		text = symbolized
-	}
-	fmt.Printf("%v\n\n%s", desc, text)
-}
diff --git a/tools/syz-repro/repro.go b/tools/syz-repro/repro.go
index 6d8316866..e51a4d459 100644
--- a/tools/syz-repro/repro.go
+++ b/tools/syz-repro/repro.go
@@ -8,11 +8,11 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"os/signal"
-	"syscall"
 
 	"github.com/google/syzkaller/pkg/csource"
-	. "github.com/google/syzkaller/pkg/log"
+	"github.com/google/syzkaller/pkg/log"
+	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/report"
 	"github.com/google/syzkaller/pkg/repro"
 	"github.com/google/syzkaller/prog"
 	"github.com/google/syzkaller/syz-manager/mgrconfig"
@@ -29,22 +29,22 @@ func main() {
 	flag.Parse()
 	cfg, err := mgrconfig.LoadFile(*flagConfig)
 	if err != nil {
-		Fatalf("%v", err)
+		log.Fatalf("%v", err)
 	}
 	if len(flag.Args()) != 1 {
-		Fatalf("usage: syz-repro -config=config.file execution.log")
+		log.Fatalf("usage: syz-repro -config=config.file execution.log")
 	}
 	data, err := ioutil.ReadFile(flag.Args()[0])
 	if err != nil {
-		Fatalf("failed to open log file: %v", err)
+		log.Fatalf("failed to open log file: %v", err)
 	}
 	if _, err := prog.GetTarget(cfg.TargetOS, cfg.TargetArch); err != nil {
-		Fatalf("%v", err)
+		log.Fatalf("%v", err)
 	}
 	env := mgrconfig.CreateVMEnv(cfg, false)
 	vmPool, err := vm.Create(cfg.Type, env)
 	if err != nil {
-		Fatalf("%v", err)
+		log.Fatalf("%v", err)
 	}
 	vmCount := vmPool.Count()
 	if *flagCount > 0 && *flagCount < vmCount {
@@ -57,20 +57,15 @@ func main() {
 	for i := range vmIndexes {
 		vmIndexes[i] = i
 	}
+	reporter, err := report.NewReporter(cfg.TargetOS, cfg.Kernel_Src, "", nil, cfg.ParsedIgnores)
+	if err != nil {
+		log.Fatalf("%v", err)
+	}
+	osutil.HandleInterrupts(vm.Shutdown)
 
-	go func() {
-		c := make(chan os.Signal, 2)
-		signal.Notify(c, syscall.SIGINT)
-		<-c
-		close(vm.Shutdown)
-		Logf(-1, "shutting down...")
-		<-c
-		Fatalf("terminating")
-	}()
-
-	res, err := repro.Run(data, cfg, vmPool, vmIndexes)
+	res, err := repro.Run(data, cfg, reporter, vmPool, vmIndexes)
 	if err != nil {
-		Logf(0, "reproduction failed: %v", err)
+		log.Logf(0, "reproduction failed: %v", err)
 	}
 	if res == nil {
 		return
@@ -81,7 +76,7 @@ func main() {
 	if res.CRepro {
 		src, err := csource.Write(res.Prog, res.Opts)
 		if err != nil {
-			Fatalf("failed to generate C repro: %v", err)
+			log.Fatalf("failed to generate C repro: %v", err)
 		}
 		if formatted, err := csource.Format(src); err == nil {
 			src = formatted
diff --git a/tools/syz-symbolize/symbolize.go b/tools/syz-symbolize/symbolize.go
index c36ee8dab..6308527cd 100644
--- a/tools/syz-symbolize/symbolize.go
+++ b/tools/syz-symbolize/symbolize.go
@@ -8,14 +8,15 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"path/filepath"
+	"runtime"
 
 	"github.com/google/syzkaller/pkg/report"
 )
 
 var (
+	flagOS        = flag.String("os", runtime.GOOS, "target os")
 	flagKernelSrc = flag.String("kernel_src", "", "path to kernel sources")
-	flagKernelObj = flag.String("kernel_obj", "", "path to kernel build dir")
+	flagKernelObj = flag.String("kernel_obj", "", "path to kernel build/obj dir")
 	flagReport    = flag.Bool("report", false, "extract report from the log")
 )
 
@@ -26,8 +27,10 @@ func main() {
 		flag.PrintDefaults()
 		os.Exit(1)
 	}
-	if *flagKernelSrc == "" {
-		*flagKernelSrc = *flagKernelObj
+	reporter, err := report.NewReporter(*flagOS, *flagKernelSrc, *flagKernelObj, nil, nil)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed to create reporter: %v\n", err)
+		os.Exit(1)
 	}
 	text, err := ioutil.ReadFile(flag.Args()[0])
 	if err != nil {
@@ -35,19 +38,19 @@ func main() {
 		os.Exit(1)
 	}
 	if *flagReport {
-		desc, text, _, _ := report.Parse(text, nil)
-		text, err = report.Symbolize(filepath.Join(*flagKernelObj, "vmlinux"), text, nil)
+		desc, text, _, _ := reporter.Parse(text)
+		text, err = reporter.Symbolize(text)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "failed to symbolize: %v\n", err)
 			os.Exit(1)
 		}
-		guiltyFile := report.ExtractGuiltyFile(text)
+		guiltyFile := reporter.ExtractGuiltyFile(text)
 		fmt.Printf("%v\n\n", desc)
 		os.Stdout.Write(text)
 		fmt.Printf("\n")
 		fmt.Printf("guilty file: %v\n", guiltyFile)
 		if guiltyFile != "" {
-			maintainers, err := report.GetMaintainers(*flagKernelSrc, guiltyFile)
+			maintainers, err := reporter.GetMaintainers(guiltyFile)
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "failed to get maintainers: %v\n", err)
 				os.Exit(1)
@@ -55,10 +58,10 @@ func main() {
 			fmt.Printf("maintainers: %v\n", maintainers)
 		}
 	} else {
-		if console := report.ExtractConsoleOutput(text); len(console) != 0 {
+		if console := reporter.ExtractConsoleOutput(text); len(console) != 0 {
 			text = console
 		}
-		text, err = report.Symbolize(filepath.Join(*flagKernelObj, "vmlinux"), text, nil)
+		text, err = reporter.Symbolize(text)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "failed to symbolize: %v\n", err)
 			os.Exit(1)