various: Fix lint errors on CI

Author: Ethan Graham

pkg/fuzzer/fuzzer.go

@@ -74,8 +74,8 @@ func NewFuzzer(ctx context.Context, cfg *Config, rnd *rand.Rand,
 	return f
 }
 
-func (f *Fuzzer) RecommendedCalls() int {
-	if f.modeKFuzzTest {
+func (fuzzer *Fuzzer) RecommendedCalls() int {
+	if fuzzer.modeKFuzzTest {
 		return prog.RecommendedCallsKFuzzTest
 	}
 	return prog.RecommendedCalls

pkg/kcov/cdefs.go

@@ -1,43 +1,45 @@
+// Copyright 2025 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 kcov
 
+// This file defines values required for KCOV ioctl calls. More information on
+// the values and their semantics can be found in the kernel documentation under
+// /Documentation/dev-tools/kcov.rst, or at docs.kernel.org/dev-tools/kcov.html.
+
 import "unsafe"
 
 const (
 	sizeofUintPtr = int(unsafe.Sizeof((*int)(nil)))
 
-	_IOC_NRBITS   = 8
-	_IOC_TYPEBITS = 8
-	_IOC_SIZEBITS = 14
-	_IOC_DIRBITS  = 2
-
-	_IOC_NRSHIFT   = 0
-	_IOC_TYPESHIFT = _IOC_NRSHIFT + _IOC_NRBITS
-	_IOC_SIZESHIFT = _IOC_TYPESHIFT + _IOC_TYPEBITS
-	_IOC_DIRSHIFT  = _IOC_SIZESHIFT + _IOC_SIZEBITS
-
-	_IOC_NONE  = 0
-	_IOC_WRITE = 1
-	_IOC_READ  = 2
-)
-
-// KCOV ioctl commands for Linux.
-const (
-	// KCOV_INIT_TRACE initializes kcov tracing.
-	// #define KCOV_INIT_TRACE _IOR('c', 1, unsigned long)
-	// On amd64, unsigned long is 8 bytes.
-	KCOV_INIT_TRACE uintptr = (_IOC_READ << _IOC_DIRSHIFT) |
-		(uintptr(unsafe.Sizeof(uint64(0))) << _IOC_SIZESHIFT) | ('c' << _IOC_TYPESHIFT) | (1 << _IOC_NRSHIFT) // 0x80086301.
-
-	// KCOV_ENABLE enables kcov for the current thread.
-	// #define KCOV_ENABLE _IO('c', 100)
-	KCOV_ENABLE uintptr = (_IOC_NONE << _IOC_DIRSHIFT) |
-		(0 << _IOC_SIZESHIFT) | ('c' << _IOC_TYPESHIFT) | (100 << _IOC_NRSHIFT) // 0x6364.
-
-	// KCOV_DISABLE disables kcov for the current thread.
-	// #define KCOV_DISABLE _IO('c', 101)
-	KCOV_DISABLE uintptr = (_IOC_NONE << _IOC_DIRSHIFT) |
-		(0 << _IOC_SIZESHIFT) | ('c' << _IOC_TYPESHIFT) | (101 << _IOC_NRSHIFT) // 0x6365.
-
-	KCOV_TRACE_PC  = 0
-	KCOV_TRACE_CMP = 1
+	iocNrBits   = 8
+	iocTypeBits = 8
+	iocSizeBits = 14
+	iocDirBits  = 2
+
+	iocNrShift   = 0
+	iocTypeshift = iocNrShift + iocNrBits
+	iocSizeShift = iocTypeshift + iocTypeBits
+	iocDirShift  = iocSizeShift + iocSizeBits
+
+	iocNone  = 0
+	iocWrite = 1
+	iocRead  = 2
+
+	// kcovInitTrace initializes KCOV tracing.
+	// #define kcovInitTrace _IOR('c', 1, unsigned long)
+	kcovInitTrace uintptr = (iocRead << iocDirShift) |
+		(unsafe.Sizeof(uint64(0)) << iocSizeShift) | ('c' << iocTypeshift) | (1 << iocNrShift) // 0x80086301.
+
+	// kcovEnable enables kcov for the current thread.
+	// #define kcovEnable _IO('c', 100)
+	kcovEnable uintptr = (iocNone << iocDirShift) |
+		(0 << iocSizeShift) | ('c' << iocTypeshift) | (100 << iocNrShift) // 0x6364.
+
+	// kcovDisable disables kcov for the current thread.
+	// #define kcovDisable _IO('c', 101)
+	kcovDisable uintptr = (iocNone << iocDirShift) |
+		(0 << iocSizeShift) | ('c' << iocTypeshift) | (101 << iocNrShift) // 0x6365.
+
+	kcovTracePC  = 0
+	kcovTraceCMP = 1
 )

pkg/kcov/kcov.go

@@ -1,4 +1,8 @@
-// Package kcov provides Go native code for reading kernel coverage.
+// Copyright 2025 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 kcov provides Go native code for collecting kernel coverage (KCOV)
+// information.
 package kcov
 
 import (
@@ -46,50 +50,63 @@ func (st *KCOVState) Trace(f func() error) KCOVTraceResult {
 
 // EnableTracingForCurrentGoroutine prepares the current goroutine for kcov tracing.
 // It must be paired with a call to DisableTracing.
-func EnableTracingForCurrentGoroutine() (*KCOVState, error) {
+func EnableTracingForCurrentGoroutine() (st *KCOVState, err error) {
+	st = &KCOVState{}
+	defer func() {
+		if err != nil {
+			// The original error is more important, so we ignore any potential
+			// errors that result from cleaning up.
+			_ = st.DisableTracing()
+		}
+	}()
+
 	// KCOV is per-thread, so lock goroutine to its current OS thread.
 	runtime.LockOSThread()
 
 	file, err := os.OpenFile(kcovPath, os.O_RDWR, 0)
 	if err != nil {
 		return nil, err
 	}
-	st := KCOVState{
-		file: file,
-	}
-	fd := file.Fd()
+	st.file = file
 
 	// Setup trace mode and size.
-	if err := unix.IoctlSetInt(int(fd), uint(KCOV_INIT_TRACE), kcovCoverSize); err != nil {
-		st.DisableTracing()
+	if err := unix.IoctlSetInt(int(st.file.Fd()), uint(kcovInitTrace), kcovCoverSize); err != nil {
 		return nil, err
 	}
 
 	// Mmap buffer shared between kernel- and user-space. For more information,
 	// see the Linux KCOV documentation: https://docs.kernel.org/dev-tools/kcov.html.
 	st.cover, err = unix.Mmap(
-		int(fd),
+		int(st.file.Fd()),
 		0, // Offset.
 		kcovCoverSize*sizeofUintPtr,
 		unix.PROT_READ|unix.PROT_WRITE,
 		unix.MAP_SHARED,
 	)
 	if err != nil {
-		st.DisableTracing()
 		return nil, err
 	}
 
 	// Enable coverage collection on the current thread.
-	if err := unix.IoctlSetInt(int(fd), uint(KCOV_ENABLE), KCOV_TRACE_PC); err != nil {
-		st.DisableTracing()
+	if err := unix.IoctlSetInt(int(st.file.Fd()), uint(kcovEnable), kcovTracePC); err != nil {
 		return nil, err
 	}
-
-	return &st, nil
+	return st, nil
 }
 
-func (st *KCOVState) DisableTracing() {
+// DisableTracing disables KCOV tracing for the current Go routine. On failure,
+// it returns the first error that occurred during cleanup.
+func (st *KCOVState) DisableTracing() error {
+	var firstErr error
+	if err := unix.IoctlSetInt(int(st.file.Fd()), uint(kcovDisable), kcovTracePC); err != nil {
+		firstErr = err
+	}
+	if err := unix.Munmap(st.cover); err != nil && firstErr == nil {
+		firstErr = err
+	}
+	if err := st.file.Close(); err != nil && firstErr == nil {
+		firstErr = err
+	}
 	runtime.UnlockOSThread()
-	st.file.Close()
-	unix.Munmap(st.cover)
+	return firstErr
 }

pkg/kfuzztest-manager/manager.go

@@ -1,6 +1,6 @@
 // Copyright 2025 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 kfuzztest_manager
+package kfuzztestmanager
 
 import (
 	"context"

pkg/kfuzztest/builder.go

@@ -71,7 +71,7 @@ func (b *Builder) EmitSyzlangDescription() (string, error) {
 	// Format the output syzlang descriptions for consistency.
 	var astError error
 	eh := func(pos ast.Pos, msg string) {
-		astError = fmt.Errorf("Failure: %v: %v\n", pos, msg)
+		astError = fmt.Errorf("ast failure: %v: %v", pos, msg)
 	}
 	descAst := ast.Parse([]byte(descBuilder.String()), "", eh)
 	if astError != nil {

pkg/kfuzztest/extractor.go

@@ -12,7 +12,7 @@ import (
 // Extractor's job is to extract all information relevant to KFuzzTest from a
 // VMlinux binary.
 type Extractor struct {
-	// Path to the `vmlinux` being parsed
+	// Path to the `vmlinux` being parsed.
 	vmlinuxPath string
 	elfFile     *elf.File
 	dwarfData   *dwarf.Data
@@ -112,7 +112,7 @@ func (e *Extractor) elfSection(addr uint64) *elf.Section {
 func (e *Extractor) readElfString(offset uint64) (string, error) {
 	strSection := e.elfSection(offset)
 	if strSection == nil {
-		return "", fmt.Errorf("unable to find section for offset 0x%X\n", offset)
+		return "", fmt.Errorf("unable to find section for offset 0x%X", offset)
 	}
 
 	// 128 bytes is longer than we expect to see in KFuzzTest metadata.
@@ -167,10 +167,10 @@ func (e *Extractor) getSymbol(symbolName string) (elf.Symbol, error) {
 }
 
 func (e *Extractor) extractFuncs() ([]SyzFunc, error) {
-	var rawFuncs []*kftfTestCase
+	var rawFuncs []*kfuzztestTarget
 	var err error
 
-	rawFuncs, err = parseKftfObjects[*kftfTestCase](e)
+	rawFuncs, err = parseKftfObjects[*kfuzztestTarget](e)
 	if err != nil {
 		return nil, err
 	}
@@ -195,10 +195,10 @@ func (e *Extractor) extractFuncs() ([]SyzFunc, error) {
 }
 
 func (e *Extractor) extractDomainConstraints() ([]SyzConstraint, error) {
-	var rawConstraints []*kftfConstraint
+	var rawConstraints []*kfuzztestConstraint
 	var err error
 
-	rawConstraints, err = parseKftfObjects[*kftfConstraint](e)
+	rawConstraints, err = parseKftfObjects[*kfuzztestConstraint](e)
 	if err != nil {
 		return nil, err
 	}
@@ -227,10 +227,10 @@ func (e *Extractor) extractDomainConstraints() ([]SyzConstraint, error) {
 }
 
 func (e *Extractor) extractAnnotations() ([]SyzAnnotation, error) {
-	var rawAnnotations []*kftfAnnotation
+	var rawAnnotations []*kfuzztestAnnotation
 	var err error
 
-	rawAnnotations, err = parseKftfObjects[*kftfAnnotation](e)
+	rawAnnotations, err = parseKftfObjects[*kfuzztestAnnotation](e)
 	if err != nil {
 		return nil, err
 	}
@@ -400,28 +400,28 @@ func parseKftfObjects[T interface {
 	*P
 	parsableFromBytes
 }, P any](e *Extractor) ([]T, error) {
-	var typeinfo T = new(P)
+	var typeinfo T
 
 	startSymbol, err := e.getSymbol(typeinfo.startSymbol())
 	if err != nil {
 		return nil, err
 	} else if startSymbol.Value == 0 {
-		return nil, fmt.Errorf("Failed to resolve start symbol")
+		return nil, fmt.Errorf("failed to resolve %s", typeinfo.startSymbol())
 	}
 
 	endSymbol, err := e.getSymbol(typeinfo.endSymbol())
 	if err != nil {
 		return nil, err
 	} else if endSymbol.Value == 0 {
-		return nil, fmt.Errorf("Failed to resolve end symbol")
+		return nil, fmt.Errorf("failed to resolve %s", typeinfo.endSymbol())
 	}
 
 	out := make([]T, 0)
 	data := make([]byte, typeinfo.size())
 	for addr := startSymbol.Value; addr < endSymbol.Value; addr += typeinfo.size() {
 		section := e.elfSection(addr)
 		if section == nil {
-			return nil, fmt.Errorf("Failed to locate section for addr=0x%x", addr)
+			return nil, fmt.Errorf("failed to locate section for addr=0x%x", addr)
 		}
 
 		n, err := section.ReadAt(data, int64(addr-section.Addr))
@@ -431,7 +431,7 @@ func parseKftfObjects[T interface {
 			return nil, err
 		}
 
-		var obj T = new(P)
+		var obj T
 		err = obj.fromBytes(e.elfFile, data)
 		if err != nil {
 			return nil, err

pkg/kfuzztest/kfuzztest.go

@@ -129,7 +129,7 @@ func ExtractData(vmlinuxPath string) (KFuzzTestData, error) {
 
 		var astError error
 		eh := func(pos ast.Pos, msg string) {
-			astError = fmt.Errorf("AST error: %v: %v\n", pos, msg)
+			astError = fmt.Errorf("ast error: %v: %v", pos, msg)
 		}
 		descAst := ast.Parse([]byte(desc), "kfuzztest-autogen", eh)
 		if astError != nil {
@@ -144,7 +144,7 @@ func ExtractData(vmlinuxPath string) (KFuzzTestData, error) {
 		target := targets.Get(targets.Linux, targets.AMD64)
 		program := compiler.Compile(descAst, make(map[string]uint64), target, eh)
 		if astError != nil {
-			extractState.err = fmt.Errorf("failed to compile extracted KFuzzTest target: %v", astError)
+			extractState.err = fmt.Errorf("failed to compile extracted KFuzzTest target: %w", astError)
 		}
 
 		kFuzzTestCalls := []*prog.Syscall{}