all: fix gometalinter warnings

Fix typos, non-canonical code, remove dead code, etc.

33 files changed, 118 insertions, 144 deletions

diff --git a/pkg/ast/parser.go b/pkg/ast/parser.go
index b28658de8..fb3327223 100644
--- a/pkg/ast/parser.go
+++ b/pkg/ast/parser.go
@@ -88,13 +88,13 @@ type parser struct {
 }
 
 // Skip parsing till the next NEWLINE, for error recovery.
-var skipLine = errors.New("")
+var errSkipLine = errors.New("")
 
 func (p *parser) parseTopRecover() Node {
 	defer func() {
 		switch err := recover(); err {
 		case nil:
-		case skipLine:
+		case errSkipLine:
 			// Try to recover by consuming everything until next NEWLINE.
 			for p.tok != tokNewLine && p.tok != tokEOF {
 				p.next()
@@ -143,7 +143,7 @@ func (p *parser) parseTop() Node {
 		}
 	case tokIllegal:
 		// Scanner has already producer an error for this one.
-		panic(skipLine)
+		panic(errSkipLine)
 	default:
 		p.expect(tokComment, tokDefine, tokInclude, tokResource, tokIdent)
 	}
@@ -178,7 +178,7 @@ func (p *parser) expect(tokens ...token) {
 		str = append(str, tok.String())
 	}
 	p.s.Error(p.pos, fmt.Sprintf("unexpected %v, expecting %v", p.tok, strings.Join(str, ", ")))
-	panic(skipLine)
+	panic(errSkipLine)
 }
 
 func (p *parser) parseComment() *Comment {
diff --git a/pkg/ast/test_util.go b/pkg/ast/test_util.go
index fbec645b7..3ffefcccb 100644
--- a/pkg/ast/test_util.go
+++ b/pkg/ast/test_util.go
@@ -61,7 +61,7 @@ func NewErrorMatcher(t *testing.T, file string) *ErrorMatcher {
 	}
 }
 
-var errorLocationRe = regexp.MustCompile("at [a-z][a-z0-9]+\\.txt:[0-9]+:[0-9]+")
+var errorLocationRe = regexp.MustCompile(`at [a-z][a-z0-9]+\.txt:[0-9]+:[0-9]+`)
 
 func (em *ErrorMatcher) ErrorHandler(pos Pos, msg string) {
 	if match := errorLocationRe.FindStringSubmatchIndex(msg); match != nil {
diff --git a/pkg/compiler/check.go b/pkg/compiler/check.go
index 4dac37260..6d304d26b 100644
--- a/pkg/compiler/check.go
+++ b/pkg/compiler/check.go
@@ -578,11 +578,11 @@ func (comp *compiler) checkStruct(ctx checkCtx, n *ast.Struct) {
 type checkFlags int
 
 const (
-	checkIsArg          checkFlags = 1 << iota // immidiate syscall arg type
-	checkIsRet                                 // immidiate syscall ret type
-	checkIsStruct                              // immidiate struct field type
-	checkIsResourceBase                        // immidiate resource base type
-	checkIsTypedef                             // immidiate type alias/template type
+	checkIsArg          checkFlags = 1 << iota // immediate syscall arg type
+	checkIsRet                                 // immediate syscall ret type
+	checkIsStruct                              // immediate struct field type
+	checkIsResourceBase                        // immediate resource base type
+	checkIsTypedef                             // immediate type alias/template type
 )
 
 type checkCtx struct {
@@ -603,7 +603,7 @@ func (comp *compiler) checkType(ctx checkCtx, t *ast.Type, flags checkFlags) {
 		err0 := comp.errors
 		// Replace t with type alias/template target type inplace,
 		// and check the replaced type recursively.
-		comp.replaceTypedef(&ctx, t, desc, flags)
+		comp.replaceTypedef(&ctx, t, flags)
 		if err0 == comp.errors {
 			comp.checkType(ctx, t, flags)
 		}
@@ -682,7 +682,7 @@ func (comp *compiler) checkType(ctx checkCtx, t *ast.Type, flags checkFlags) {
 	}
 }
 
-func (comp *compiler) replaceTypedef(ctx *checkCtx, t *ast.Type, desc *typeDesc, flags checkFlags) {
+func (comp *compiler) replaceTypedef(ctx *checkCtx, t *ast.Type, flags checkFlags) {
 	typedefName := t.Ident
 	if t.HasColon {
 		comp.error(t.Pos, "type alias %v with ':'", t.Ident)
@@ -740,7 +740,7 @@ func (comp *compiler) replaceTypedef(ctx *checkCtx, t *ast.Type, desc *typeDesc,
 	t.Pos = pos0
 
 	// Remove base type if it's not needed in this context.
-	desc = comp.getTypeDesc(t)
+	desc := comp.getTypeDesc(t)
 	if flags&checkIsArg != 0 && desc.NeedBase {
 		baseTypePos := len(t.Args) - 1
 		if t.Args[baseTypePos].Ident == "opt" {
@@ -938,7 +938,9 @@ func (comp *compiler) checkDupConsts() {
 	// The second one is meant to be const[BAR],
 	// Unfortunately, this does not fully work as it detects lots of false positives.
 	// But was useful to find real bugs as well. So for now it's disabled, but can be run manually.
-	return
+	if true {
+		return
+	}
 	dups := make(map[string]map[string]dupConstArg)
 	for _, decl := range comp.desc.Nodes {
 		switch n := decl.(type) {
diff --git a/pkg/compiler/compiler.go b/pkg/compiler/compiler.go
index f0d1176e7..f1e39b269 100644
--- a/pkg/compiler/compiler.go
+++ b/pkg/compiler/compiler.go
@@ -27,7 +27,7 @@ import (
 // 4.1. assignSyscallNumbers: uses consts to assign syscall numbers.
 //      This step also detects unsupported syscalls and discards no longer
 //      needed AST nodes (inlcude, define, comments, etc).
-// 4.2. patchConsts: patches Int nodes refering to consts with corresponding values.
+// 4.2. patchConsts: patches Int nodes referring to consts with corresponding values.
 //      Also detects unsupported syscalls, structs, resources due to missing consts.
 // 4.3. check: does extensive semantical checks of AST.
 // 4.4. gen: generates prog objects from AST.
diff --git a/pkg/compiler/types.go b/pkg/compiler/types.go
index f5ec1221e..019b734dd 100644
--- a/pkg/compiler/types.go
+++ b/pkg/compiler/types.go
@@ -267,10 +267,7 @@ var typeFilename = &typeDesc{
 	OptArgs:   1,
 	Args:      []namedArg{{"size", typeArgInt}},
 	Varlen: func(comp *compiler, t *ast.Type, args []*ast.Type) bool {
-		if len(args) >= 1 {
-			return false
-		}
-		return true
+		return len(args) == 0
 	},
 	Gen: func(comp *compiler, t *ast.Type, args []*ast.Type, base prog.IntTypeCommon) prog.Type {
 		base.TypeSize = 0
@@ -448,13 +445,17 @@ var typeBuffer = &typeDesc{
 	},
 }
 
+const (
+	stringnoz = "stringnoz"
+)
+
 var typeString = &typeDesc{
-	Names:        []string{"string", "stringnoz"},
+	Names:        []string{"string", stringnoz},
 	CanBeTypedef: true,
 	OptArgs:      2,
 	Args:         []namedArg{{"literal or flags", typeArgStringFlags}, {"size", typeArgInt}},
 	Check: func(comp *compiler, t *ast.Type, args []*ast.Type, base prog.IntTypeCommon) {
-		if t.Ident == "stringnoz" && len(args) > 1 {
+		if t.Ident == stringnoz && len(args) > 1 {
 			comp.error(args[0].Pos, "fixed-size string can't be non-zero-terminated")
 		}
 	},
@@ -491,7 +492,7 @@ var typeString = &typeDesc{
 			Kind:       prog.BufferString,
 			SubKind:    subkind,
 			Values:     vals,
-			NoZ:        t.Ident == "stringnoz",
+			NoZ:        t.Ident == stringnoz,
 		}
 	},
 }
@@ -505,7 +506,7 @@ func (comp *compiler) genStrings(t *ast.Type, args []*ast.Type) []string {
 			vals = genStrArray(comp.strFlags[args[0].Ident].Values)
 		}
 	}
-	if t.Ident == "stringnoz" {
+	if t.Ident == stringnoz {
 		return vals
 	}
 	var size uint64
@@ -645,12 +646,11 @@ func init() {
 				FldName:    base.FldName,
 				StructDesc: desc,
 			}
-		} else {
-			return &prog.StructType{
-				Key:        key,
-				FldName:    base.FldName,
-				StructDesc: desc,
-			}
+		}
+		return &prog.StructType{
+			Key:        key,
+			FldName:    base.FldName,
+			StructDesc: desc,
 		}
 	}
 }
diff --git a/pkg/config/config.go b/pkg/config/config.go
index b80e03b3f..f4863916d 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -110,7 +110,7 @@ func checkUnknownFieldsStruct(val interface{}, prefix string, typ reflect.Type)
 	}
 	inner, err := json.Marshal(val)
 	if err != nil {
-		return fmt.Errorf("failed to marshal inner struct '%v%v':", prefix, err)
+		return fmt.Errorf("failed to marshal inner struct %q: %v", prefix, err)
 	}
 	return checkUnknownFieldsRec(inner, prefix, typ)
 }
diff --git a/pkg/cover/cover.go b/pkg/cover/cover.go
index 367f68d4d..43b243b4b 100644
--- a/pkg/cover/cover.go
+++ b/pkg/cover/cover.go
@@ -6,14 +6,14 @@ package cover
 
 type Cover map[uint32]struct{}
 
-func (covp *Cover) Merge(raw []uint32) {
-	cov := *covp
-	if cov == nil {
-		cov = make(Cover)
-		*covp = cov
+func (cov *Cover) Merge(raw []uint32) {
+	c := *cov
+	if c == nil {
+		c = make(Cover)
+		*cov = c
 	}
 	for _, pc := range raw {
-		cov[pc] = struct{}{}
+		c[pc] = struct{}{}
 	}
 }
 
diff --git a/pkg/csource/build.go b/pkg/csource/build.go
index 69f5adfcb..b027b337f 100644
--- a/pkg/csource/build.go
+++ b/pkg/csource/build.go
@@ -27,7 +27,7 @@ func Build(target *prog.Target, lang, src string) (string, error) {
 	sysTarget := targets.List[target.OS][target.Arch]
 	compiler := sysTarget.CCompilerPrefix + "gcc"
 	if _, err := exec.LookPath(compiler); err != nil {
-		return "", NoCompilerErr
+		return "", ErrNoCompiler
 	}
 	flags := []string{
 		"-x", lang, "-Wall", "-Werror", "-O1", "-g", "-o", bin.Name(),
@@ -46,13 +46,13 @@ func Build(target *prog.Target, lang, src string) (string, error) {
 	if err != nil {
 		os.Remove(bin.Name())
 		data, _ := ioutil.ReadFile(src)
-		return "", fmt.Errorf("failed to build program:\n%s\n%s\ncompiler invocation: %v %v\n",
+		return "", fmt.Errorf("failed to build program:\n%s\n%s\ncompiler invocation: %v %v",
 			data, out, compiler, flags)
 	}
 	return bin.Name(), nil
 }
 
-var NoCompilerErr = errors.New("no target compiler")
+var ErrNoCompiler = errors.New("no target compiler")
 
 // Format reformats C source using clang-format.
 func Format(src []byte) ([]byte, error) {
diff --git a/pkg/csource/common.go b/pkg/csource/common.go
index dd13e53bf..f77df3459 100644
--- a/pkg/csource/common.go
+++ b/pkg/csource/common.go
@@ -33,7 +33,7 @@ func createCommonHeader(p *prog.Prog, opts Options) ([]byte, error) {
 	cmd.Stderr = stderr
 	cmd.Stdout = stdout
 	if err := cmd.Run(); len(stdout.Bytes()) == 0 {
-		return nil, fmt.Errorf("cpp failed: %v\n%v\n%v\n", err, stdout.String(), stderr.String())
+		return nil, fmt.Errorf("cpp failed: %v\n%v\n%v", err, stdout.String(), stderr.String())
 	}
 
 	src, err := removeSystemDefines(stdout.Bytes(), defines)
diff --git a/pkg/csource/csource_test.go b/pkg/csource/csource_test.go
index 4aaaa3451..fa5eee58a 100644
--- a/pkg/csource/csource_test.go
+++ b/pkg/csource/csource_test.go
@@ -114,7 +114,7 @@ func testOne(t *testing.T, p *prog.Prog, opts Options) {
 	}
 	defer os.Remove(srcf)
 	bin, err := Build(p.Target, "c", srcf)
-	if err == NoCompilerErr {
+	if err == ErrNoCompiler {
 		t.Skip(err)
 	}
 	if err != nil {
diff --git a/pkg/email/parser_test.go b/pkg/email/parser_test.go
index 69e237806..a99ab17f6 100644
--- a/pkg/email/parser_test.go
+++ b/pkg/email/parser_test.go
@@ -91,6 +91,9 @@ func TestAddAddrContextEmptyName(t *testing.T) {
 		t.Fatalf("want: %q, got %q", want, email1)
 	}
 	email2, context1, err := RemoveAddrContext(email1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	if email != email2 {
 		t.Fatalf("want: %q, got %q", email, email2)
 	}
diff --git a/pkg/email/patch_test.go b/pkg/email/patch_test.go
index b10211ff0..c8cae4621 100644
--- a/pkg/email/patch_test.go
+++ b/pkg/email/patch_test.go
@@ -157,7 +157,7 @@ The handling of the might_cancel queueing is not properly protected, so
 parallel operations on the file descriptor can race with each other and
 lead to list corruptions or use after free.
 
-Protect the context for these operations with a seperate lock.
+Protect the context for these operations with a separate lock.
 
 Reported-by: Foo Bar <foo@bar.com>
 Signed-off-by: Foo Bar <foo@bar.com>
diff --git a/pkg/gcs/gcs.go b/pkg/gcs/gcs.go
index 97883256a..7e832de41 100644
--- a/pkg/gcs/gcs.go
+++ b/pkg/gcs/gcs.go
@@ -92,10 +92,8 @@ func (client *Client) UploadFile(localFile, gcsFile string) error {
 	}
 	defer w.Close()
 
-	if _, err := io.Copy(w, local); err != nil {
-		return err
-	}
-	return nil
+	_, err = io.Copy(w, local)
+	return err
 }
 
 func (client *Client) FileWriter(gcsFile string) (io.WriteCloser, error) {
diff --git a/pkg/git/git.go b/pkg/git/git.go
index 2455a1ea2..372309634 100644
--- a/pkg/git/git.go
+++ b/pkg/git/git.go
@@ -322,7 +322,7 @@ func CheckRepoAddress(repo string) bool {
 	return gitRepoRe.MatchString(repo)
 }
 
-var gitRepoRe = regexp.MustCompile("^(git|ssh|http|https|ftp|ftps)://[a-zA-Z0-9-_]+(\\.[a-zA-Z0-9-_]+)+(:[0-9]+)?/[a-zA-Z0-9-_./]+\\.git(/)?$")
+var gitRepoRe = regexp.MustCompile(`^(git|ssh|http|https|ftp|ftps)://[a-zA-Z0-9-_]+(\.[a-zA-Z0-9-_]+)+(:[0-9]+)?/[a-zA-Z0-9-_./]+\.git(/)?$`)
 
 // CheckBranch does a best-effort approximate check of a git branch name.
 func CheckBranch(branch string) bool {
diff --git a/pkg/host/host_linux.go b/pkg/host/host_linux.go
index 57ce3e79e..0d1cd9afc 100644
--- a/pkg/host/host_linux.go
+++ b/pkg/host/host_linux.go
@@ -55,7 +55,7 @@ func isSupported(sandbox string, kallsyms []byte, c *prog.Syscall) bool {
 	if newname := kallsymsMap[name]; newname != "" {
 		name = newname
 	}
-	return bytes.Index(kallsyms, []byte(" T sys_"+name+"\n")) != -1
+	return bytes.Contains(kallsyms, []byte(" T sys_"+name+"\n"))
 }
 
 // Some syscall names diverge in __NR_* consts and kallsyms.
diff --git a/pkg/ifuzz/encode.go b/pkg/ifuzz/encode.go
index 799def63a..0b3732aa7 100644
--- a/pkg/ifuzz/encode.go
+++ b/pkg/ifuzz/encode.go
@@ -76,7 +76,7 @@ func (insn *Insn) Encode(cfg *Config, r *rand.Rand) []byte {
 			rex = byte(0x40 | r.Intn(16))
 			if insn.Rexw == 1 {
 				rex |= 1 << 3
-			} else if insn.Rexw == 1 {
+			} else {
 				rex &^= 1 << 3
 			}
 			rexR = rex&0x4 != 0
diff --git a/pkg/ifuzz/gen/gen.go b/pkg/ifuzz/gen/gen.go
index 47822780c..1ad725e12 100644
--- a/pkg/ifuzz/gen/gen.go
+++ b/pkg/ifuzz/gen/gen.go
@@ -504,7 +504,7 @@ func parseModrm(v string) (int8, error) {
 		}
 		vv *= 2
 		if v[i] == '1' {
-			vv += 1
+			vv++
 		}
 	}
 	return vv, nil
diff --git a/pkg/ipc/ipc.go b/pkg/ipc/ipc.go
index fbce12efa..104be74d2 100644
--- a/pkg/ipc/ipc.go
+++ b/pkg/ipc/ipc.go
@@ -528,6 +528,8 @@ type executeReply struct {
 	status uint32
 }
 
+// TODO(dvyukov): we currently parse this manually, should cast output to this struct instead.
+/*
 type callReply struct {
 	callIndex     uint32
 	callNum       uint32
@@ -539,6 +541,7 @@ type callReply struct {
 	compsSize     uint32
 	// signal/cover/comps follow
 }
+*/
 
 func makeCommand(pid int, bin []string, config *Config, inFile *os.File, outFile *os.File) (*command, error) {
 	dir, err := ioutil.TempDir("./", "syzkaller-testdir")
@@ -782,7 +785,7 @@ func (c *command) exec(opts *ExecOpts, progData []byte) (output []byte, failed,
 			hang <- false
 		}
 	}()
-	exitStatus := 0
+	var exitStatus int
 	if c.config.Flags&FlagUseForkServer == 0 {
 		restart = true
 		c.cmd.Wait()
@@ -849,9 +852,3 @@ func (c *command) exec(opts *ExecOpts, progData []byte) (output []byte, failed,
 	}
 	return
 }
-
-func serializeUint64(buf []byte, v uint64) {
-	for i := 0; i < 8; i++ {
-		buf[i] = byte(v >> (8 * uint(i)))
-	}
-}
diff --git a/pkg/ipc/ipc_test.go b/pkg/ipc/ipc_test.go
index 03de4ebf1..88b124a6f 100644
--- a/pkg/ipc/ipc_test.go
+++ b/pkg/ipc/ipc_test.go
@@ -13,7 +13,6 @@ import (
 	"time"
 
 	"github.com/google/syzkaller/pkg/csource"
-	"github.com/google/syzkaller/pkg/osutil"
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys"
 )
@@ -25,15 +24,6 @@ func buildExecutor(t *testing.T, target *prog.Target) string {
 	return buildProgram(t, target, filepath.FromSlash(src))
 }
 
-func buildSource(t *testing.T, target *prog.Target, src []byte) string {
-	tmp, err := osutil.WriteTempFile(src)
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	defer os.Remove(tmp)
-	return buildProgram(t, target, tmp)
-}
-
 func buildProgram(t *testing.T, target *prog.Target, src string) string {
 	bin, err := csource.Build(target, "c++", src)
 	if err != nil {
diff --git a/pkg/kernel/kernel.go b/pkg/kernel/kernel.go
index 2c35bcc40..f1bdcdc83 100644
--- a/pkg/kernel/kernel.go
+++ b/pkg/kernel/kernel.go
@@ -48,10 +48,8 @@ func Build(dir, compiler, config string) error {
 	}
 	cmd.Dir = dir
 	// Build of a large kernel can take a while on a 1 CPU VM.
-	if _, err := osutil.Run(3*time.Hour, cmd); err != nil {
-		return err
-	}
-	return nil
+	_, err := osutil.Run(3*time.Hour, cmd)
+	return err
 }
 
 // CreateImage creates a disk image that is suitable for syzkaller.
diff --git a/pkg/kernel/kernel_test.go b/pkg/kernel/kernel_test.go
index 750fa50eb..18d7936d0 100644
--- a/pkg/kernel/kernel_test.go
+++ b/pkg/kernel/kernel_test.go
@@ -21,7 +21,7 @@ func TestCompilerIdentity(t *testing.T) {
 	if len(id) == 0 {
 		t.Fatalf("identity is empty")
 	}
-	if strings.Index(id, "\n") != -1 {
+	if strings.Contains(id, "\n") {
 		t.Fatalf("identity contains a new line")
 	}
 	// We don't know what's the right answer,
diff --git a/pkg/osutil/fileutil_test.go b/pkg/osutil/fileutil_test.go
index 4db5c0d83..62e07bc8f 100644
--- a/pkg/osutil/fileutil_test.go
+++ b/pkg/osutil/fileutil_test.go
@@ -4,6 +4,7 @@
 package osutil
 
 import (
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -36,29 +37,31 @@ func TestProcessTempDir(t *testing.T) {
 				}
 			}
 			// Now request a bunch of instances concurrently.
-			done := make(chan bool)
+			done := make(chan error)
 			allDirs := make(map[string]bool)
 			var mu sync.Mutex
 			for p := 0; p < P; p++ {
 				go func() {
-					defer func() {
-						done <- true
-					}()
 					dir, err := ProcessTempDir(tmp)
 					if err != nil {
-						t.Fatalf("failed to create process temp dir")
+						done <- fmt.Errorf("failed to create temp dir: %v", err)
+						return
 					}
 					mu.Lock()
 					present := allDirs[dir]
 					allDirs[dir] = true
 					mu.Unlock()
 					if present {
-						t.Fatalf("duplicate dir %v", dir)
+						done <- fmt.Errorf("duplicate dir %v", dir)
+						return
 					}
+					done <- nil
 				}()
 			}
 			for p := 0; p < P; p++ {
-				<-done
+				if err := <-done; err != nil {
+					t.Error(err)
+				}
 			}
 		}()
 	}
diff --git a/pkg/report/linux.go b/pkg/report/linux.go
index 4fbf5ddc3..703b41fb4 100644
--- a/pkg/report/linux.go
+++ b/pkg/report/linux.go
@@ -159,7 +159,7 @@ func (ctx *linux) Parse(output []byte) *Report {
 			}
 		}
 		if ctx.consoleOutputRe.Match(line) &&
-			(!ctx.questionableRe.Match(line) || bytes.Index(line, ctx.eoi) != -1) {
+			(!ctx.questionableRe.Match(line) || bytes.Contains(line, ctx.eoi)) {
 			lineStart := bytes.Index(line, []byte("] ")) + pos + 2
 			lineEnd := next
 			if lineEnd != 0 && output[lineEnd-1] == '\r' {
@@ -352,12 +352,8 @@ func symbolizeLine(symbFunc func(bin string, pc uint64) ([]symbolizer.Frame, err
 	var symbolized []byte
 	for _, frame := range frames {
 		file := frame.File
-		if strings.HasPrefix(file, strip) {
-			file = file[len(strip):]
-		}
-		if strings.HasPrefix(file, "./") {
-			file = file[2:]
-		}
+		file = strings.TrimPrefix(file, strip)
+		file = strings.TrimPrefix(file, "./")
 		info := fmt.Sprintf(" %v:%v", file, frame.Line)
 		modified := append([]byte{}, line...)
 		modified = replace(modified, match[7], match[7], []byte(info))
diff --git a/pkg/report/report.go b/pkg/report/report.go
index 89d780b4b..82e68edc4 100644
--- a/pkg/report/report.go
+++ b/pkg/report/report.go
@@ -229,20 +229,6 @@ type stackParams struct {
 	skipPatterns []string
 }
 
-func startReportPrefix(output []byte, prefixes []string) []byte {
-	if len(prefixes) == 0 {
-		return output
-	}
-	for _, prefix := range prefixes {
-		re := regexp.MustCompile(prefix + ".*\\n")
-		match := re.FindSubmatchIndex(output)
-		if match != nil {
-			return output[match[0]:]
-		}
-	}
-	return nil
-}
-
 func extractStackFrame(params *stackParams, stack *stackFmt, output []byte) string {
 	skip := append([]string{}, params.skipPatterns...)
 	skip = append(skip, stack.skip...)
diff --git a/pkg/repro/repro.go b/pkg/repro/repro.go
index fc79f5a8a..ba136743c 100644
--- a/pkg/repro/repro.go
+++ b/pkg/repro/repro.go
@@ -382,7 +382,7 @@ func (ctx *context) extractProgBisect(entries []*prog.LogEntry, baseDuration tim
 			Duration: dur,
 			Opts:     opts,
 		}
-		ctx.reproLog(3, "bisect: concatenation succeded")
+		ctx.reproLog(3, "bisect: concatenation succeeded")
 		return res, nil
 	}
 
@@ -458,7 +458,7 @@ func (ctx *context) simplifyProg(res *Result) (*Result, error) {
 			}
 			if crashed {
 				res.Opts = opts
-				// Simplification successfull, try extracting C repro.
+				// Simplification successful, try extracting C repro.
 				res, err := ctx.extractC(res)
 				if err != nil {
 					return nil, err
@@ -681,7 +681,7 @@ again:
 		ctx.reproLog(3, "bisect: guilty chunks split: %v, <%v>, %v", logGuilty(guilty1), len(chunk), logGuilty(guilty2))
 
 		chunk1 := chunk[0 : len(chunk)/2]
-		chunk2 := chunk[len(chunk)/2 : len(chunk)]
+		chunk2 := chunk[len(chunk)/2:]
 		ctx.reproLog(3, "bisect: chunk split: <%v> => <%v>, <%v>", len(chunk), len(chunk1), len(chunk2))
 
 		ctx.reproLog(3, "bisect: triggering crash without chunk #1")
diff --git a/pkg/repro/repro_test.go b/pkg/repro/repro_test.go
index e56e176aa..2cb646c0c 100644
--- a/pkg/repro/repro_test.go
+++ b/pkg/repro/repro_test.go
@@ -35,7 +35,7 @@ func TestBisect(t *testing.T) {
 			var prog prog.LogEntry
 			if rd.Intn(30) == 0 {
 				prog.Proc = 42
-				numGuilty += 1
+				numGuilty++
 			}
 			progs = append(progs, &prog)
 		}
@@ -43,13 +43,13 @@ func TestBisect(t *testing.T) {
 			var prog prog.LogEntry
 			prog.Proc = 42
 			progs = append(progs, &prog)
-			numGuilty += 1
+			numGuilty++
 		}
 		progs, _ = ctx.bisectProgs(progs, func(p []*prog.LogEntry) (bool, error) {
 			guilty := 0
 			for _, prog := range p {
 				if prog.Proc == 42 {
-					guilty += 1
+					guilty++
 				}
 			}
 			return guilty == numGuilty, nil
diff --git a/pkg/rpctype/rpc.go b/pkg/rpctype/rpc.go
index 8400b0e95..18d2a04f5 100644
--- a/pkg/rpctype/rpc.go
+++ b/pkg/rpctype/rpc.go
@@ -12,26 +12,26 @@ import (
 	. "github.com/google/syzkaller/pkg/log"
 )
 
-type RpcServer struct {
+type RPCServer struct {
 	ln net.Listener
 	s  *rpc.Server
 }
 
-func NewRpcServer(addr string, receiver interface{}) (*RpcServer, error) {
+func NewRPCServer(addr string, receiver interface{}) (*RPCServer, error) {
 	ln, err := net.Listen("tcp", addr)
 	if err != nil {
 		return nil, fmt.Errorf("failed to listen on %v: %v", addr, err)
 	}
 	s := rpc.NewServer()
 	s.Register(receiver)
-	serv := &RpcServer{
+	serv := &RPCServer{
 		ln: ln,
 		s:  s,
 	}
 	return serv, nil
 }
 
-func (serv *RpcServer) Serve() {
+func (serv *RPCServer) Serve() {
 	for {
 		conn, err := serv.ln.Accept()
 		if err != nil {
@@ -44,42 +44,42 @@ func (serv *RpcServer) Serve() {
 	}
 }
 
-func (serv *RpcServer) Addr() net.Addr {
+func (serv *RPCServer) Addr() net.Addr {
 	return serv.ln.Addr()
 }
 
-type RpcClient struct {
+type RPCClient struct {
 	conn net.Conn
 	c    *rpc.Client
 }
 
-func NewRpcClient(addr string) (*RpcClient, error) {
+func NewRPCClient(addr string) (*RPCClient, error) {
 	conn, err := net.DialTimeout("tcp", addr, 60*time.Second)
 	if err != nil {
 		return nil, err
 	}
 	conn.(*net.TCPConn).SetKeepAlive(true)
 	conn.(*net.TCPConn).SetKeepAlivePeriod(time.Minute)
-	cli := &RpcClient{
+	cli := &RPCClient{
 		conn: conn,
 		c:    rpc.NewClient(conn),
 	}
 	return cli, nil
 }
 
-func (cli *RpcClient) Call(method string, args, reply interface{}) error {
+func (cli *RPCClient) Call(method string, args, reply interface{}) error {
 	cli.conn.SetDeadline(time.Now().Add(5 * 60 * time.Second))
 	err := cli.c.Call(method, args, reply)
 	cli.conn.SetDeadline(time.Time{})
 	return err
 }
 
-func (cli *RpcClient) Close() {
+func (cli *RPCClient) Close() {
 	cli.c.Close()
 }
 
-func RpcCall(addr, method string, args, reply interface{}) error {
-	c, err := NewRpcClient(addr)
+func RPCCall(addr, method string, args, reply interface{}) error {
+	c, err := NewRPCClient(addr)
 	if err != nil {
 		return err
 	}
diff --git a/pkg/rpctype/rpctype.go b/pkg/rpctype/rpctype.go
index d7fee32da..078d44a7a 100644
--- a/pkg/rpctype/rpctype.go
+++ b/pkg/rpctype/rpctype.go
@@ -9,14 +9,14 @@ import (
 	"github.com/google/syzkaller/pkg/signal"
 )
 
-type RpcInput struct {
+type RPCInput struct {
 	Call   string
 	Prog   []byte
 	Signal signal.Serial
 	Cover  []uint32
 }
 
-type RpcCandidate struct {
+type RPCCandidate struct {
 	Prog      []byte
 	Minimized bool
 	Smashed   bool
@@ -28,9 +28,9 @@ type ConnectArgs struct {
 
 type ConnectRes struct {
 	Prios        [][]float32
-	Inputs       []RpcInput
+	Inputs       []RPCInput
 	MaxSignal    signal.Serial
-	Candidates   []RpcCandidate
+	Candidates   []RPCCandidate
 	EnabledCalls string
 	NeedCheck    bool
 }
@@ -52,7 +52,7 @@ type CheckArgs struct {
 
 type NewInputArgs struct {
 	Name string
-	RpcInput
+	RPCInput
 }
 
 type PollArgs struct {
@@ -63,8 +63,8 @@ type PollArgs struct {
 }
 
 type PollRes struct {
-	Candidates []RpcCandidate
-	NewInputs  []RpcInput
+	Candidates []RPCCandidate
+	NewInputs  []RPCInput
 	MaxSignal  signal.Serial
 }
 
diff --git a/pkg/serializer/serializer.go b/pkg/serializer/serializer.go
index af2708fb3..3054bd3a4 100644
--- a/pkg/serializer/serializer.go
+++ b/pkg/serializer/serializer.go
@@ -129,10 +129,6 @@ func (w *writer) typ(t reflect.Type) {
 	}
 }
 
-func (w *writer) write(v []byte) {
-	w.w.Write(v)
-}
-
 func (w *writer) string(v string) {
 	io.WriteString(w.w, v)
 }
diff --git a/pkg/serializer/serializer_test.go b/pkg/serializer/serializer_test.go
index 17cc9550b..7757b345a 100644
--- a/pkg/serializer/serializer_test.go
+++ b/pkg/serializer/serializer_test.go
@@ -39,6 +39,6 @@ type Y struct {
 type T int
 
 const (
-	T0 T = iota
+	_ T = iota
 	T1
 )
diff --git a/pkg/signal/signal.go b/pkg/signal/signal.go
index 366407d04..e82255537 100644
--- a/pkg/signal/signal.go
+++ b/pkg/signal/signal.go
@@ -114,28 +114,28 @@ func (s Signal) Intersection(s1 Signal) Signal {
 	return res
 }
 
-func (sp *Signal) Merge(s1 Signal) {
+func (s *Signal) Merge(s1 Signal) {
 	if s1.Empty() {
 		return
 	}
-	s := *sp
-	if s == nil {
-		s = make(Signal, len(s1))
-		*sp = s
+	s0 := *s
+	if s0 == nil {
+		s0 = make(Signal, len(s1))
+		*s = s0
 	}
 	for e, p1 := range s1 {
-		if p, ok := s[e]; !ok || p < p1 {
-			s[e] = p1
+		if p, ok := s0[e]; !ok || p < p1 {
+			s0[e] = p1
 		}
 	}
 }
 
-type SignalContext struct {
+type Context struct {
 	Signal  Signal
 	Context interface{}
 }
 
-func Minimize(corpus []SignalContext) []interface{} {
+func Minimize(corpus []Context) []interface{} {
 	sort.Slice(corpus, func(i, j int) bool {
 		return corpus[i].Signal.Len() > corpus[j].Signal.Len()
 	})
diff --git a/pkg/symbolizer/nm.go b/pkg/symbolizer/nm.go
index 72e5db792..01d23ab94 100644
--- a/pkg/symbolizer/nm.go
+++ b/pkg/symbolizer/nm.go
@@ -34,7 +34,7 @@ func ReadSymbols(bin string) (map[string][]Symbol, error) {
 	for s.Scan() {
 		// A line looks as: "ffffffff8104db90 0000000000000059 t snb_uncore_msr_enable_box"
 		ln := s.Bytes()
-		if bytes.Index(ln, text[0]) == -1 && bytes.Index(ln, text[1]) == -1 {
+		if !bytes.Contains(ln, text[0]) && !bytes.Contains(ln, text[1]) {
 			continue
 		}
 		sp1 := bytes.IndexByte(ln, ' ')
diff --git a/pkg/symbolizer/symbolizer_test.go b/pkg/symbolizer/symbolizer_test.go
index bb902b290..30a8413f2 100644
--- a/pkg/symbolizer/symbolizer_test.go
+++ b/pkg/symbolizer/symbolizer_test.go
@@ -5,6 +5,7 @@ package symbolizer
 
 import (
 	"bufio"
+	"fmt"
 	"os"
 	"reflect"
 	"strconv"
@@ -114,7 +115,7 @@ func TestParse(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer outputr.Close()
-	done := make(chan bool)
+	done := make(chan error)
 	go func() {
 		s := bufio.NewScanner(inputr)
 	loop:
@@ -122,7 +123,8 @@ func TestParse(t *testing.T) {
 			pc, err := strconv.ParseUint(s.Text(), 0, 64)
 			if err != nil {
 				outputw.Close()
-				t.Fatalf("got unexpected pc: %v", s.Text())
+				done <- fmt.Errorf("got unexpected pc: %v", s.Text())
+				return
 			}
 			for _, addr := range addresses {
 				if pc == addr.pc {
@@ -131,7 +133,8 @@ func TestParse(t *testing.T) {
 				}
 			}
 			outputw.Close()
-			t.Fatalf("got unexpected pc: 0x%x", pc)
+			done <- fmt.Errorf("got unexpected pc: 0x%x", pc)
+			return
 		}
 		outputw.Write([]byte("DONE\n"))
 		outputw.Close()
@@ -139,7 +142,9 @@ func TestParse(t *testing.T) {
 	}()
 	defer func() {
 		inputw.Close()
-		<-done
+		if err := <-done; err != nil {
+			t.Fatal(err)
+		}
 	}()
 
 	// First, symbolize all PCs one-by-one.