all: move KernelModule into vminfo package

9 files changed, 65 insertions, 61 deletions

diff --git a/pkg/cover/backend/backend.go b/pkg/cover/backend/backend.go
index 640922a83..a660d02e4 100644
--- a/pkg/cover/backend/backend.go
+++ b/pkg/cover/backend/backend.go
@@ -7,6 +7,7 @@ import (
 	"fmt"
 
 	"github.com/google/syzkaller/pkg/mgrconfig"
+	"github.com/google/syzkaller/pkg/vminfo"
 	"github.com/google/syzkaller/sys/targets"
 )
 
@@ -14,7 +15,7 @@ type Impl struct {
 	Units           []*CompileUnit
 	Symbols         []*Symbol
 	Frames          []Frame
-	Symbolize       func(pcs map[*KernelModule][]uint64) ([]Frame, error)
+	Symbolize       func(pcs map[*vminfo.KernelModule][]uint64) ([]Frame, error)
 	CallbackPoints  []uint64
 	PreciseCoverage bool
 }
@@ -22,12 +23,12 @@ type Impl struct {
 type CompileUnit struct {
 	ObjectUnit
 	Path   string
-	Module *KernelModule
+	Module *vminfo.KernelModule
 }
 
 type Symbol struct {
 	ObjectUnit
-	Module     *KernelModule
+	Module     *vminfo.KernelModule
 	Unit       *CompileUnit
 	Start      uint64
 	End        uint64
@@ -42,7 +43,7 @@ type ObjectUnit struct {
 }
 
 type Frame struct {
-	Module   *KernelModule
+	Module   *vminfo.KernelModule
 	PC       uint64
 	Name     string
 	FuncName string
@@ -66,7 +67,7 @@ type SecRange struct {
 const LineEnd = 1 << 30
 
 func Make(target *targets.Target, vm, objDir, srcDir, buildDir string, splitBuild bool,
-	moduleObj []string, modules []*KernelModule) (*Impl, error) {
+	moduleObj []string, modules []*vminfo.KernelModule) (*Impl, error) {
 	if objDir == "" {
 		return nil, fmt.Errorf("kernel obj directory is not specified")
 	}
diff --git a/pkg/cover/backend/dwarf.go b/pkg/cover/backend/dwarf.go
index ab60cdf26..b6f7ef034 100644
--- a/pkg/cover/backend/dwarf.go
+++ b/pkg/cover/backend/dwarf.go
@@ -20,6 +20,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/osutil"
 	"github.com/google/syzkaller/pkg/symbolizer"
+	"github.com/google/syzkaller/pkg/vminfo"
 	"github.com/google/syzkaller/sys/targets"
 )
 
@@ -30,11 +31,11 @@ type dwarfParams struct {
 	buildDir              string
 	splitBuildDelimiters  []string
 	moduleObj             []string
-	hostModules           []*KernelModule
-	readSymbols           func(*KernelModule, *symbolInfo) ([]*Symbol, error)
-	readTextData          func(*KernelModule) ([]byte, error)
-	readModuleCoverPoints func(*targets.Target, *KernelModule, *symbolInfo) ([2][]uint64, error)
-	readTextRanges        func(*KernelModule) ([]pcRange, []*CompileUnit, error)
+	hostModules           []*vminfo.KernelModule
+	readSymbols           func(*vminfo.KernelModule, *symbolInfo) ([]*Symbol, error)
+	readTextData          func(*vminfo.KernelModule) ([]byte, error)
+	readModuleCoverPoints func(*targets.Target, *vminfo.KernelModule, *symbolInfo) ([2][]uint64, error)
+	readTextRanges        func(*vminfo.KernelModule) ([]pcRange, []*CompileUnit, error)
 	getCompilerVersion    func(string) string
 }
 
@@ -104,7 +105,7 @@ type Result struct {
 	Symbols     []*Symbol
 }
 
-func processModule(params *dwarfParams, module *KernelModule, info *symbolInfo,
+func processModule(params *dwarfParams, module *vminfo.KernelModule, info *symbolInfo,
 	target *targets.Target) (*Result, error) {
 	symbols, err := params.readSymbols(module, info)
 	if err != nil {
@@ -159,7 +160,7 @@ func makeDWARFUnsafe(params *dwarfParams) (*Impl, error) {
 	}
 	binC := make(chan binResult, len(modules))
 	for _, module := range modules {
-		go func(m *KernelModule) {
+		go func(m *vminfo.KernelModule) {
 			info := &symbolInfo{
 				tracePC:     make(map[uint64]bool),
 				traceCmp:    make(map[uint64]bool),
@@ -242,7 +243,7 @@ func makeDWARFUnsafe(params *dwarfParams) (*Impl, error) {
 	impl := &Impl{
 		Units:   allUnits,
 		Symbols: allSymbols,
-		Symbolize: func(pcs map[*KernelModule][]uint64) ([]Frame, error) {
+		Symbolize: func(pcs map[*vminfo.KernelModule][]uint64) ([]Frame, error) {
 			return symbolize(target, &interner, objDir, srcDir, buildDir, splitBuildDelimiters, pcs)
 		},
 		CallbackPoints:  allCoverPoints[0],
@@ -350,7 +351,7 @@ type pcRange struct {
 
 type pcFixFn = (func([2]uint64) ([2]uint64, bool))
 
-func readTextRanges(debugInfo *dwarf.Data, module *KernelModule, pcFix pcFixFn) (
+func readTextRanges(debugInfo *dwarf.Data, module *vminfo.KernelModule, pcFix pcFixFn) (
 	[]pcRange, []*CompileUnit, error) {
 	var ranges []pcRange
 	var units []*CompileUnit
@@ -397,7 +398,7 @@ func readTextRanges(debugInfo *dwarf.Data, module *KernelModule, pcFix pcFixFn)
 }
 
 func symbolizeModule(target *targets.Target, interner *symbolizer.Interner, objDir, srcDir, buildDir string,
-	splitBuildDelimiters []string, mod *KernelModule, pcs []uint64) ([]Frame, error) {
+	splitBuildDelimiters []string, mod *vminfo.KernelModule, pcs []uint64) ([]Frame, error) {
 	procs := runtime.GOMAXPROCS(0) / 2
 	if need := len(pcs) / 1000; procs > need {
 		procs = need
@@ -478,7 +479,7 @@ func symbolizeModule(target *targets.Target, interner *symbolizer.Interner, objD
 }
 
 func symbolize(target *targets.Target, interner *symbolizer.Interner, objDir, srcDir, buildDir string,
-	splitBuildDelimiters []string, pcs map[*KernelModule][]uint64) ([]Frame, error) {
+	splitBuildDelimiters []string, pcs map[*vminfo.KernelModule][]uint64) ([]Frame, error) {
 	var frames []Frame
 	type frameResult struct {
 		frames []Frame
@@ -486,7 +487,7 @@ func symbolize(target *targets.Target, interner *symbolizer.Interner, objDir, sr
 	}
 	frameC := make(chan frameResult, len(pcs))
 	for mod, pcs1 := range pcs {
-		go func(mod *KernelModule, pcs []uint64) {
+		go func(mod *vminfo.KernelModule, pcs []uint64) {
 			frames, err := symbolizeModule(target, interner, objDir, srcDir, buildDir, splitBuildDelimiters, mod, pcs)
 			frameC <- frameResult{frames: frames, err: err}
 		}(mod, pcs1)
@@ -610,7 +611,7 @@ func cleanPath(path, objDir, srcDir, buildDir string, splitBuildDelimiters []str
 // objdump is an old, slow way of finding coverage points.
 // amd64 uses faster option of parsing binary directly (readCoverPoints).
 // TODO: use the faster approach for all other arches and drop this.
-func objdump(target *targets.Target, mod *KernelModule) ([2][]uint64, error) {
+func objdump(target *targets.Target, mod *vminfo.KernelModule) ([2][]uint64, error) {
 	var pcs [2][]uint64
 	cmd := osutil.Command(target.Objdump, "-d", "--no-show-raw-insn", mod.Path)
 	stdout, err := cmd.StdoutPipe()
diff --git a/pkg/cover/backend/elf.go b/pkg/cover/backend/elf.go
index 7152922d1..05e15ad45 100644
--- a/pkg/cover/backend/elf.go
+++ b/pkg/cover/backend/elf.go
@@ -13,11 +13,12 @@ import (
 
 	"github.com/google/syzkaller/pkg/log"
 	"github.com/google/syzkaller/pkg/mgrconfig"
+	"github.com/google/syzkaller/pkg/vminfo"
 	"github.com/google/syzkaller/sys/targets"
 )
 
 func makeELF(target *targets.Target, objDir, srcDir, buildDir string, splitBuildDelimiters, moduleObj []string,
-	hostModules []*KernelModule) (*Impl, error) {
+	hostModules []*vminfo.KernelModule) (*Impl, error) {
 	return makeDWARF(&dwarfParams{
 		target:                target,
 		objDir:                objDir,
@@ -59,7 +60,7 @@ func getTraceCallbackType(name string) int {
 	return TraceCbNone
 }
 
-func elfReadSymbols(module *KernelModule, info *symbolInfo) ([]*Symbol, error) {
+func elfReadSymbols(module *vminfo.KernelModule, info *symbolInfo) ([]*Symbol, error) {
 	file, err := elf.Open(module.Path)
 	if err != nil {
 		return nil, err
@@ -110,7 +111,7 @@ func elfReadSymbols(module *KernelModule, info *symbolInfo) ([]*Symbol, error) {
 	return symbols, nil
 }
 
-func elfReadTextRanges(module *KernelModule) ([]pcRange, []*CompileUnit, error) {
+func elfReadTextRanges(module *vminfo.KernelModule) ([]pcRange, []*CompileUnit, error) {
 	file, err := elf.Open(module.Path)
 	if err != nil {
 		return nil, nil, err
@@ -154,7 +155,7 @@ func elfReadTextRanges(module *KernelModule) ([]pcRange, []*CompileUnit, error)
 	return readTextRanges(debugInfo, module, pcFix)
 }
 
-func elfReadTextData(module *KernelModule) ([]byte, error) {
+func elfReadTextData(module *vminfo.KernelModule) ([]byte, error) {
 	file, err := elf.Open(module.Path)
 	if err != nil {
 		return nil, err
@@ -167,7 +168,8 @@ func elfReadTextData(module *KernelModule) ([]byte, error) {
 	return text.Data()
 }
 
-func elfReadModuleCoverPoints(target *targets.Target, module *KernelModule, info *symbolInfo) ([2][]uint64, error) {
+func elfReadModuleCoverPoints(target *targets.Target, module *vminfo.KernelModule, info *symbolInfo) ([2][]uint64,
+	error) {
 	var pcs [2][]uint64
 	file, err := elf.Open(module.Path)
 	if err != nil {
@@ -220,7 +222,7 @@ func elfGetCompilerVersion(path string) string {
 	return string(data[:])
 }
 
-func elfReadTextSecRange(module *KernelModule) (*SecRange, error) {
+func elfReadTextSecRange(module *vminfo.KernelModule) (*SecRange, error) {
 	text, err := elfReadTextSec(module)
 	if err != nil {
 		return nil, err
@@ -232,7 +234,7 @@ func elfReadTextSecRange(module *KernelModule) (*SecRange, error) {
 	return r, nil
 }
 
-func elfReadTextSec(module *KernelModule) (*elf.Section, error) {
+func elfReadTextSec(module *vminfo.KernelModule) (*elf.Section, error) {
 	file, err := elf.Open(module.Path)
 	if err != nil {
 		return nil, err
diff --git a/pkg/cover/backend/gvisor.go b/pkg/cover/backend/gvisor.go
index ed8a316cd..56a36a5dc 100644
--- a/pkg/cover/backend/gvisor.go
+++ b/pkg/cover/backend/gvisor.go
@@ -11,10 +11,12 @@ import (
 	"strconv"
 
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/pkg/vminfo"
 	"github.com/google/syzkaller/sys/targets"
 )
 
-func makeGvisor(target *targets.Target, objDir, srcDir, buildDir string, modules []*KernelModule) (*Impl, error) {
+func makeGvisor(target *targets.Target, objDir, srcDir, buildDir string, modules []*vminfo.KernelModule) (*Impl,
+	error) {
 	if len(modules) != 0 {
 		return nil, fmt.Errorf("gvisor coverage does not support modules")
 	}
diff --git a/pkg/cover/backend/mach-o.go b/pkg/cover/backend/mach-o.go
index 5f7eb78a0..b2cde9a66 100644
--- a/pkg/cover/backend/mach-o.go
+++ b/pkg/cover/backend/mach-o.go
@@ -10,11 +10,12 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/google/syzkaller/pkg/vminfo"
 	"github.com/google/syzkaller/sys/targets"
 )
 
 func makeMachO(target *targets.Target, objDir, srcDir, buildDir string,
-	moduleObj []string, hostModules []*KernelModule) (*Impl, error) {
+	moduleObj []string, hostModules []*vminfo.KernelModule) (*Impl, error) {
 	return makeDWARF(&dwarfParams{
 		target:                target,
 		objDir:                objDir,
@@ -29,7 +30,7 @@ func makeMachO(target *targets.Target, objDir, srcDir, buildDir string,
 	})
 }
 
-func machoReadSymbols(module *KernelModule, info *symbolInfo) ([]*Symbol, error) {
+func machoReadSymbols(module *vminfo.KernelModule, info *symbolInfo) ([]*Symbol, error) {
 	file, err := macho.Open(module.Path)
 	if err != nil {
 		return nil, err
@@ -87,7 +88,7 @@ func machoReadSymbols(module *KernelModule, info *symbolInfo) ([]*Symbol, error)
 	return symbols, nil
 }
 
-func machoReadTextRanges(module *KernelModule) ([]pcRange, []*CompileUnit, error) {
+func machoReadTextRanges(module *vminfo.KernelModule) ([]pcRange, []*CompileUnit, error) {
 	dir, kernel := filepath.Split(module.Path)
 	dSYMPath := filepath.Join(dir, fmt.Sprintf(
 		"%[1]s.dSYM/Contents/Resources/DWARF/%[1]s", kernel))
@@ -102,7 +103,7 @@ func machoReadTextRanges(module *KernelModule) ([]pcRange, []*CompileUnit, error
 	return readTextRanges(debugInfo, module, nil)
 }
 
-func machoReadTextData(module *KernelModule) ([]byte, error) {
+func machoReadTextData(module *vminfo.KernelModule) ([]byte, error) {
 	file, err := macho.Open(module.Path)
 	if err != nil {
 		return nil, err
@@ -114,7 +115,8 @@ func machoReadTextData(module *KernelModule) ([]byte, error) {
 	return text.Data()
 }
 
-func machoReadModuleCoverPoints(target *targets.Target, module *KernelModule, info *symbolInfo) ([2][]uint64, error) {
+func machoReadModuleCoverPoints(target *targets.Target, module *vminfo.KernelModule, info *symbolInfo) ([2][]uint64,
+	error) {
 	// TODO: Linux/ELF supports module symbols. We should probably also do that
 	// for XNU/Mach-O. To maximize code re-use we already have a lot of the
 	// plumbing for module support. I think we mainly miss an equivalent to
diff --git a/pkg/cover/backend/modules.go b/pkg/cover/backend/modules.go
index c96d4bd05..206b6986a 100644
--- a/pkg/cover/backend/modules.go
+++ b/pkg/cover/backend/modules.go
@@ -12,26 +12,20 @@ import (
 	"strings"
 
 	"github.com/google/syzkaller/pkg/log"
+	"github.com/google/syzkaller/pkg/vminfo"
 	"github.com/google/syzkaller/sys/targets"
 )
 
-type KernelModule struct {
-	Name string
-	Addr uint64
-	Size uint64
-	Path string
-}
-
 func DiscoverModules(target *targets.Target, objDir string, moduleObj []string) (
-	[]*KernelModule, error) {
-	module := &KernelModule{
+	[]*vminfo.KernelModule, error) {
+	module := &vminfo.KernelModule{
 		Path: filepath.Join(objDir, target.KernelObject),
 	}
 	textRange, err := elfReadTextSecRange(module)
 	if err != nil {
 		return nil, err
 	}
-	modules := []*KernelModule{
+	modules := []*vminfo.KernelModule{
 		// A dummy module representing the kernel itself.
 		{
 			Path: module.Path,
@@ -50,18 +44,18 @@ func DiscoverModules(target *targets.Target, objDir string, moduleObj []string)
 	return modules, nil
 }
 
-func discoverModulesLinux(dirs []string) ([]*KernelModule, error) {
+func discoverModulesLinux(dirs []string) ([]*vminfo.KernelModule, error) {
 	paths, err := locateModules(dirs)
 	if err != nil {
 		return nil, err
 	}
-	var modules []*KernelModule
+	var modules []*vminfo.KernelModule
 	for name, path := range paths {
 		if path == "" {
 			continue
 		}
 		log.Logf(2, "module %v -> %v", name, path)
-		module := &KernelModule{
+		module := &vminfo.KernelModule{
 			Name: name,
 			Path: path,
 		}
@@ -149,7 +143,7 @@ func searchModuleName(data []byte) string {
 	return string(data[pos+len(key) : end])
 }
 
-func getKaslrOffset(modules []*KernelModule, pcBase uint64) uint64 {
+func getKaslrOffset(modules []*vminfo.KernelModule, pcBase uint64) uint64 {
 	for _, mod := range modules {
 		if mod.Name == "" {
 			return mod.Addr - pcBase
@@ -159,9 +153,9 @@ func getKaslrOffset(modules []*KernelModule, pcBase uint64) uint64 {
 }
 
 // when CONFIG_RANDOMIZE_BASE=y, pc from kcov already removed kaslr_offset.
-func FixModules(localModules, modules []*KernelModule, pcBase uint64) []*KernelModule {
+func FixModules(localModules, modules []*vminfo.KernelModule, pcBase uint64) []*vminfo.KernelModule {
 	kaslrOffset := getKaslrOffset(modules, pcBase)
-	var modules1 []*KernelModule
+	var modules1 []*vminfo.KernelModule
 	for _, mod := range modules {
 		size := uint64(0)
 		path := ""
@@ -180,7 +174,7 @@ func FixModules(localModules, modules []*KernelModule, pcBase uint64) []*KernelM
 			// mod.Addr for core kernel from target is _stext addr
 			addr = 0
 		}
-		modules1 = append(modules1, &KernelModule{
+		modules1 = append(modules1, &vminfo.KernelModule{
 			Name: mod.Name,
 			Size: size,
 			Addr: addr,
diff --git a/pkg/cover/canonicalizer.go b/pkg/cover/canonicalizer.go
index b1f866963..6edb3dbb3 100644
--- a/pkg/cover/canonicalizer.go
+++ b/pkg/cover/canonicalizer.go
@@ -8,11 +8,12 @@ import (
 	"sort"
 
 	"github.com/google/syzkaller/pkg/log"
+	"github.com/google/syzkaller/pkg/vminfo"
 )
 
 type Canonicalizer struct {
 	// Map of modules stored as module name:kernel module.
-	modules map[string]*KernelModule
+	modules map[string]*vminfo.KernelModule
 
 	// Contains a sorted list of the canonical module addresses.
 	moduleKeys []uint64
@@ -48,13 +49,13 @@ type canonicalizerModule struct {
 	discard bool
 }
 
-func NewCanonicalizer(modules []*KernelModule, flagSignal bool) *Canonicalizer {
+func NewCanonicalizer(modules []*vminfo.KernelModule, flagSignal bool) *Canonicalizer {
 	// Return if not using canonicalization.
 	if len(modules) == 0 || !flagSignal {
 		return &Canonicalizer{}
 	}
 	// Create a map of canonical module offsets by name.
-	canonicalModules := make(map[string]*KernelModule)
+	canonicalModules := make(map[string]*vminfo.KernelModule)
 	for _, module := range modules {
 		canonicalModules[module.Name] = module
 	}
@@ -68,7 +69,7 @@ func NewCanonicalizer(modules []*KernelModule, flagSignal bool) *Canonicalizer {
 	}
 }
 
-func (can *Canonicalizer) NewInstance(modules []*KernelModule) *CanonicalizerInstance {
+func (can *Canonicalizer) NewInstance(modules []*vminfo.KernelModule) *CanonicalizerInstance {
 	if can.moduleKeys == nil {
 		return &CanonicalizerInstance{}
 	}
@@ -130,7 +131,7 @@ func (ci *CanonicalizerInstance) Decanonicalize(elems []uint64) []uint64 {
 }
 
 // Store sorted list of addresses. Used to binary search when converting PCs.
-func setModuleKeys(moduleKeys []uint64, modules []*KernelModule) {
+func setModuleKeys(moduleKeys []uint64, modules []*vminfo.KernelModule) {
 	for idx, module := range modules {
 		moduleKeys[idx] = module.Addr
 	}
diff --git a/pkg/cover/canonicalizer_test.go b/pkg/cover/canonicalizer_test.go
index 5a8fa2fb7..b2284d80a 100644
--- a/pkg/cover/canonicalizer_test.go
+++ b/pkg/cover/canonicalizer_test.go
@@ -10,6 +10,8 @@ import (
 	"reflect"
 	"strconv"
 	"testing"
+
+	"github.com/google/syzkaller/pkg/vminfo"
 )
 
 type RPCServer struct {
@@ -244,7 +246,7 @@ func (serv *RPCServer) runTest(val canonicalizeValue) string {
 	return ""
 }
 
-func (serv *RPCServer) connect(name string, modules []*KernelModule, flagSignal bool) {
+func (serv *RPCServer) connect(name string, modules []*vminfo.KernelModule, flagSignal bool) {
 	if !serv.modulesInitialized {
 		serv.canonicalModules = NewCanonicalizer(modules, flagSignal)
 		serv.modulesInitialized = true
@@ -255,10 +257,10 @@ func (serv *RPCServer) connect(name string, modules []*KernelModule, flagSignal
 	}
 }
 
-func initModules(addrs, sizes []uint64) []*KernelModule {
-	var modules []*KernelModule
+func initModules(addrs, sizes []uint64) []*vminfo.KernelModule {
+	var modules []*vminfo.KernelModule
 	for idx, addr := range addrs {
-		modules = append(modules, &KernelModule{
+		modules = append(modules, &vminfo.KernelModule{
 			Name: strconv.FormatInt(int64(idx), 10),
 			Addr: addr,
 			Size: sizes[idx],
diff --git a/pkg/cover/report.go b/pkg/cover/report.go
index b41a96356..b45150d73 100644
--- a/pkg/cover/report.go
+++ b/pkg/cover/report.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/cover/backend"
 	"github.com/google/syzkaller/pkg/mgrconfig"
+	"github.com/google/syzkaller/pkg/vminfo"
 	"github.com/google/syzkaller/sys/targets"
 	"golang.org/x/exp/maps"
 )
@@ -28,14 +29,12 @@ type Prog struct {
 	PCs  []uint64
 }
 
-type KernelModule = backend.KernelModule
-
 func GetPCBase(cfg *mgrconfig.Config) (uint64, error) {
 	return backend.GetPCBase(cfg)
 }
 
 func MakeReportGenerator(cfg *mgrconfig.Config, subsystem []mgrconfig.Subsystem,
-	modules []*KernelModule, rawCover bool) (*ReportGenerator, error) {
+	modules []*vminfo.KernelModule, rawCover bool) (*ReportGenerator, error) {
 	impl, err := backend.Make(cfg.SysTarget, cfg.Type, cfg.KernelObj,
 		cfg.KernelSrc, cfg.KernelBuildSrc, cfg.AndroidSplitBuild, cfg.ModuleObj, modules)
 	if err != nil {
@@ -206,7 +205,7 @@ func (rg *ReportGenerator) symbolizePCs(PCs []uint64) error {
 		return nil
 	}
 	symbolize := make(map[*backend.Symbol]bool)
-	pcs := make(map[*backend.KernelModule][]uint64)
+	pcs := make(map[*vminfo.KernelModule][]uint64)
 	for _, pc := range PCs {
 		sym := rg.findSymbol(pc)
 		if sym == nil || sym.Symbolized || symbolize[sym] {