gometalinter: check dot imports

Update #538

2 files changed, 28 insertions, 28 deletions

diff --git a/tools/syz-execprog/execprog.go b/tools/syz-execprog/execprog.go
index b59a55682..e64172d9f 100644
--- a/tools/syz-execprog/execprog.go
+++ b/tools/syz-execprog/execprog.go
@@ -17,7 +17,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/cover"
 	"github.com/google/syzkaller/pkg/ipc"
-	. "github.com/google/syzkaller/pkg/log"
+	"github.com/google/syzkaller/pkg/log"
 	"github.com/google/syzkaller/pkg/osutil"
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys"
@@ -45,25 +45,25 @@ func main() {
 
 	target, err := prog.GetTarget(*flagOS, *flagArch)
 	if err != nil {
-		Fatalf("%v", err)
+		log.Fatalf("%v", err)
 	}
 
 	var entries []*prog.LogEntry
 	for _, fn := range flag.Args() {
 		data, err := ioutil.ReadFile(fn)
 		if err != nil {
-			Fatalf("failed to read log file: %v", err)
+			log.Fatalf("failed to read log file: %v", err)
 		}
 		entries = append(entries, target.ParseLog(data)...)
 	}
-	Logf(0, "parsed %v programs", len(entries))
+	log.Logf(0, "parsed %v programs", len(entries))
 	if len(entries) == 0 {
 		return
 	}
 
 	config, execOpts, err := ipc.DefaultConfig()
 	if err != nil {
-		Fatalf("%v", err)
+		log.Fatalf("%v", err)
 	}
 	if config.Flags&ipc.FlagSignal != 0 {
 		execOpts.Flags |= ipc.FlagCollectCover
@@ -110,7 +110,7 @@ func main() {
 			defer wg.Done()
 			env, err := ipc.MakeEnv(config, pid)
 			if err != nil {
-				Fatalf("failed to create ipc env: %v", err)
+				log.Fatalf("failed to create ipc env: %v", err)
 			}
 			defer env.Close()
 			for {
@@ -123,7 +123,7 @@ func main() {
 					idx := pos
 					pos++
 					if idx%len(entries) == 0 && time.Since(lastPrint) > 5*time.Second {
-						Logf(0, "executed programs: %v", idx)
+						log.Logf(0, "executed programs: %v", idx)
 						lastPrint = time.Now()
 					}
 					posMu.Unlock()
@@ -147,7 +147,7 @@ func main() {
 						}
 						data := entry.P.Serialize()
 						logMu.Lock()
-						Logf(0, "executing program %v%v:\n%s", pid, strOpts, data)
+						log.Logf(0, "executing program %v%v:\n%s", pid, strOpts, data)
 						logMu.Unlock()
 					}
 					output, info, failed, hanged, err := env.Exec(callOpts, entry.P)
@@ -157,21 +157,21 @@ func main() {
 					default:
 					}
 					if failed {
-						Logf(0, "BUG: executor-detected bug:\n%s", output)
+						log.Logf(0, "BUG: executor-detected bug:\n%s", output)
 					}
 					if config.Flags&ipc.FlagDebug != 0 || err != nil {
-						Logf(0, "result: failed=%v hanged=%v err=%v\n\n%s",
+						log.Logf(0, "result: failed=%v hanged=%v err=%v\n\n%s",
 							failed, hanged, err, output)
 					}
 					if len(info) != 0 {
-						Logf(1, "RESULT: signal %v, coverage %v errno %v",
+						log.Logf(1, "RESULT: signal %v, coverage %v errno %v",
 							len(info[0].Signal), len(info[0].Cover), info[0].Errno)
 					} else {
-						Logf(1, "RESULT: no calls executed")
+						log.Logf(1, "RESULT: no calls executed")
 					}
 					if *flagCoverFile != "" {
 						for i, inf := range info {
-							Logf(0, "call #%v: signal %v, coverage %v",
+							log.Logf(0, "call #%v: signal %v, coverage %v",
 								i, len(inf.Signal), len(inf.Cover))
 							if len(inf.Cover) == 0 {
 								continue
@@ -182,7 +182,7 @@ func main() {
 							}
 							err := osutil.WriteFile(fmt.Sprintf("%v.%v", *flagCoverFile, i), buf.Bytes())
 							if err != nil {
-								Fatalf("failed to write coverage file: %v", err)
+								log.Fatalf("failed to write coverage file: %v", err)
 							}
 						}
 					}
@@ -206,11 +206,11 @@ func main() {
 							entry.P.MutateWithHints(i, comps, func(p *prog.Prog) {
 								ncandidates++
 								if *flagOutput == "stdout" {
-									Logf(1, "PROGRAM:\n%s", p.Serialize())
+									log.Logf(1, "PROGRAM:\n%s", p.Serialize())
 								}
 							})
 						}
-						Logf(0, "ncomps=%v ncandidates=%v", ncomps, ncandidates)
+						log.Logf(0, "ncomps=%v ncandidates=%v", ncomps, ncandidates)
 					}
 					return true
 				}() {
diff --git a/tools/syz-stress/stress.go b/tools/syz-stress/stress.go
index 2736c2f6f..504e5b58b 100644
--- a/tools/syz-stress/stress.go
+++ b/tools/syz-stress/stress.go
@@ -16,7 +16,7 @@ import (
 	"github.com/google/syzkaller/pkg/db"
 	"github.com/google/syzkaller/pkg/host"
 	"github.com/google/syzkaller/pkg/ipc"
-	. "github.com/google/syzkaller/pkg/log"
+	"github.com/google/syzkaller/pkg/log"
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys"
 )
@@ -40,12 +40,12 @@ func main() {
 	flag.Parse()
 	target, err := prog.GetTarget(*flagOS, *flagArch)
 	if err != nil {
-		Fatalf("%v", err)
+		log.Fatalf("%v", err)
 	}
 	corpus := readCorpus(target)
-	Logf(0, "parsed %v programs", len(corpus))
+	log.Logf(0, "parsed %v programs", len(corpus))
 	if !*flagGenerate && len(corpus) == 0 {
-		Fatalf("nothing to mutate (-generate=false and no corpus)")
+		log.Fatalf("nothing to mutate (-generate=false and no corpus)")
 	}
 
 	calls := buildCallList(target)
@@ -54,7 +54,7 @@ func main() {
 
 	config, execOpts, err := ipc.DefaultConfig()
 	if err != nil {
-		Fatalf("%v", err)
+		log.Fatalf("%v", err)
 	}
 	gate = ipc.NewGate(2**flagProcs, nil)
 	for pid := 0; pid < *flagProcs; pid++ {
@@ -62,7 +62,7 @@ func main() {
 		go func() {
 			env, err := ipc.MakeEnv(config, pid)
 			if err != nil {
-				Fatalf("failed to create execution environment: %v", err)
+				log.Fatalf("failed to create execution environment: %v", err)
 			}
 			rs := rand.NewSource(time.Now().UnixNano() + int64(pid)*1e12)
 			rnd := rand.New(rs)
@@ -84,7 +84,7 @@ func main() {
 		}()
 	}
 	for range time.NewTicker(5 * time.Second).C {
-		Logf(0, "executed %v programs", atomic.LoadUint64(&statExec))
+		log.Logf(0, "executed %v programs", atomic.LoadUint64(&statExec))
 	}
 }
 
@@ -117,13 +117,13 @@ func readCorpus(target *prog.Target) []*prog.Prog {
 	}
 	db, err := db.Open(*flagCorpus)
 	if err != nil {
-		Fatalf("failed to open corpus database: %v", err)
+		log.Fatalf("failed to open corpus database: %v", err)
 	}
 	var progs []*prog.Prog
 	for _, rec := range db.Records {
 		p, err := target.Deserialize(rec.Val)
 		if err != nil {
-			Fatalf("failed to deserialize corpus program: %v", err)
+			log.Fatalf("failed to deserialize corpus program: %v", err)
 		}
 		progs = append(progs, p)
 	}
@@ -141,18 +141,18 @@ func buildCallList(target *prog.Target) map[*prog.Syscall]bool {
 	}
 	calls, disabled, err := host.DetectSupportedSyscalls(target, "none")
 	if err != nil {
-		Logf(0, "failed to detect host supported syscalls: %v", err)
+		log.Logf(0, "failed to detect host supported syscalls: %v", err)
 		calls = make(map[*prog.Syscall]bool)
 		for _, c := range target.Syscalls {
 			calls[c] = true
 		}
 	}
 	for c, reason := range disabled {
-		Logf(0, "unsupported syscall: %v: %v", c.Name, reason)
+		log.Logf(0, "unsupported syscall: %v: %v", c.Name, reason)
 	}
 	calls, disabled = target.TransitivelyEnabledCalls(calls)
 	for c, reason := range disabled {
-		Logf(0, "transitively unsupported: %v: %v", c.Name, reason)
+		log.Logf(0, "transitively unsupported: %v: %v", c.Name, reason)
 	}
 	return calls
 }