all: use tool.Failf instead of local functions

15 files changed, 100 insertions, 167 deletions

diff --git a/pkg/csource/gen.go b/pkg/csource/gen.go
index 53b34bbc2..c92c4b581 100644
--- a/pkg/csource/gen.go
+++ b/pkg/csource/gen.go
@@ -11,17 +11,19 @@ import (
 	"io/ioutil"
 	"os"
 	"regexp"
+
+	"github.com/google/syzkaller/pkg/tool"
 )
 
 func main() {
 	out, err := os.Create("generated.go")
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	defer out.Close()
 	data, err := ioutil.ReadFile("../../executor/common.h")
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	executorFilenames := []string{
 		"common_linux.h",
@@ -60,20 +62,15 @@ func main() {
 	fmt.Fprintf(out, "`\n")
 }
 
-func failf(msg string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	os.Exit(1)
-}
-
 func replaceIncludes(filenames []string, location string, data []byte) []byte {
 	for _, include := range filenames {
 		contents, err := ioutil.ReadFile(location + include)
 		if err != nil {
-			failf("%v", err)
+			tool.Fail(err)
 		}
 		replace := []byte("#include \"" + include + "\"")
 		if bytes.Index(data, replace) == -1 {
-			failf("can't find %v include", include)
+			tool.Failf("can't find %v include", include)
 		}
 		data = bytes.Replace(data, replace, contents, -1)
 	}
diff --git a/pkg/ifuzz/x86/gen/gen.go b/pkg/ifuzz/x86/gen/gen.go
index 284ea9033..acec104fe 100644
--- a/pkg/ifuzz/x86/gen/gen.go
+++ b/pkg/ifuzz/x86/gen/gen.go
@@ -16,16 +16,17 @@ import (
 	"github.com/google/syzkaller/pkg/ifuzz/iset"
 	"github.com/google/syzkaller/pkg/ifuzz/x86"
 	"github.com/google/syzkaller/pkg/serializer"
+	"github.com/google/syzkaller/pkg/tool"
 )
 
 // nolint: gocyclo, gocognit, funlen
 func main() {
 	if len(os.Args) != 2 {
-		failf("usage: gen instructions.txt")
+		tool.Failf("usage: gen instructions.txt")
 	}
 	f, err := os.Open(os.Args[1])
 	if err != nil {
-		failf("failed to open input file: %v", err)
+		tool.Failf("failed to open input file: %v", err)
 	}
 	defer f.Close()
 
@@ -37,7 +38,7 @@ func main() {
 	for i := 1; s.Scan(); i++ {
 		reportError := func(msg string, args ...interface{}) {
 			fmt.Fprintf(os.Stderr, "line %v: %v\n", i, s.Text())
-			failf(msg, args...)
+			tool.Failf(msg, args...)
 		}
 		line := s.Text()
 		if comment := strings.IndexByte(line, '#'); comment != -1 {
@@ -559,8 +560,3 @@ func addImm(insn *x86.Insn, imm int8) {
 	}
 	panic("too many immediates")
 }
-
-func failf(msg string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	os.Exit(1)
-}
diff --git a/sys/fuchsia/fidlgen/main.go b/sys/fuchsia/fidlgen/main.go
index b4942a08d..937ef62d1 100644
--- a/sys/fuchsia/fidlgen/main.go
+++ b/sys/fuchsia/fidlgen/main.go
@@ -13,6 +13,7 @@ import (
 	"github.com/google/syzkaller/pkg/ast"
 	"github.com/google/syzkaller/pkg/compiler"
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/tool"
 	"github.com/google/syzkaller/sys/fuchsia/layout"
 	"github.com/google/syzkaller/sys/targets"
 )
@@ -21,13 +22,13 @@ func main() {
 	targetArch := os.Getenv("TARGETARCH")
 	target := targets.Get(targets.Fuchsia, targetArch)
 	if target == nil {
-		failf("unknown TARGETARCH %s", targetArch)
+		tool.Failf("unknown TARGETARCH %s", targetArch)
 	}
 	arch := target.KernelHeaderArch
 
 	sourceDir := os.Getenv("SOURCEDIR")
 	if !osutil.IsExist(sourceDir) {
-		failf("cannot find SOURCEDIR %s", sourceDir)
+		tool.Failf("cannot find SOURCEDIR %s", sourceDir)
 	}
 
 	fidlgenPath := filepath.Join(
@@ -38,7 +39,7 @@ func main() {
 		"fidlgen_syzkaller",
 	)
 	if !osutil.IsExist(fidlgenPath) {
-		failf("cannot find fidlgen %s", fidlgenPath)
+		tool.Failf("cannot find fidlgen %s", fidlgenPath)
 	}
 
 	var newFiles []string
@@ -62,14 +63,14 @@ func main() {
 		errorMsg = msg
 	})
 	if desc == nil {
-		failf("parsing failed at %v: %v", errorPos, errorMsg)
+		tool.Failf("parsing failed at %v: %v", errorPos, errorMsg)
 	}
 
 	unused := make(map[ast.Node]bool)
 
 	nodes, err := compiler.CollectUnused(desc, target, nil)
 	if err != nil {
-		failf("collect unused nodes failed: %v", err)
+		tool.Failf("collect unused nodes failed: %v", err)
 	}
 
 	for _, n := range nodes {
@@ -88,14 +89,14 @@ func main() {
 		}))
 
 		if err := osutil.WriteFile(file, desc); err != nil {
-			failf("%v", err)
+			tool.Fail(err)
 		}
 	}
 }
 
 func fidlgen(fidlgenPath, jsonPath, txtPathBase string) string {
 	if !osutil.IsExist(jsonPath) {
-		failf("cannot find %s", jsonPath)
+		tool.Failf("cannot find %s", jsonPath)
 	}
 
 	out, err := osutil.RunCmd(time.Minute, "",
@@ -108,13 +109,8 @@ func fidlgen(fidlgenPath, jsonPath, txtPathBase string) string {
 	}
 
 	if err != nil {
-		failf("fidlgen failed: %v", err)
+		tool.Failf("fidlgen failed: %v", err)
 	}
 
 	return fmt.Sprintf("%s.syz.txt", txtPathBase)
 }
-
-func failf(msg string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	os.Exit(1)
-}
diff --git a/sys/syz-extract/extract.go b/sys/syz-extract/extract.go
index 477877d3c..d8ae1eeda 100644
--- a/sys/syz-extract/extract.go
+++ b/sys/syz-extract/extract.go
@@ -17,6 +17,7 @@ import (
 	"github.com/google/syzkaller/pkg/ast"
 	"github.com/google/syzkaller/pkg/compiler"
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/tool"
 	"github.com/google/syzkaller/sys/targets"
 )
 
@@ -69,30 +70,26 @@ var extractors = map[string]Extractor{
 }
 
 func main() {
-	failf := func(msg string, args ...interface{}) {
-		fmt.Fprintf(os.Stderr, msg+"\n", args...)
-		os.Exit(1)
-	}
 	flag.Parse()
 	if *flagBuild && *flagBuildDir != "" {
-		failf("-build and -builddir is an invalid combination")
+		tool.Failf("-build and -builddir is an invalid combination")
 	}
 
 	OS, archArray, files, err := archFileList(*flagOS, *flagArch, flag.Args())
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 
 	extractor := extractors[OS]
 	if extractor == nil {
-		failf("unknown os: %v", OS)
+		tool.Failf("unknown os: %v", OS)
 	}
 	arches, err := createArches(OS, archArray, files)
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	if err := extractor.prepare(*flagSourceDir, *flagBuild, arches); err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 
 	jobC := make(chan interface{}, len(archArray)*len(files))
@@ -135,7 +132,7 @@ func main() {
 			continue
 		}
 		if err := osutil.WriteFile(outname, data); err != nil {
-			failf("failed to write output file: %v", err)
+			tool.Failf("failed to write output file: %v", err)
 		}
 	}
 
diff --git a/sys/syz-sysgen/sysgen.go b/sys/syz-sysgen/sysgen.go
index b62e1dff2..a17186731 100644
--- a/sys/syz-sysgen/sysgen.go
+++ b/sys/syz-sysgen/sysgen.go
@@ -173,7 +173,7 @@ func main() {
 
 		for what, count := range unsupported {
 			if count == len(jobs) {
-				failf("%v is unsupported on all arches (typo?)", what)
+				tool.Failf("%v is unsupported on all arches (typo?)", what)
 			}
 		}
 	}
@@ -305,12 +305,12 @@ func writeExecutorSyscalls(data *ExecutorData) {
 	})
 	buf := new(bytes.Buffer)
 	if err := defsTempl.Execute(buf, data); err != nil {
-		failf("failed to execute defs template: %v", err)
+		tool.Failf("failed to execute defs template: %v", err)
 	}
 	writeFile(filepath.Join(*outDir, "executor", "defs.h"), buf.Bytes())
 	buf.Reset()
 	if err := syscallsTempl.Execute(buf, data); err != nil {
-		failf("failed to execute syscalls template: %v", err)
+		tool.Failf("failed to execute syscalls template: %v", err)
 	}
 	writeFile(filepath.Join(*outDir, "executor", "syscalls.h"), buf.Bytes())
 }
@@ -325,17 +325,12 @@ func writeSource(file string, data []byte) {
 func writeFile(file string, data []byte) {
 	outf, err := os.Create(file)
 	if err != nil {
-		failf("failed to create output file: %v", err)
+		tool.Failf("failed to create output file: %v", err)
 	}
 	defer outf.Close()
 	outf.Write(data)
 }
 
-func failf(msg string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	os.Exit(1)
-}
-
 var defsTempl = template.Must(template.New("").Parse(`// AUTOGENERATED FILE
 
 struct call_attrs_t { {{range $attr := $.CallAttrs}}
diff --git a/tools/syz-benchcmp/benchcmp.go b/tools/syz-benchcmp/benchcmp.go
index 3f1da4f8d..4cc9ad001 100644
--- a/tools/syz-benchcmp/benchcmp.go
+++ b/tools/syz-benchcmp/benchcmp.go
@@ -20,6 +20,7 @@ import (
 	"sort"
 
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/tool"
 )
 
 var (
@@ -68,7 +69,7 @@ func main() {
 	}
 	for _, g := range graphs {
 		if len(g.Points) == 0 {
-			failf("no data points")
+			tool.Failf("no data points")
 		}
 		sort.Sort(pointSlice(g.Points))
 		skipStart(g)
@@ -81,14 +82,14 @@ func main() {
 func readFile(fname string) (data []map[string]uint64) {
 	f, err := os.Open(fname)
 	if err != nil {
-		failf("failed to open input file: %v", err)
+		tool.Failf("failed to open input file: %v", err)
 	}
 	defer f.Close()
 	dec := json.NewDecoder(bufio.NewReader(f))
 	for dec.More() {
 		v := make(map[string]uint64)
 		if err := dec.Decode(&v); err != nil {
-			failf("failed to decode input file %v: %v", fname, err)
+			tool.Failf("failed to decode input file %v: %v", fname, err)
 		}
 		data = append(data, v)
 	}
@@ -185,18 +186,18 @@ func printFinalStats(graphs []*Graph) {
 func display(graphs []*Graph) {
 	outf, err := ioutil.TempFile("", "")
 	if err != nil {
-		failf("failed to create temp file: %v", err)
+		tool.Failf("failed to create temp file: %v", err)
 	}
 	if err := htmlTemplate.Execute(outf, graphs); err != nil {
-		failf("failed to execute template: %v", err)
+		tool.Failf("failed to execute template: %v", err)
 	}
 	outf.Close()
 	name := outf.Name() + ".html"
 	if err := osutil.Rename(outf.Name(), name); err != nil {
-		failf("failed to rename file: %v", err)
+		tool.Failf("failed to rename file: %v", err)
 	}
 	if err := exec.Command("xdg-open", name).Start(); err != nil {
-		failf("failed to start browser: %v", err)
+		tool.Failf("failed to start browser: %v", err)
 	}
 }
 
@@ -206,11 +207,6 @@ func (a pointSlice) Len() int           { return len(a) }
 func (a pointSlice) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 func (a pointSlice) Less(i, j int) bool { return a[i].Time < a[j].Time }
 
-func failf(msg string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	os.Exit(1)
-}
-
 var htmlTemplate = template.Must(
 	template.New("").Parse(`
 <!doctype html>
diff --git a/tools/syz-check/check.go b/tools/syz-check/check.go
index 5961cb6e8..41c9c6b10 100644
--- a/tools/syz-check/check.go
+++ b/tools/syz-check/check.go
@@ -55,10 +55,6 @@ func main() {
 	for arch := range targets.List[targets.Linux] {
 		arches[arch] = flag.String("obj-"+arch, "", arch+" kernel object file")
 	}
-	failf := func(msg string, args ...interface{}) {
-		fmt.Fprintf(os.Stderr, msg+"\n", args...)
-		os.Exit(1)
-	}
 	defer tool.Init()()
 	var warnings []Warn
 	for arch, obj := range arches {
@@ -68,7 +64,7 @@ func main() {
 		}
 		warnings1, err := check(*flagOS, arch, *obj, *flagDWARF, *flagNetlink)
 		if err != nil {
-			failf("%v", err)
+			tool.Fail(err)
 		}
 		warnings = append(warnings, warnings1...)
 		runtime.GC()
diff --git a/tools/syz-cover/syz-cover.go b/tools/syz-cover/syz-cover.go
index 2808cdd96..221567f06 100644
--- a/tools/syz-cover/syz-cover.go
+++ b/tools/syz-cover/syz-cover.go
@@ -61,40 +61,40 @@ func main() {
 	}
 	target := targets.Get(*flagOS, *flagArch)
 	if target == nil {
-		failf("unknown target %v/%v", *flagOS, *flagArch)
+		tool.Failf("unknown target %v/%v", *flagOS, *flagArch)
 	}
 	pcs, err := readPCs(flag.Args())
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	rg, err := cover.MakeReportGenerator(target, *flagVM, *flagKernelObj, *flagKernelSrc, *flagKernelBuildSrc)
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	progs := []cover.Prog{{PCs: pcs}}
 	buf := new(bytes.Buffer)
 	if *flagExport != "" {
 		if err := rg.DoCSV(buf, progs); err != nil {
-			failf("%v", err)
+			tool.Fail(err)
 		}
 		if err := osutil.WriteFile(*flagExport, buf.Bytes()); err != nil {
-			failf("%v", err)
+			tool.Fail(err)
 		}
 		return
 	}
 	if err := rg.DoHTML(buf, progs); err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	fn, err := osutil.TempFile("syz-cover")
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	fn += ".html"
 	if err := osutil.WriteFile(fn, buf.Bytes()); err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	if err := exec.Command("xdg-open", fn).Start(); err != nil {
-		failf("failed to start browser: %v", err)
+		tool.Failf("failed to start browser: %v", err)
 	}
 }
 
@@ -119,8 +119,3 @@ func readPCs(files []string) ([]uint64, error) {
 	}
 	return pcs, nil
 }
-
-func failf(msg string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	os.Exit(1)
-}
diff --git a/tools/syz-db/syz-db.go b/tools/syz-db/syz-db.go
index e6cdb12ce..0b48e7c6d 100644
--- a/tools/syz-db/syz-db.go
+++ b/tools/syz-db/syz-db.go
@@ -17,6 +17,7 @@ import (
 	"github.com/google/syzkaller/pkg/db"
 	"github.com/google/syzkaller/pkg/hash"
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/tool"
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys"
 )
@@ -38,7 +39,7 @@ func main() {
 		}
 		target, err := prog.GetTarget(*flagOS, *flagArch)
 		if err != nil {
-			failf("failed to find target: %v", err)
+			tool.Failf("failed to find target: %v", err)
 		}
 		bench(target, args[1])
 		return
@@ -51,7 +52,7 @@ func main() {
 		var err error
 		target, err = prog.GetTarget(*flagOS, *flagArch)
 		if err != nil {
-			failf("failed to find target: %v", err)
+			tool.Failf("failed to find target: %v", err)
 		}
 	}
 	switch args[0] {
@@ -75,13 +76,13 @@ func usage() {
 func pack(dir, file string, target *prog.Target, version uint64) {
 	files, err := ioutil.ReadDir(dir)
 	if err != nil {
-		failf("failed to read dir: %v", err)
+		tool.Failf("failed to read dir: %v", err)
 	}
 	var records []db.Record
 	for _, file := range files {
 		data, err := ioutil.ReadFile(filepath.Join(dir, file.Name()))
 		if err != nil {
-			failf("failed to read file %v: %v", file.Name(), err)
+			tool.Failf("failed to read file %v: %v", file.Name(), err)
 		}
 		var seq uint64
 		key := file.Name()
@@ -95,7 +96,7 @@ func pack(dir, file string, target *prog.Target, version uint64) {
 			if target != nil {
 				p, err := target.Deserialize(data, prog.NonStrict)
 				if err != nil {
-					failf("failed to deserialize %v: %v", file.Name(), err)
+					tool.Failf("failed to deserialize %v: %v", file.Name(), err)
 				}
 				data = p.Serialize()
 				sig = hash.String(data)
@@ -109,14 +110,14 @@ func pack(dir, file string, target *prog.Target, version uint64) {
 		})
 	}
 	if err := db.Create(file, version, records); err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 }
 
 func unpack(file, dir string) {
 	db, err := db.Open(file)
 	if err != nil {
-		failf("failed to open database: %v", err)
+		tool.Failf("failed to open database: %v", err)
 	}
 	osutil.MkdirAll(dir)
 	for key, rec := range db.Records {
@@ -125,7 +126,7 @@ func unpack(file, dir string) {
 			fname += fmt.Sprintf("-%v", rec.Seq)
 		}
 		if err := osutil.WriteFile(fname, rec.Val); err != nil {
-			failf("failed to output file: %v", err)
+			tool.Failf("failed to output file: %v", err)
 		}
 	}
 }
@@ -134,13 +135,13 @@ func bench(target *prog.Target, file string) {
 	start := time.Now()
 	db, err := db.Open(file)
 	if err != nil {
-		failf("failed to open database: %v", err)
+		tool.Failf("failed to open database: %v", err)
 	}
 	var corpus []*prog.Prog
 	for _, rec := range db.Records {
 		p, err := target.Deserialize(rec.Val, prog.NonStrict)
 		if err != nil {
-			failf("failed to deserialize: %v\n%s", err, rec.Val)
+			tool.Failf("failed to deserialize: %v\n%s", err, rec.Val)
 		}
 		corpus = append(corpus, p)
 	}
@@ -160,8 +161,3 @@ func bench(target *prog.Target, file string) {
 }
 
 var sink interface{}
-
-func failf(msg string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	os.Exit(1)
-}
diff --git a/tools/syz-imagegen/imagegen.go b/tools/syz-imagegen/imagegen.go
index 4ca608254..c2c1eb663 100644
--- a/tools/syz-imagegen/imagegen.go
+++ b/tools/syz-imagegen/imagegen.go
@@ -27,6 +27,7 @@ import (
 	"time"
 
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/tool"
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys"
 	"github.com/google/syzkaller/sys/targets"
@@ -469,23 +470,19 @@ func main() {
 	if *flagDebug {
 		*flagVerbose = true
 	}
-	failf := func(msg string, args ...interface{}) {
-		fmt.Fprintf(os.Stderr, msg+"\n", args...)
-		os.Exit(1)
-	}
 	if *flagPopulate != "" {
 		if err := populate(*flagPopulate, *flagFS); err != nil {
-			failf("%v", err)
+			tool.Fail(err)
 		}
 		return
 	}
 	target, err := prog.GetTarget(targets.Linux, targets.AMD64)
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	images, err := generateImages(target, *flagFS, *flagList)
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	if *flagList {
 		return
@@ -493,11 +490,11 @@ func main() {
 	// Create a single template dir for file systems that need the root dir at creation time.
 	templateDir, err := ioutil.TempDir("", "syz-imagegen")
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	defer os.RemoveAll(templateDir)
 	if err := populateDir(templateDir); err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	shutdown := make(chan struct{})
 	osutil.HandleInterrupts(shutdown)
diff --git a/tools/syz-kcidb/kcidb.go b/tools/syz-kcidb/kcidb.go
index 098602697..7fcb7cf25 100644
--- a/tools/syz-kcidb/kcidb.go
+++ b/tools/syz-kcidb/kcidb.go
@@ -6,12 +6,11 @@ package main
 import (
 	"context"
 	"flag"
-	"fmt"
 	"io/ioutil"
-	"os"
 
 	"github.com/google/syzkaller/dashboard/dashapi"
 	"github.com/google/syzkaller/pkg/kcidb"
+	"github.com/google/syzkaller/pkg/tool"
 )
 
 func main() {
@@ -27,30 +26,26 @@ func main() {
 		flagDashKey    = flag.String("key", "", "dashboard API key")
 		flagBug        = flag.String("bug", "", "bug ID to upload to KCIDB")
 	)
-	failf := func(msg string, args ...interface{}) {
-		fmt.Fprintf(os.Stderr, msg+"\n", args...)
-		os.Exit(1)
-	}
 	flag.Parse()
 
 	dashboard := dashapi.New(*flagDashClient, *flagDashAddr, *flagDashKey)
 	bug, err := dashboard.LoadBug(*flagBug)
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 
 	cred, err := ioutil.ReadFile(*flagCred)
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	kcidb.Validate = true
 	client, err := kcidb.NewClient(context.Background(), origin, projectID, topicName, cred)
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	defer client.Close()
 
 	if err := client.Publish(bug); err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 }
diff --git a/tools/syz-kconf/kconf.go b/tools/syz-kconf/kconf.go
index 20430f1e4..3ee32ada0 100644
--- a/tools/syz-kconf/kconf.go
+++ b/tools/syz-kconf/kconf.go
@@ -19,6 +19,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/kconfig"
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/tool"
 	"github.com/google/syzkaller/pkg/vcs"
 	"github.com/google/syzkaller/sys/targets"
 )
@@ -41,23 +42,16 @@ func main() {
 		flagInstance  = flag.String("instance", "", "instance")
 	)
 	flag.Parse()
-	failf := func(msg string, args ...interface{}) {
-		fmt.Fprintf(os.Stderr, msg+"\n", args...)
-		os.Exit(1)
-	}
-	fail := func(err error) {
-		failf("%v", err)
-	}
 	if *flagSourceDir == "" {
-		failf("missing mandatory flag -sourcedir")
+		tool.Failf("missing mandatory flag -sourcedir")
 	}
 	repo, err := vcs.NewRepo(targets.Linux, "", *flagSourceDir, vcs.OptPrecious)
 	if err != nil {
-		failf("failed to create repo: %v", err)
+		tool.Failf("failed to create repo: %v", err)
 	}
 	instances, err := parseMainSpec(*flagConfig)
 	if err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	// In order to speed up the process we generate instances that use the same kernel revision in parallel.
 	failed := false
@@ -70,12 +64,12 @@ func main() {
 		fmt.Printf("git checkout %v %v\n", inst.Kernel.Repo, inst.Kernel.Tag)
 		if _, err := repo.SwitchCommit(inst.Kernel.Tag); err != nil {
 			if _, err := repo.CheckoutCommit(inst.Kernel.Repo, inst.Kernel.Tag); err != nil {
-				failf("failed to checkout %v/%v: %v", inst.Kernel.Repo, inst.Kernel.Tag, err)
+				tool.Failf("failed to checkout %v/%v: %v", inst.Kernel.Repo, inst.Kernel.Tag, err)
 			}
 		}
 		releaseTag, err := repo.ReleaseTag("HEAD")
 		if err != nil {
-			fail(err)
+			tool.Fail(err)
 		}
 		fmt.Printf("kernel release %v\n", releaseTag)
 		// Now generate all instances that use this kernel revision in parallel (each will use own build dir).
@@ -109,10 +103,10 @@ func main() {
 		}
 	}
 	if failed {
-		failf("some configs failed")
+		tool.Failf("some configs failed")
 	}
 	if len(generated) == 0 {
-		failf("unknown instance name")
+		tool.Failf("unknown instance name")
 	}
 }
 
diff --git a/tools/syz-minconfig/minconfig.go b/tools/syz-minconfig/minconfig.go
index 93446b384..a77a8f47f 100644
--- a/tools/syz-minconfig/minconfig.go
+++ b/tools/syz-minconfig/minconfig.go
@@ -10,7 +10,6 @@ package main
 
 import (
 	"flag"
-	"fmt"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -18,6 +17,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/debugtracer"
 	"github.com/google/syzkaller/pkg/kconfig"
+	"github.com/google/syzkaller/pkg/tool"
 	"github.com/google/syzkaller/sys/targets"
 )
 
@@ -32,15 +32,15 @@ func main() {
 	flag.Parse()
 	kconf, err := kconfig.Parse(targets.Get("linux", *flagArch), filepath.Join(*flagSourceDir, "Kconfig"))
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	base, err := kconfig.ParseConfig(*flagBase)
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	full, err := kconfig.ParseConfig(*flagFull)
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	pred := func(candidate *kconfig.ConfigFile) (bool, error) {
 		for _, cfg := range strings.Split(*flagConfigs, ",") {
@@ -55,12 +55,7 @@ func main() {
 	}
 	res, err := kconf.Minimize(base, full, pred, gt)
 	if err != nil {
-		failf("%v", err)
+		tool.Fail(err)
 	}
 	os.Stdout.Write(res.Serialize())
 }
-
-func failf(msg string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	os.Exit(1)
-}
diff --git a/tools/syz-testbuild/testbuild.go b/tools/syz-testbuild/testbuild.go
index 69f2c67db..d98452ba1 100644
--- a/tools/syz-testbuild/testbuild.go
+++ b/tools/syz-testbuild/testbuild.go
@@ -34,6 +34,7 @@ import (
 	"github.com/google/syzkaller/pkg/instance"
 	"github.com/google/syzkaller/pkg/mgrconfig"
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/tool"
 	"github.com/google/syzkaller/pkg/vcs"
 )
 
@@ -58,12 +59,12 @@ const (
 func main() {
 	flag.Parse()
 	if os.Getuid() != 0 {
-		failf("image build will fail, run under root")
+		tool.Failf("image build will tool.Fail, run under root")
 	}
 	os.Setenv("SYZ_DISABLE_SANDBOXING", "yes")
 	dir, err := ioutil.TempDir("", "syz-testbuild")
 	if err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	defer os.RemoveAll(dir)
 	cfg := &mgrconfig.Config{
@@ -86,36 +87,36 @@ func main() {
 		},
 	}
 	if err := mgrconfig.Complete(cfg); err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	repo, err := vcs.NewRepo(*flagOS, vmType, *flagKernelSrc)
 	if err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	bisecter := repo.(vcs.Bisecter)
 	head, err := repo.HeadCommit()
 	if err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	log.Printf("HEAD is on %v %v", head.Hash, head.Title)
 	tags, err := bisecter.PreviousReleaseTags(head.Hash)
 	if err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	log.Printf("tags: %v", tags)
 	kernelConfig, err := ioutil.ReadFile(*flagKernelConfig)
 	if err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	env, err := instance.NewEnv(cfg)
 	if err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	test(repo, bisecter, kernelConfig, env, head)
 	for _, tag := range tags {
 		com, err := repo.SwitchCommit(tag)
 		if err != nil {
-			fail(err)
+			tool.Fail(err)
 		}
 		test(repo, bisecter, kernelConfig, env, com)
 	}
@@ -124,11 +125,11 @@ func main() {
 func test(repo vcs.Repo, bisecter vcs.Bisecter, kernelConfig []byte, env instance.Env, com *vcs.Commit) {
 	bisectEnv, err := bisecter.EnvForCommit(*flagBisectBin, com.Hash, kernelConfig)
 	if err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	log.Printf("testing: %v %v using %v", com.Hash, com.Title, bisectEnv.Compiler)
 	if err := build.Clean(*flagOS, *flagArch, vmType, *flagKernelSrc); err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	_, _, err = env.BuildKernel(bisectEnv.Compiler, "", *flagUserspace,
 		*flagKernelCmdline, *flagKernelSysctl, bisectEnv.KernelConfig)
@@ -144,7 +145,7 @@ func test(repo vcs.Repo, bisecter vcs.Bisecter, kernelConfig []byte, env instanc
 	log.Printf("build OK")
 	results, err := env.Test(numTests, nil, nil, nil)
 	if err != nil {
-		fail(err)
+		tool.Fail(err)
 	}
 	var verdicts []string
 	for i, res := range results {
@@ -194,12 +195,3 @@ func saveLog(hash string, idx int, data []byte) {
 	}
 	osutil.WriteFile(fmt.Sprintf("%v.%v", hash, idx), data)
 }
-
-func fail(err error) {
-	failf("%v", err)
-}
-
-func failf(msg string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	os.Exit(1)
-}
diff --git a/tools/syz-usbgen/usbgen.go b/tools/syz-usbgen/usbgen.go
index 5b41c28e4..b74e25902 100644
--- a/tools/syz-usbgen/usbgen.go
+++ b/tools/syz-usbgen/usbgen.go
@@ -13,6 +13,7 @@ import (
 	"sort"
 
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/tool"
 )
 
 func main() {
@@ -24,7 +25,7 @@ func main() {
 
 	syslog, err := ioutil.ReadFile(args[0])
 	if err != nil {
-		failf("failed to read file %v: %v", args[0], err)
+		tool.Failf("failed to read file %v: %v", args[0], err)
 	}
 
 	usbIds := extractIds(syslog, "USBID", 34)
@@ -41,7 +42,7 @@ package linux
 	output = append(output, generateIdsVar(hidIds, "hidIds")...)
 
 	if err := osutil.WriteFile(args[1], output); err != nil {
-		failf("failed to output file %v: %v", args[1], err)
+		tool.Failf("failed to output file %v: %v", args[1], err)
 	}
 }
 
@@ -68,7 +69,7 @@ func generateIdsVar(ids []string, name string) []byte {
 	for i, id := range ids {
 		decodedID, err := hex.DecodeString(id)
 		if err != nil {
-			failf("failed to decode hex string %v: %v", id, err)
+			tool.Failf("failed to decode hex string %v: %v", id, err)
 		}
 		prefix := "\t"
 		suffix := " +"
@@ -92,8 +93,3 @@ func usage() {
 	fmt.Fprintf(os.Stderr, "  syz-usbgen syslog.txt sys/linux/init_vusb_ids.go\n")
 	os.Exit(1)
 }
-
-func failf(msg string, args ...interface{}) {
-	fmt.Fprintf(os.Stderr, msg+"\n", args...)
-	os.Exit(1)
-}