pkg/subsystem: restructure the package

Remove the entity and match subpackages.

Regenerate the linux.go file.

21 files changed, 178 insertions, 223 deletions

diff --git a/pkg/subsystem/entity/entities.go b/pkg/subsystem/entities.go
index e2b29a7f3..b74217bcd 100644
--- a/pkg/subsystem/entity/entities.go
+++ b/pkg/subsystem/entities.go
@@ -1,7 +1,7 @@
 // Copyright 2023 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 entity
+package subsystem
 
 type Subsystem struct {
 	Name        string
diff --git a/pkg/subsystem/extractor.go b/pkg/subsystem/extractor.go
index e54086b29..075c8079d 100644
--- a/pkg/subsystem/extractor.go
+++ b/pkg/subsystem/extractor.go
@@ -3,10 +3,6 @@
 
 package subsystem
 
-import (
-	"github.com/google/syzkaller/pkg/subsystem/entity"
-)
-
 // Extractor deduces the subsystems from the list of crashes.
 type Extractor struct {
 	raw rawExtractorInterface
@@ -21,17 +17,17 @@ type Crash struct {
 
 // rawExtractorInterface simplifies testing.
 type rawExtractorInterface interface {
-	FromPath(path string) []*entity.Subsystem
-	FromProg(progBytes []byte) []*entity.Subsystem
+	FromPath(path string) []*Subsystem
+	FromProg(progBytes []byte) []*Subsystem
 }
 
-func MakeExtractor(list []*entity.Subsystem) *Extractor {
+func MakeExtractor(list []*Subsystem) *Extractor {
 	return &Extractor{raw: makeRawExtractor(list)}
 }
 
-func (e *Extractor) Extract(crashes []*Crash) []*entity.Subsystem {
+func (e *Extractor) Extract(crashes []*Crash) []*Subsystem {
 	// First put all subsystems to the same list.
-	subsystems := []*entity.Subsystem{}
+	subsystems := []*Subsystem{}
 	for _, crash := range crashes {
 		if crash.GuiltyPath != "" {
 			subsystems = append(subsystems, e.raw.FromPath(crash.GuiltyPath)...)
@@ -42,7 +38,7 @@ func (e *Extractor) Extract(crashes []*Crash) []*entity.Subsystem {
 	}
 
 	// If there are both parents and children, remove parents.
-	ignore := make(map[*entity.Subsystem]struct{})
+	ignore := make(map[*Subsystem]struct{})
 	for _, entry := range subsystems {
 		for p := range entry.ReachableParents() {
 			ignore[p] = struct{}{}
@@ -50,7 +46,7 @@ func (e *Extractor) Extract(crashes []*Crash) []*entity.Subsystem {
 	}
 
 	// And calculate counts.
-	counts := make(map[*entity.Subsystem]int)
+	counts := make(map[*Subsystem]int)
 	maxCount := 0
 	for _, entry := range subsystems {
 		if _, ok := ignore[entry]; ok {
@@ -63,7 +59,7 @@ func (e *Extractor) Extract(crashes []*Crash) []*entity.Subsystem {
 	}
 
 	// Pick the most prevalent ones.
-	ret := []*entity.Subsystem{}
+	ret := []*Subsystem{}
 	for entry, count := range counts {
 		if count < maxCount {
 			continue
diff --git a/pkg/subsystem/extractor_test.go b/pkg/subsystem/extractor_test.go
index 5dedd0b1a..c2d165973 100644
--- a/pkg/subsystem/extractor_test.go
+++ b/pkg/subsystem/extractor_test.go
@@ -7,7 +7,6 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -15,14 +14,14 @@ func TestExtractor(t *testing.T) {
 	// Objects used in tests.
 	fsPath := "fs/"
 	extProg, nfsProg := []byte("ext prog"), []byte("nfs prog")
-	fs := &entity.Subsystem{Name: "fs"}
-	ext := &entity.Subsystem{Name: "ext", Parents: []*entity.Subsystem{fs}}
-	nfs := &entity.Subsystem{Name: "nfs", Parents: []*entity.Subsystem{fs}}
+	fs := &Subsystem{Name: "fs"}
+	ext := &Subsystem{Name: "ext", Parents: []*Subsystem{fs}}
+	nfs := &Subsystem{Name: "nfs", Parents: []*Subsystem{fs}}
 	// Tests themselves.
 	tests := []struct {
 		name    string
 		crashes []*Crash
-		want    []*entity.Subsystem
+		want    []*Subsystem
 	}{
 		{
 			name: `Make sure it works fine with just a single path`,
@@ -31,7 +30,7 @@ func TestExtractor(t *testing.T) {
 					GuiltyPath: fsPath,
 				},
 			},
-			want: []*entity.Subsystem{fs},
+			want: []*Subsystem{fs},
 		},
 		{
 			name: `Make sure a child shadows its parent`,
@@ -44,7 +43,7 @@ func TestExtractor(t *testing.T) {
 					SyzRepro:   extProg,
 				},
 			},
-			want: []*entity.Subsystem{ext},
+			want: []*Subsystem{ext},
 		},
 		{
 			name: `Two equally present children`,
@@ -61,7 +60,7 @@ func TestExtractor(t *testing.T) {
 					SyzRepro:   nfsProg,
 				},
 			},
-			want: []*entity.Subsystem{nfs, ext},
+			want: []*Subsystem{nfs, ext},
 		},
 		{
 			name: `One child is more present than another`,
@@ -82,17 +81,17 @@ func TestExtractor(t *testing.T) {
 					SyzRepro:   extProg,
 				},
 			},
-			want: []*entity.Subsystem{ext},
+			want: []*Subsystem{ext},
 		},
 	}
 	extractor := &Extractor{
 		raw: &testRawExtractor{
-			perPath: map[string][]*entity.Subsystem{
+			perPath: map[string][]*Subsystem{
 				fsPath: {fs},
 			},
 			perProg: []progSubsystems{
-				{extProg, []*entity.Subsystem{ext}},
-				{nfsProg, []*entity.Subsystem{nfs}},
+				{extProg, []*Subsystem{ext}},
+				{nfsProg, []*Subsystem{nfs}},
 			},
 		},
 	}
@@ -103,20 +102,20 @@ func TestExtractor(t *testing.T) {
 }
 
 type testRawExtractor struct {
-	perPath map[string][]*entity.Subsystem
+	perPath map[string][]*Subsystem
 	perProg []progSubsystems
 }
 
 type progSubsystems struct {
 	prog []byte
-	ret  []*entity.Subsystem
+	ret  []*Subsystem
 }
 
-func (e *testRawExtractor) FromPath(path string) []*entity.Subsystem {
+func (e *testRawExtractor) FromPath(path string) []*Subsystem {
 	return e.perPath[path]
 }
 
-func (e *testRawExtractor) FromProg(progBytes []byte) []*entity.Subsystem {
+func (e *testRawExtractor) FromProg(progBytes []byte) []*Subsystem {
 	for _, obj := range e.perProg {
 		if reflect.DeepEqual(progBytes, obj.prog) {
 			return obj.ret
diff --git a/pkg/subsystem/match/coincidence.go b/pkg/subsystem/linux/coincidence.go
index 45bd98884..86ee0794f 100644
--- a/pkg/subsystem/match/coincidence.go
+++ b/pkg/subsystem/linux/coincidence.go
@@ -1,24 +1,24 @@
 // Copyright 2023 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 match
+package linux
 
-import "github.com/google/syzkaller/pkg/subsystem/entity"
+import "github.com/google/syzkaller/pkg/subsystem"
 
 // CoincidenceMatrix represents a matrix that, for every pair of subsystems
 // A and B, stores the number of times A and B have coincided in the input data.
-// So far we only need it for entity.Subsystem, so its interface is tailored to it.
+// So far we only need it for subsystem.Subsystem, so its interface is tailored to it.
 type CoincidenceMatrix struct {
-	matrix map[*entity.Subsystem]map[*entity.Subsystem]int
+	matrix map[*subsystem.Subsystem]map[*subsystem.Subsystem]int
 }
 
 func MakeCoincidenceMatrix() *CoincidenceMatrix {
 	return &CoincidenceMatrix{
-		matrix: make(map[*entity.Subsystem]map[*entity.Subsystem]int),
+		matrix: make(map[*subsystem.Subsystem]map[*subsystem.Subsystem]int),
 	}
 }
 
-func (cm *CoincidenceMatrix) Record(items ...*entity.Subsystem) {
+func (cm *CoincidenceMatrix) Record(items ...*subsystem.Subsystem) {
 	for i := 0; i < len(items); i++ {
 		for j := 0; j < len(items); j++ {
 			cm.inc(items[i], items[j])
@@ -26,15 +26,15 @@ func (cm *CoincidenceMatrix) Record(items ...*entity.Subsystem) {
 	}
 }
 
-func (cm *CoincidenceMatrix) Count(a *entity.Subsystem) int {
+func (cm *CoincidenceMatrix) Count(a *subsystem.Subsystem) int {
 	return cm.Get(a, a)
 }
 
-func (cm *CoincidenceMatrix) Get(a, b *entity.Subsystem) int {
+func (cm *CoincidenceMatrix) Get(a, b *subsystem.Subsystem) int {
 	return cm.matrix[a][b]
 }
 
-func (cm *CoincidenceMatrix) NonEmptyPairs(cb func(a, b *entity.Subsystem, val int)) {
+func (cm *CoincidenceMatrix) NonEmptyPairs(cb func(a, b *subsystem.Subsystem, val int)) {
 	for a, sub := range cm.matrix {
 		for b, val := range sub {
 			if a == b {
@@ -45,10 +45,10 @@ func (cm *CoincidenceMatrix) NonEmptyPairs(cb func(a, b *entity.Subsystem, val i
 	}
 }
 
-func (cm *CoincidenceMatrix) inc(a, b *entity.Subsystem) {
+func (cm *CoincidenceMatrix) inc(a, b *subsystem.Subsystem) {
 	subMatrix, ok := cm.matrix[a]
 	if !ok {
-		subMatrix = make(map[*entity.Subsystem]int)
+		subMatrix = make(map[*subsystem.Subsystem]int)
 		cm.matrix[a] = subMatrix
 	}
 	subMatrix[b]++
diff --git a/pkg/subsystem/match/coincidence_test.go b/pkg/subsystem/linux/coincidence_test.go
index 15f0dd241..8aaf5ed0a 100644
--- a/pkg/subsystem/match/coincidence_test.go
+++ b/pkg/subsystem/linux/coincidence_test.go
@@ -1,18 +1,18 @@
 // Copyright 2023 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 match
+package linux
 
 import (
 	"testing"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
+	"github.com/google/syzkaller/pkg/subsystem"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestCoincidenceMatrix(t *testing.T) {
 	cm := MakeCoincidenceMatrix()
-	a, b, c := &entity.Subsystem{}, &entity.Subsystem{}, &entity.Subsystem{}
+	a, b, c := &subsystem.Subsystem{}, &subsystem.Subsystem{}, &subsystem.Subsystem{}
 	cm.Record(a, b)
 	cm.Record(b, c)
 
@@ -28,12 +28,12 @@ func TestCoincidenceMatrix(t *testing.T) {
 
 	// Test the iterator.
 	type pair struct {
-		a *entity.Subsystem
-		b *entity.Subsystem
+		a *subsystem.Subsystem
+		b *subsystem.Subsystem
 	}
 	expected := []pair{{a, b}, {b, a}, {b, c}, {c, b}}
 	got := []pair{}
-	cm.NonEmptyPairs(func(a, b *entity.Subsystem, _ int) {
+	cm.NonEmptyPairs(func(a, b *subsystem.Subsystem, _ int) {
 		got = append(got, pair{a, b})
 	})
 	assert.ElementsMatch(t, expected, got)
diff --git a/pkg/subsystem/linux/maintainers.go b/pkg/subsystem/linux/maintainers.go
index 7c60a840a..2f4d63003 100644
--- a/pkg/subsystem/linux/maintainers.go
+++ b/pkg/subsystem/linux/maintainers.go
@@ -13,7 +13,7 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
+	"github.com/google/syzkaller/pkg/subsystem"
 )
 
 // maintainersRecord represents a single raw record in the MAINTAINERS file.
@@ -146,7 +146,7 @@ func parseEmail(value string) (string, error) {
 	return addr.Address, nil
 }
 
-func (r maintainersRecord) ToPathRule() entity.PathRule {
+func (r maintainersRecord) ToPathRule() subsystem.PathRule {
 	inclRe := strings.Builder{}
 	for i, wildcard := range r.includePatterns {
 		if i > 0 {
@@ -167,7 +167,7 @@ func (r maintainersRecord) ToPathRule() entity.PathRule {
 		}
 		wildcardToRegexp(wildcard, &exclRe)
 	}
-	return entity.PathRule{
+	return subsystem.PathRule{
 		IncludeRegexp: inclRe.String(),
 		ExcludeRegexp: exclRe.String(),
 	}
diff --git a/pkg/subsystem/linux/maintainers_test.go b/pkg/subsystem/linux/maintainers_test.go
index dc3299dbf..676bbcda1 100644
--- a/pkg/subsystem/linux/maintainers_test.go
+++ b/pkg/subsystem/linux/maintainers_test.go
@@ -8,8 +8,7 @@ import (
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
-	"github.com/google/syzkaller/pkg/subsystem/entity"
-	"github.com/google/syzkaller/pkg/subsystem/match"
+	"github.com/google/syzkaller/pkg/subsystem"
 )
 
 func TestRecordToPathRule(t *testing.T) {
@@ -127,8 +126,8 @@ func TestRecordToPathRule(t *testing.T) {
 	for _, loopTest := range tests {
 		test := loopTest
 		t.Run(test.name, func(t *testing.T) {
-			pm := match.MakePathMatcher([]*entity.Subsystem{
-				{PathRules: []entity.PathRule{test.record.ToPathRule()}},
+			pm := subsystem.MakePathMatcher([]*subsystem.Subsystem{
+				{PathRules: []subsystem.PathRule{test.record.ToPathRule()}},
 			})
 			for _, path := range test.match {
 				if len(pm.Match(path)) != 1 {
diff --git a/pkg/subsystem/linux/names.go b/pkg/subsystem/linux/names.go
index be57a5ab3..3dcc2deed 100644
--- a/pkg/subsystem/linux/names.go
+++ b/pkg/subsystem/linux/names.go
@@ -7,12 +7,12 @@ import (
 	"fmt"
 	"regexp"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
+	"github.com/google/syzkaller/pkg/subsystem"
 )
 
 // setSubsystemNames assigns unique names to the presented subsystems.
 // If it failed to assign a name to a subsystem, the Name field remains empty.
-func setSubsystemNames(list []*entity.Subsystem) error {
+func setSubsystemNames(list []*subsystem.Subsystem) error {
 	dups := map[string]bool{}
 	for _, item := range list {
 		// For now, we can only infer name from the list email.
diff --git a/pkg/subsystem/linux/names_test.go b/pkg/subsystem/linux/names_test.go
index 0b2352411..03f9a86d3 100644
--- a/pkg/subsystem/linux/names_test.go
+++ b/pkg/subsystem/linux/names_test.go
@@ -6,7 +6,7 @@ package linux
 import (
 	"testing"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
+	"github.com/google/syzkaller/pkg/subsystem"
 )
 
 func TestEmailToName(t *testing.T) {
@@ -33,8 +33,8 @@ type subsystemTestInput struct {
 	outName string
 }
 
-func (sti subsystemTestInput) ToSubsystem() *entity.Subsystem {
-	s := &entity.Subsystem{}
+func (sti subsystemTestInput) ToSubsystem() *subsystem.Subsystem {
+	s := &subsystem.Subsystem{}
 	if sti.email != "" {
 		s.Lists = append(s.Lists, sti.email)
 	}
@@ -92,7 +92,7 @@ func TestSetSubsystemNames(t *testing.T) {
 	for _, test := range tests {
 		curr := test
 		t.Run(curr.name, func(t *testing.T) {
-			list := []*entity.Subsystem{}
+			list := []*subsystem.Subsystem{}
 			for _, i := range curr.inputs {
 				list = append(list, i.ToSubsystem())
 			}
diff --git a/pkg/subsystem/linux/parents.go b/pkg/subsystem/linux/parents.go
index fdea4a62f..344bc0db2 100644
--- a/pkg/subsystem/linux/parents.go
+++ b/pkg/subsystem/linux/parents.go
@@ -3,14 +3,11 @@
 
 package linux
 
-import (
-	"github.com/google/syzkaller/pkg/subsystem/entity"
-	"github.com/google/syzkaller/pkg/subsystem/match"
-)
+import "github.com/google/syzkaller/pkg/subsystem"
 
 // parentTransformations applies all subsystem list transformations that have been implemented.
-func parentTransformations(matrix *match.CoincidenceMatrix,
-	list []*entity.Subsystem) ([]*entity.Subsystem, error) {
+func parentTransformations(matrix *CoincidenceMatrix,
+	list []*subsystem.Subsystem) ([]*subsystem.Subsystem, error) {
 	list = dropSmallSubsystems(matrix, list)
 	list = dropDuplicateSubsystems(matrix, list)
 	err := setParents(matrix, list)
@@ -24,13 +21,13 @@ func parentTransformations(matrix *match.CoincidenceMatrix,
 // We assume A is a child of B if:
 // 1) B covers more paths than A.
 // 2) Most of the paths that relate to A also relate to B.
-func setParents(matrix *match.CoincidenceMatrix, list []*entity.Subsystem) error {
+func setParents(matrix *CoincidenceMatrix, list []*subsystem.Subsystem) error {
 	// Some subsystems might have already been dropeed.
-	inInput := map[*entity.Subsystem]bool{}
+	inInput := map[*subsystem.Subsystem]bool{}
 	for _, item := range list {
 		inInput[item] = true
 	}
-	matrix.NonEmptyPairs(func(a, b *entity.Subsystem, count int) {
+	matrix.NonEmptyPairs(func(a, b *subsystem.Subsystem, count int) {
 		if !inInput[a] || !inInput[b] {
 			return
 		}
@@ -45,10 +42,10 @@ func setParents(matrix *match.CoincidenceMatrix, list []*entity.Subsystem) error
 }
 
 // dropSmallSubsystems removes subsystems for which we have found only a few matches in the filesystem tree.
-func dropSmallSubsystems(matrix *match.CoincidenceMatrix, list []*entity.Subsystem) []*entity.Subsystem {
+func dropSmallSubsystems(matrix *CoincidenceMatrix, list []*subsystem.Subsystem) []*subsystem.Subsystem {
 	const cutOffCount = 2
 
-	newList := []*entity.Subsystem{}
+	newList := []*subsystem.Subsystem{}
 	for _, item := range list {
 		if matrix.Count(item) > cutOffCount || len(item.Syscalls) > 0 {
 			newList = append(newList, item)
@@ -61,9 +58,9 @@ func dropSmallSubsystems(matrix *match.CoincidenceMatrix, list []*entity.Subsyst
 // First, if subsystems A and B 100% overlap, we prefer the one that's alphabetically first.
 // Second, if subsystem A is fully enclosed in subsystem B and constitutes more than 75% of B,
 // we drop A, since it brings little value.
-func dropDuplicateSubsystems(matrix *match.CoincidenceMatrix, list []*entity.Subsystem) []*entity.Subsystem {
-	drop := map[*entity.Subsystem]struct{}{}
-	firstIsBetter := func(first, second *entity.Subsystem) bool {
+func dropDuplicateSubsystems(matrix *CoincidenceMatrix, list []*subsystem.Subsystem) []*subsystem.Subsystem {
+	drop := map[*subsystem.Subsystem]struct{}{}
+	firstIsBetter := func(first, second *subsystem.Subsystem) bool {
 		firstEmail, secondEmail := "", ""
 		if len(first.Lists) > 0 {
 			firstEmail = first.Lists[0]
@@ -73,7 +70,7 @@ func dropDuplicateSubsystems(matrix *match.CoincidenceMatrix, list []*entity.Sub
 		}
 		return firstEmail < secondEmail
 	}
-	matrix.NonEmptyPairs(func(a, b *entity.Subsystem, count int) {
+	matrix.NonEmptyPairs(func(a, b *subsystem.Subsystem, count int) {
 		// Only consider cases when A is fully enclosed in B, i.e. M[A][B] == M[A][A].
 		if count != matrix.Count(a) {
 			return
@@ -91,7 +88,7 @@ func dropDuplicateSubsystems(matrix *match.CoincidenceMatrix, list []*entity.Sub
 			drop[a] = struct{}{}
 		}
 	})
-	newList := []*entity.Subsystem{}
+	newList := []*subsystem.Subsystem{}
 	for _, item := range list {
 		if _, exists := drop[item]; !exists {
 			newList = append(newList, item)
@@ -102,15 +99,15 @@ func dropDuplicateSubsystems(matrix *match.CoincidenceMatrix, list []*entity.Sub
 
 // The algorithm runs in O(E * (E + V)).
 // We expect that E is quite low here, so it should be fine.
-func transitiveReduction(list []*entity.Subsystem) {
+func transitiveReduction(list []*subsystem.Subsystem) {
 	for _, s := range list {
-		removeParents := map[*entity.Subsystem]bool{}
+		removeParents := map[*subsystem.Subsystem]bool{}
 		for _, p := range s.Parents {
 			for otherP := range p.ReachableParents() {
 				removeParents[otherP] = true
 			}
 		}
-		newParents := []*entity.Subsystem{}
+		newParents := []*subsystem.Subsystem{}
 		for _, p := range s.Parents {
 			if !removeParents[p] {
 				newParents = append(newParents, p)
diff --git a/pkg/subsystem/linux/parents_test.go b/pkg/subsystem/linux/parents_test.go
index dde13177d..444e4ff33 100644
--- a/pkg/subsystem/linux/parents_test.go
+++ b/pkg/subsystem/linux/parents_test.go
@@ -7,40 +7,39 @@ import (
 	"testing"
 	"testing/fstest"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
-	"github.com/google/syzkaller/pkg/subsystem/match"
+	"github.com/google/syzkaller/pkg/subsystem"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestDropSmallSubsystems(t *testing.T) {
-	kernel := &entity.Subsystem{}
-	net := &entity.Subsystem{}
-	fs := &entity.Subsystem{}
-	legal := &entity.Subsystem{}
+	kernel := &subsystem.Subsystem{}
+	net := &subsystem.Subsystem{}
+	fs := &subsystem.Subsystem{}
+	legal := &subsystem.Subsystem{}
 
-	matrix := match.MakeCoincidenceMatrix()
+	matrix := MakeCoincidenceMatrix()
 	matrix.Record(kernel, net)
 	matrix.Record(kernel, fs)
 	matrix.Record(kernel, net, fs)
 	matrix.Record(kernel, net, fs)
 	matrix.Record(kernel, net, fs)
 
-	ret := dropSmallSubsystems(matrix, []*entity.Subsystem{kernel, net, fs, legal})
-	assert.ElementsMatch(t, []*entity.Subsystem{kernel, net, fs}, ret)
+	ret := dropSmallSubsystems(matrix, []*subsystem.Subsystem{kernel, net, fs, legal})
+	assert.ElementsMatch(t, []*subsystem.Subsystem{kernel, net, fs}, ret)
 }
 
 func TestDropDuplicateSubsystems(t *testing.T) {
-	input, expected := []*entity.Subsystem{}, []*entity.Subsystem{}
-	matrix := match.MakeCoincidenceMatrix()
+	input, expected := []*subsystem.Subsystem{}, []*subsystem.Subsystem{}
+	matrix := MakeCoincidenceMatrix()
 
 	// Always present.
-	kernel := &entity.Subsystem{Name: "kernel"}
+	kernel := &subsystem.Subsystem{Name: "kernel"}
 	input = append(input, kernel)
 	expected = append(expected, kernel)
 
 	// Fully overlap.
-	sameA := &entity.Subsystem{Lists: []string{"SameA@gmail.com"}}
-	sameB := &entity.Subsystem{Lists: []string{"SameB@gmail.com"}}
+	sameA := &subsystem.Subsystem{Lists: []string{"SameA@gmail.com"}}
+	sameB := &subsystem.Subsystem{Lists: []string{"SameB@gmail.com"}}
 	matrix.Record(kernel, sameA, sameB)
 	matrix.Record(kernel, sameA, sameB)
 	matrix.Record(kernel, sameA, sameB)
@@ -48,7 +47,7 @@ func TestDropDuplicateSubsystems(t *testing.T) {
 	expected = append(expected, sameA)
 
 	// Overlap, but the smaller one is not so significant.
-	ext4, fs := &entity.Subsystem{Name: "ext4"}, &entity.Subsystem{Name: "fs"}
+	ext4, fs := &subsystem.Subsystem{Name: "ext4"}, &subsystem.Subsystem{Name: "fs"}
 	matrix.Record(kernel, ext4, fs)
 	matrix.Record(kernel, ext4, fs)
 	matrix.Record(kernel, fs) // 66%.
@@ -56,7 +55,7 @@ func TestDropDuplicateSubsystems(t *testing.T) {
 	expected = append(expected, ext4, fs)
 
 	// Overlap, and the smaller one takes a big part.
-	toDrop, stays := &entity.Subsystem{Name: "to-drop"}, &entity.Subsystem{Name: "stays"}
+	toDrop, stays := &subsystem.Subsystem{Name: "to-drop"}, &subsystem.Subsystem{Name: "stays"}
 	for i := 0; i < 5; i++ {
 		matrix.Record(kernel, toDrop, stays)
 	}
@@ -75,31 +74,31 @@ func TestTransitiveReduction(t *testing.T) {
 	// (d, b)
 	// (d, e)
 	// (c, a)
-	a := &entity.Subsystem{}
-	b := &entity.Subsystem{Parents: []*entity.Subsystem{a}}
-	c := &entity.Subsystem{Parents: []*entity.Subsystem{a, b}}
-	e := &entity.Subsystem{}
-	d := &entity.Subsystem{Parents: []*entity.Subsystem{a, b, c, e}}
-	transitiveReduction([]*entity.Subsystem{a, b, c, d, e})
+	a := &subsystem.Subsystem{}
+	b := &subsystem.Subsystem{Parents: []*subsystem.Subsystem{a}}
+	c := &subsystem.Subsystem{Parents: []*subsystem.Subsystem{a, b}}
+	e := &subsystem.Subsystem{}
+	d := &subsystem.Subsystem{Parents: []*subsystem.Subsystem{a, b, c, e}}
+	transitiveReduction([]*subsystem.Subsystem{a, b, c, d, e})
 
 	// The result should be:
 	// (d, c), (c, b), (b, a)
 	// (d, e)
-	assert.ElementsMatch(t, d.Parents, []*entity.Subsystem{c, e})
-	assert.ElementsMatch(t, c.Parents, []*entity.Subsystem{b})
+	assert.ElementsMatch(t, d.Parents, []*subsystem.Subsystem{c, e})
+	assert.ElementsMatch(t, c.Parents, []*subsystem.Subsystem{b})
 }
 
 func TestSetParents(t *testing.T) {
-	kernel := &entity.Subsystem{PathRules: []entity.PathRule{{
+	kernel := &subsystem.Subsystem{PathRules: []subsystem.PathRule{{
 		IncludeRegexp: `.*`,
 	}}}
-	net := &entity.Subsystem{PathRules: []entity.PathRule{{
+	net := &subsystem.Subsystem{PathRules: []subsystem.PathRule{{
 		IncludeRegexp: `^net/`,
 	}}}
-	wireless := &entity.Subsystem{PathRules: []entity.PathRule{{
+	wireless := &subsystem.Subsystem{PathRules: []subsystem.PathRule{{
 		IncludeRegexp: `^net/wireless`,
 	}}}
-	drivers := &entity.Subsystem{PathRules: []entity.PathRule{{
+	drivers := &subsystem.Subsystem{PathRules: []subsystem.PathRule{{
 		IncludeRegexp: `^drivers/`,
 	}}}
 
@@ -114,20 +113,20 @@ func TestSetParents(t *testing.T) {
 		"drivers/android/binder.c": {},
 	}
 
-	matrix, err := match.BuildCoincidenceMatrix(tree,
-		[]*entity.Subsystem{kernel, net, wireless, drivers}, nil)
+	matrix, err := BuildCoincidenceMatrix(tree,
+		[]*subsystem.Subsystem{kernel, net, wireless, drivers}, nil)
 	assert.NoError(t, err)
 
 	// Calculate parents.
 
-	err = setParents(matrix, []*entity.Subsystem{kernel, net, wireless, drivers})
+	err = setParents(matrix, []*subsystem.Subsystem{kernel, net, wireless, drivers})
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	// Verify parents.
-	assert.ElementsMatch(t, net.Parents, []*entity.Subsystem{kernel})
-	assert.ElementsMatch(t, wireless.Parents, []*entity.Subsystem{net})
-	assert.ElementsMatch(t, drivers.Parents, []*entity.Subsystem{kernel})
-	assert.ElementsMatch(t, kernel.Parents, []*entity.Subsystem{})
+	assert.ElementsMatch(t, net.Parents, []*subsystem.Subsystem{kernel})
+	assert.ElementsMatch(t, wireless.Parents, []*subsystem.Subsystem{net})
+	assert.ElementsMatch(t, drivers.Parents, []*subsystem.Subsystem{kernel})
+	assert.ElementsMatch(t, kernel.Parents, []*subsystem.Subsystem{})
 }
diff --git a/pkg/subsystem/match/path_coincidence.go b/pkg/subsystem/linux/path_coincidence.go
index 944546490..44182bd6a 100644
--- a/pkg/subsystem/match/path_coincidence.go
+++ b/pkg/subsystem/linux/path_coincidence.go
@@ -1,7 +1,7 @@
 // Copyright 2023 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 match
+package linux
 
 import (
 	"io/fs"
@@ -9,13 +9,13 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
+	"github.com/google/syzkaller/pkg/subsystem"
 )
 
-func BuildCoincidenceMatrix(root fs.FS, list []*entity.Subsystem,
+func BuildCoincidenceMatrix(root fs.FS, list []*subsystem.Subsystem,
 	excludeRe *regexp.Regexp) (*CoincidenceMatrix, error) {
 	// Create a matcher.
-	matcher := MakePathMatcher(list)
+	matcher := subsystem.MakePathMatcher(list)
 	chPaths, chResult := extractSubsystems(matcher)
 	// The final consumer goroutine.
 	cm := MakeCoincidenceMatrix()
@@ -47,9 +47,9 @@ var (
 	includePathRe = regexp.MustCompile(`(?:/|\.(?:c|h|S))$`)
 )
 
-func extractSubsystems(matcher *PathMatcher) (chan<- string, <-chan []*entity.Subsystem) {
+func extractSubsystems(matcher *subsystem.PathMatcher) (chan<- string, <-chan []*subsystem.Subsystem) {
 	procs := runtime.NumCPU()
-	paths, output := make(chan string, procs), make(chan []*entity.Subsystem, procs)
+	paths, output := make(chan string, procs), make(chan []*subsystem.Subsystem, procs)
 	var wg sync.WaitGroup
 	for i := 0; i < procs; i++ {
 		wg.Add(1)
diff --git a/pkg/subsystem/match/path_coincidence_test.go b/pkg/subsystem/linux/path_coincidence_test.go
index 2d1969d7f..ac32dcd31 100644
--- a/pkg/subsystem/match/path_coincidence_test.go
+++ b/pkg/subsystem/linux/path_coincidence_test.go
@@ -1,27 +1,27 @@
 // Copyright 2023 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 match
+package linux
 
 import (
 	"testing"
 	"testing/fstest"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
+	"github.com/google/syzkaller/pkg/subsystem"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestBuildCoincidenceMatrix(t *testing.T) {
-	vfs := &entity.Subsystem{PathRules: []entity.PathRule{
+	vfs := &subsystem.Subsystem{PathRules: []subsystem.PathRule{
 		{IncludeRegexp: `^fs/`},
 	}}
-	ext4 := &entity.Subsystem{PathRules: []entity.PathRule{
+	ext4 := &subsystem.Subsystem{PathRules: []subsystem.PathRule{
 		{IncludeRegexp: `^fs/ext4/`},
 	}}
-	ntfs := &entity.Subsystem{PathRules: []entity.PathRule{
+	ntfs := &subsystem.Subsystem{PathRules: []subsystem.PathRule{
 		{IncludeRegexp: `^fs/ntfs/`},
 	}}
-	kernel := &entity.Subsystem{PathRules: []entity.PathRule{
+	kernel := &subsystem.Subsystem{PathRules: []subsystem.PathRule{
 		{IncludeRegexp: `.*`},
 	}}
 
@@ -33,7 +33,7 @@ func TestBuildCoincidenceMatrix(t *testing.T) {
 		"fs/fat/file.c":  {},
 		"net/socket.c":   {},
 	}
-	matrix, err := BuildCoincidenceMatrix(fs, []*entity.Subsystem{vfs, ntfs, ext4, kernel}, nil)
+	matrix, err := BuildCoincidenceMatrix(fs, []*subsystem.Subsystem{vfs, ntfs, ext4, kernel}, nil)
 	assert.NoError(t, err)
 
 	// Test total counts.
diff --git a/pkg/subsystem/linux/subsystems.go b/pkg/subsystem/linux/subsystems.go
index 5ca57a1be..18ac3864e 100644
--- a/pkg/subsystem/linux/subsystems.go
+++ b/pkg/subsystem/linux/subsystems.go
@@ -10,16 +10,15 @@ import (
 	"regexp"
 	"sort"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
-	"github.com/google/syzkaller/pkg/subsystem/match"
+	"github.com/google/syzkaller/pkg/subsystem"
 )
 
-func ListFromRepo(repo string) ([]*entity.Subsystem, error) {
+func ListFromRepo(repo string) ([]*subsystem.Subsystem, error) {
 	return listFromRepoInner(os.DirFS(repo), linuxSubsystemRules)
 }
 
 // listFromRepoInner allows for better testing.
-func listFromRepoInner(root fs.FS, rules *customRules) ([]*entity.Subsystem, error) {
+func listFromRepoInner(root fs.FS, rules *customRules) ([]*subsystem.Subsystem, error) {
 	records, err := getMaintainers(root)
 	if err != nil {
 		return nil, err
@@ -31,7 +30,7 @@ func listFromRepoInner(root fs.FS, rules *customRules) ([]*entity.Subsystem, err
 		extraRules: rules,
 	}
 	list := ctx.groupByList()
-	matrix, err := match.BuildCoincidenceMatrix(root, list, dropPatterns)
+	matrix, err := BuildCoincidenceMatrix(root, list, dropPatterns)
 	if err != nil {
 		return nil, err
 	}
@@ -71,7 +70,7 @@ var (
 	dropPatterns = regexp.MustCompile(`^(Documentation|scripts|samples|tools)|Makefile`)
 )
 
-func (ctx *linuxCtx) groupByList() []*entity.Subsystem {
+func (ctx *linuxCtx) groupByList() []*subsystem.Subsystem {
 	perList := make(map[string][]*maintainersRecord)
 	for _, record := range ctx.rawRecords {
 		for _, list := range record.lists {
@@ -82,7 +81,7 @@ func (ctx *linuxCtx) groupByList() []*entity.Subsystem {
 	if ctx.extraRules != nil {
 		exclude = ctx.extraRules.notSubsystemEmails
 	}
-	ret := []*entity.Subsystem{}
+	ret := []*subsystem.Subsystem{}
 	for email, list := range perList {
 		if _, skip := exclude[email]; skip {
 			continue
@@ -96,7 +95,7 @@ func (ctx *linuxCtx) groupByList() []*entity.Subsystem {
 	return ret
 }
 
-func (ctx *linuxCtx) applyExtraRules(list []*entity.Subsystem) {
+func (ctx *linuxCtx) applyExtraRules(list []*subsystem.Subsystem) {
 	if ctx.extraRules == nil {
 		return
 	}
@@ -105,7 +104,7 @@ func (ctx *linuxCtx) applyExtraRules(list []*entity.Subsystem) {
 	}
 }
 
-func mergeRawRecords(email string, records []*maintainersRecord) *entity.Subsystem {
+func mergeRawRecords(email string, records []*maintainersRecord) *subsystem.Subsystem {
 	unique := func(list []string) []string {
 		m := make(map[string]struct{})
 		for _, s := range list {
@@ -119,7 +118,7 @@ func mergeRawRecords(email string, records []*maintainersRecord) *entity.Subsyst
 		return ret
 	}
 	var maintainers []string
-	subsystem := &entity.Subsystem{Lists: []string{email}}
+	subsystem := &subsystem.Subsystem{Lists: []string{email}}
 	for _, record := range records {
 		rule := record.ToPathRule()
 		if !rule.IsEmpty() {
diff --git a/pkg/subsystem/linux/subsystems_test.go b/pkg/subsystem/linux/subsystems_test.go
index f13009fad..cbc4b9699 100644
--- a/pkg/subsystem/linux/subsystems_test.go
+++ b/pkg/subsystem/linux/subsystems_test.go
@@ -8,8 +8,7 @@ import (
 	"testing"
 	"testing/fstest"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
-	"github.com/google/syzkaller/pkg/subsystem/match"
+	"github.com/google/syzkaller/pkg/subsystem"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -26,7 +25,7 @@ func TestGroupLinuxSubsystems(t *testing.T) {
 		// It complicates the test, so let's skip it here.
 		s.Parents = nil
 	}
-	expected := []*entity.Subsystem{
+	expected := []*subsystem.Subsystem{
 		{
 			Name:        "fs",
 			Lists:       []string{"linux-fsdevel@vger.kernel.org"},
@@ -88,7 +87,7 @@ func TestLinuxSubsystemPaths(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	matcher := match.MakePathMatcher(subsystems)
+	matcher := subsystem.MakePathMatcher(subsystems)
 	tests := []struct {
 		path string
 		list []string
diff --git a/pkg/subsystem/list.go b/pkg/subsystem/list.go
index 737ab859e..7842f8620 100644
--- a/pkg/subsystem/list.go
+++ b/pkg/subsystem/list.go
@@ -3,10 +3,6 @@
 
 package subsystem
 
-import (
-	"github.com/google/syzkaller/pkg/subsystem/entity"
-)
-
 // In general, it's not correct to assume that subsystems are only determined by target.OS,
 // because subsystems are related not to the user interface of the OS kernel, but rather to
 // the OS kernel implementation.
@@ -17,16 +13,16 @@ import (
 // Therefore, subsystem lists have to be a completely different entity.
 
 var (
-	lists = make(map[string][]*entity.Subsystem)
+	lists = make(map[string][]*Subsystem)
 )
 
-func RegisterList(name string, list []*entity.Subsystem) {
+func RegisterList(name string, list []*Subsystem) {
 	if _, ok := lists[name]; ok {
 		panic(name + " subsystem list already exists!")
 	}
 	lists[name] = list
 }
 
-func GetList(name string) []*entity.Subsystem {
+func GetList(name string) []*Subsystem {
 	return lists[name]
 }
diff --git a/pkg/subsystem/lists/linux.go b/pkg/subsystem/lists/linux.go
index bd03428d3..708fbe67b 100644
--- a/pkg/subsystem/lists/linux.go
+++ b/pkg/subsystem/lists/linux.go
@@ -3,11 +3,10 @@
 
 package lists
 
-import . "github.com/google/syzkaller/pkg/subsystem/entity"
-import "github.com/google/syzkaller/pkg/subsystem"
+import . "github.com/google/syzkaller/pkg/subsystem"
 
 func init() {
-	subsystem.RegisterList("linux", subsystems)
+	RegisterList("linux", subsystems)
 }
 
 // The subsystem list:
@@ -123,7 +122,6 @@ func init() {
 //   - kexec
 //   - keyrings
 //   - kgdb-bugreport
-//   - kselftest
 //   - kunit
 //   - kvm
 //     - kvm-riscv
@@ -179,7 +177,6 @@ func init() {
 //       - ath10k
 //       - ath11k
 //       - b43
-//       - brcm80211
 //       - libertas
 //       - wcn36xx
 //       - zd1211
@@ -243,7 +240,7 @@ func init() {
 //   - xtensa
 
 var subsystems = []*Subsystem{
-	shacyfmac, ac100, accelerators, acpi, acpi4asus, acpica, acrn, actions, afs, alpha, alsa, amdgfx, amlogic, apparmor, arch, arm, armmsm, asahi, aspeed, ath10k, ath11k, atm, audit, autofs, axis, batman, b43, bcache, block, bluetooth, bpf, brcm80211, bridge, btrfs, cachefs, can, ceph, cgroups, chromeplatform, cifs, cirrus, clk, cluster, codalist, coresight, coreteam, crypto, csky, cxl, damon, dccp, dell, devicetree, dm, dmaengine, drbd, dri, ecryptfs, edac, efi, erofs, etnaviv, ext4, f2fs, fbdev, fpga, freedreno, fs, fscrypt, fsi, fsverity, geode, gpio, greybus, hams, hardening, hexagon, hippi, hwmon, hyperv, i2c, i3c, ia64, ide, iio, imx, industrypack, input, integrity, intelgfx, intelgvt, intelwiredlan, iouring, iommu, isdn4linux, jfs, karma, kasan, kernel, kexec, keyrings, kgdbbugreport, kselftest, kunit, kvm, kvmriscv, kvmarm, leds, libertas, lima, linux1394, linuxppc, linuxpps, livepatching, llvm, loongarch, lsm, lvs, m68k, malidp, media, mediatek, megaraid, mhi, mips, mjpeg, mm, mmc, modules, mpi3, mptfusion, mptcp, mtd, nbd, net, nfc, nfs, nilfs, nitro, nouveau, ntb, ntfs, ntfs3, nvdimm, nvme, ocfs2, omap, optee, openiscsi, openbmc, openipmi, openrisc, openvswitch, openwrt, orangefs, ossdrivers, overlayfs, oxnas, parisc, parport, pci, perf, phy, pm, ppp, pvrusb2, pwm, qat, raid, rcu, rdma, rds, reiserfs, remoteproc, renesassoc, riscv, rockchip, rpi, rttools, rtc, rustfor, s390, samsungsoc, scsi, sctp, selinux, serial, sgx, sh, snpsarc, sof, sparclinux, speakup, spi, spice, squashfs, staging, stm32, sunxi, target, tegra, tipc, tomoyo, trace, uclinux, um, unisoc, usb, usbstorage, v9fs, video, virt, watchdog, wcn36xx, wireguard, wireless, wpan, x25, x86, x86drivers, xen, xfs, xtensa, zd1211,
+	shacyfmac, ac100, accelerators, acpi, acpi4asus, acpica, acrn, actions, afs, alpha, alsa, amdgfx, amlogic, apparmor, arch, arm, armmsm, asahi, aspeed, ath10k, ath11k, atm, audit, autofs, axis, batman, b43, bcache, block, bluetooth, bpf, bridge, btrfs, cachefs, can, ceph, cgroups, chromeplatform, cifs, cirrus, clk, cluster, codalist, coresight, coreteam, crypto, csky, cxl, damon, dccp, dell, devicetree, dm, dmaengine, drbd, dri, ecryptfs, edac, efi, erofs, etnaviv, ext4, f2fs, fbdev, fpga, freedreno, fs, fscrypt, fsi, fsverity, geode, gpio, greybus, hams, hardening, hexagon, hippi, hwmon, hyperv, i2c, i3c, ia64, ide, iio, imx, industrypack, input, integrity, intelgfx, intelgvt, intelwiredlan, iouring, iommu, isdn4linux, jfs, karma, kasan, kernel, kexec, keyrings, kgdbbugreport, kunit, kvm, kvmriscv, kvmarm, leds, libertas, lima, linux1394, linuxppc, linuxpps, livepatching, llvm, loongarch, lsm, lvs, m68k, malidp, media, mediatek, megaraid, mhi, mips, mjpeg, mm, mmc, modules, mpi3, mptfusion, mptcp, mtd, nbd, net, nfc, nfs, nilfs, nitro, nouveau, ntb, ntfs, ntfs3, nvdimm, nvme, ocfs2, omap, optee, openiscsi, openbmc, openipmi, openrisc, openvswitch, openwrt, orangefs, ossdrivers, overlayfs, oxnas, parisc, parport, pci, perf, phy, pm, ppp, pvrusb2, pwm, qat, raid, rcu, rdma, rds, reiserfs, remoteproc, renesassoc, riscv, rockchip, rpi, rttools, rtc, rustfor, s390, samsungsoc, scsi, sctp, selinux, serial, sgx, sh, snpsarc, sof, sparclinux, speakup, spi, spice, squashfs, staging, stm32, sunxi, target, tegra, tipc, tomoyo, trace, uclinux, um, unisoc, usb, usbstorage, v9fs, video, virt, watchdog, wcn36xx, wireguard, wireless, wpan, x25, x86, x86drivers, xen, xfs, xtensa, zd1211,
 }
 
 // Subsystem info.
@@ -818,16 +815,6 @@ var bpf = &Subsystem{
 	},
 }
 
-var brcm80211 = &Subsystem{
-	Name:        "brcm80211",
-	Lists:       []string{"brcm80211-dev-list.pdl@broadcom.com"},
-	Maintainers: []string{"aspriel@gmail.com", "franky.lin@broadcom.com", "hante.meuleman@broadcom.com"},
-	Parents:     []*Subsystem{wireless},
-	PathRules: []PathRule{
-		{IncludeRegexp: "^drivers/net/wireless/broadcom/brcm80211/"},
-	},
-}
-
 var bridge = &Subsystem{
 	Name:        "bridge",
 	Lists:       []string{"bridge@lists.linux-foundation.org"},
@@ -2106,16 +2093,6 @@ var kgdbbugreport = &Subsystem{
 	},
 }
 
-var kselftest = &Subsystem{
-	Name:    "kselftest",
-	Lists:   []string{"linux-kselftest@vger.kernel.org"},
-	Parents: []*Subsystem{kernel},
-	PathRules: []PathRule{
-		{IncludeRegexp: "^include/kunit/|^lib/kunit/"},
-		{IncludeRegexp: "^lib/list-test\\.c$"},
-	},
-}
-
 var kunit = &Subsystem{
 	Name:    "kunit",
 	Lists:   []string{"kunit-dev@googlegroups.com"},
@@ -2168,7 +2145,7 @@ var kvmriscv = &Subsystem{
 
 var kvmarm = &Subsystem{
 	Name:        "kvmarm",
-	Lists:       []string{"kvmarm@lists.linux.dev"},
+	Lists:       []string{"kvmarm@lists.cs.columbia.edu"},
 	Maintainers: []string{"maz@kernel.org"},
 	Parents:     []*Subsystem{arm},
 	PathRules: []PathRule{
diff --git a/pkg/subsystem/match/match.go b/pkg/subsystem/match.go
index 31874f978..ad5d3a257 100644
--- a/pkg/subsystem/match/match.go
+++ b/pkg/subsystem/match.go
@@ -1,13 +1,11 @@
 // Copyright 2023 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 match
+package subsystem
 
 import (
 	"regexp"
 	"strings"
-
-	"github.com/google/syzkaller/pkg/subsystem/entity"
 )
 
 type PathMatcher struct {
@@ -17,10 +15,10 @@ type PathMatcher struct {
 type match struct {
 	include *regexp.Regexp
 	exclude *regexp.Regexp
-	object  *entity.Subsystem
+	object  *Subsystem
 }
 
-func MakePathMatcher(list []*entity.Subsystem) *PathMatcher {
+func MakePathMatcher(list []*Subsystem) *PathMatcher {
 	m := &PathMatcher{}
 	for _, item := range list {
 		m.register(item)
@@ -28,9 +26,9 @@ func MakePathMatcher(list []*entity.Subsystem) *PathMatcher {
 	return m
 }
 
-func (p *PathMatcher) register(item *entity.Subsystem) {
+func (p *PathMatcher) register(item *Subsystem) {
 	onlyInclude := []string{}
-	list := []entity.PathRule{}
+	list := []PathRule{}
 	for _, r := range item.PathRules {
 		if r.ExcludeRegexp == "" {
 			// It's expected that almost everything will go to this branch.
@@ -40,7 +38,7 @@ func (p *PathMatcher) register(item *entity.Subsystem) {
 		}
 	}
 	if len(onlyInclude) > 0 {
-		list = append(list, entity.PathRule{
+		list = append(list, PathRule{
 			IncludeRegexp: strings.Join(onlyInclude, "|"),
 		})
 	}
@@ -49,8 +47,8 @@ func (p *PathMatcher) register(item *entity.Subsystem) {
 	}
 }
 
-func (p *PathMatcher) Match(path string) []*entity.Subsystem {
-	ret := []*entity.Subsystem{}
+func (p *PathMatcher) Match(path string) []*Subsystem {
+	ret := []*Subsystem{}
 	for _, m := range p.matches {
 		if m.exclude != nil && m.exclude.MatchString(path) {
 			continue
@@ -63,7 +61,7 @@ func (p *PathMatcher) Match(path string) []*entity.Subsystem {
 	return ret
 }
 
-func buildMatch(rule entity.PathRule, item *entity.Subsystem) *match {
+func buildMatch(rule PathRule, item *Subsystem) *match {
 	m := &match{object: item}
 	if rule.IncludeRegexp != "" {
 		m.include = regexp.MustCompile(rule.IncludeRegexp)
diff --git a/pkg/subsystem/match/match_test.go b/pkg/subsystem/match_test.go
index 2f7440e19..7c96b0bcd 100644
--- a/pkg/subsystem/match/match_test.go
+++ b/pkg/subsystem/match_test.go
@@ -1,18 +1,17 @@
 // Copyright 2023 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 match
+package subsystem
 
 import (
 	"testing"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestPathMatcher(t *testing.T) {
-	arm := &entity.Subsystem{
-		PathRules: []entity.PathRule{
+	arm := &Subsystem{
+		PathRules: []PathRule{
 			{
 				IncludeRegexp: `^arch/arm/.*$`,
 				ExcludeRegexp: `^arch/arm/boot/dts/.*$`,
@@ -24,29 +23,29 @@ func TestPathMatcher(t *testing.T) {
 			},
 		},
 	}
-	docs := &entity.Subsystem{
-		PathRules: []entity.PathRule{
+	docs := &Subsystem{
+		PathRules: []PathRule{
 			{IncludeRegexp: `^Documentation/.*$`},
 		},
 	}
-	m := MakePathMatcher([]*entity.Subsystem{arm, docs})
-	assert.ElementsMatch(t, []*entity.Subsystem{arm, docs},
+	m := MakePathMatcher([]*Subsystem{arm, docs})
+	assert.ElementsMatch(t, []*Subsystem{arm, docs},
 		m.Match(`Documentation/devicetree/bindings/interrupt-controller/arm,vic.yaml`))
-	assert.ElementsMatch(t, []*entity.Subsystem{arm}, m.Match(`arch/arm/a.c`))
-	assert.ElementsMatch(t, []*entity.Subsystem{docs}, m.Match(`Documentation/a/b/c.md`))
+	assert.ElementsMatch(t, []*Subsystem{arm}, m.Match(`arch/arm/a.c`))
+	assert.ElementsMatch(t, []*Subsystem{docs}, m.Match(`Documentation/a/b/c.md`))
 	assert.Empty(t, m.Match(`arch/boot/dts/a.c`))
 }
 
 func TestPathMatchOrder(t *testing.T) {
-	s := &entity.Subsystem{
-		PathRules: []entity.PathRule{
+	s := &Subsystem{
+		PathRules: []PathRule{
 			{
 				IncludeRegexp: `^a/b/.*$`,
 				ExcludeRegexp: `^a/.*$`,
 			},
 		},
 	}
-	m := MakePathMatcher([]*entity.Subsystem{s})
+	m := MakePathMatcher([]*Subsystem{s})
 	// If we first exclude a/, then a/b/c never matches.
 	assert.Empty(t, m.Match("a/b/c"))
 }
diff --git a/pkg/subsystem/raw_extractor.go b/pkg/subsystem/raw_extractor.go
index 4a86b1f6b..fa964fd25 100644
--- a/pkg/subsystem/raw_extractor.go
+++ b/pkg/subsystem/raw_extractor.go
@@ -4,21 +4,19 @@
 package subsystem
 
 import (
-	"github.com/google/syzkaller/pkg/subsystem/entity"
-	"github.com/google/syzkaller/pkg/subsystem/match"
 	"github.com/google/syzkaller/prog"
 )
 
 // rawExtractor performs low-level subsystem matching (directly by a path or a syscall).
 type rawExtractor struct {
-	matcher *match.PathMatcher
-	perCall map[string][]*entity.Subsystem
+	matcher *PathMatcher
+	perCall map[string][]*Subsystem
 }
 
-func makeRawExtractor(list []*entity.Subsystem) *rawExtractor {
+func makeRawExtractor(list []*Subsystem) *rawExtractor {
 	ret := &rawExtractor{
-		matcher: match.MakePathMatcher(list),
-		perCall: make(map[string][]*entity.Subsystem),
+		matcher: MakePathMatcher(list),
+		perCall: make(map[string][]*Subsystem),
 	}
 	for _, subsystem := range list {
 		for _, call := range subsystem.Syscalls {
@@ -28,19 +26,19 @@ func makeRawExtractor(list []*entity.Subsystem) *rawExtractor {
 	return ret
 }
 
-func (e *rawExtractor) FromPath(path string) []*entity.Subsystem {
+func (e *rawExtractor) FromPath(path string) []*Subsystem {
 	return e.matcher.Match(path)
 }
 
-func (e *rawExtractor) FromProg(progBytes []byte) []*entity.Subsystem {
-	calls := make(map[*entity.Subsystem]struct{})
+func (e *rawExtractor) FromProg(progBytes []byte) []*Subsystem {
+	calls := make(map[*Subsystem]struct{})
 	progCalls, _, _ := prog.CallSet(progBytes)
 	for call := range progCalls {
 		for _, subsystem := range e.perCall[call] {
 			calls[subsystem] = struct{}{}
 		}
 	}
-	list := []*entity.Subsystem{}
+	list := []*Subsystem{}
 	for key := range calls {
 		list = append(list, key)
 	}
diff --git a/pkg/subsystem/raw_extractor_test.go b/pkg/subsystem/raw_extractor_test.go
index 9d221af86..44273be2e 100644
--- a/pkg/subsystem/raw_extractor_test.go
+++ b/pkg/subsystem/raw_extractor_test.go
@@ -6,23 +6,22 @@ package subsystem
 import (
 	"testing"
 
-	"github.com/google/syzkaller/pkg/subsystem/entity"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestSubsystemExtractor(t *testing.T) {
-	ioUring := &entity.Subsystem{
+	ioUring := &Subsystem{
 		Name: "io_uring",
-		PathRules: []entity.PathRule{
+		PathRules: []PathRule{
 			{
 				IncludeRegexp: `io_uring/.*`,
 			},
 		},
 		Syscalls: []string{"syz_io_uring_setup"},
 	}
-	security := &entity.Subsystem{
+	security := &Subsystem{
 		Name: "security",
-		PathRules: []entity.PathRule{
+		PathRules: []PathRule{
 			{
 				IncludeRegexp: `security/.*`,
 				ExcludeRegexp: `security/selinux/.*`,
@@ -32,21 +31,21 @@ func TestSubsystemExtractor(t *testing.T) {
 			},
 		},
 	}
-	net := &entity.Subsystem{
+	net := &Subsystem{
 		Name: "net",
-		PathRules: []entity.PathRule{
+		PathRules: []PathRule{
 			{
 				IncludeRegexp: `net/.*`,
 			},
 		},
 	}
-	obj := makeRawExtractor([]*entity.Subsystem{ioUring, security, net})
+	obj := makeRawExtractor([]*Subsystem{ioUring, security, net})
 
 	// Verify path matching.
-	assert.ElementsMatch(t, obj.FromPath(`io_uring/file.c`), []*entity.Subsystem{ioUring})
-	assert.ElementsMatch(t, obj.FromPath(`security/file.c`), []*entity.Subsystem{security})
-	assert.ElementsMatch(t, obj.FromPath(`security/selinux/file.c`), []*entity.Subsystem{})
-	assert.ElementsMatch(t, obj.FromPath(`net/ipv6/calipso.c`), []*entity.Subsystem{net, security})
+	assert.ElementsMatch(t, obj.FromPath(`io_uring/file.c`), []*Subsystem{ioUring})
+	assert.ElementsMatch(t, obj.FromPath(`security/file.c`), []*Subsystem{security})
+	assert.ElementsMatch(t, obj.FromPath(`security/selinux/file.c`), []*Subsystem{})
+	assert.ElementsMatch(t, obj.FromPath(`net/ipv6/calipso.c`), []*Subsystem{net, security})
 
 	// Verify prog matching.
 	// nolint: lll
@@ -60,10 +59,10 @@ r3 = openat$ptmx(0xffffffffffffff9c, &(0x7f0000000040), 0x8a04, 0x0)
 syz_io_uring_submit(r1, r2, &(0x7f0000000000)=@IORING_OP_READ=@pass_buffer={0x16, 0x0, 0x0, @fd_index=0x5, 0x0, 0x0}, 0x0)
 ioctl$TIOCSETD(r3, 0x5423, &(0x7f0000000580)=0x3)
 io_uring_enter(r0, 0x2ff, 0x0, 0x0, 0x0, 0x0)`)),
-		[]*entity.Subsystem{ioUring})
+		[]*Subsystem{ioUring})
 	// nolint: lll
 	assert.ElementsMatch(t, obj.FromProg([]byte(
 		`syz_mount_image$nilfs2(&(0x7f0000000000), &(0x7f0000000100)='./file0\x00', 0x100000, 0x3b, &(0x7f0000000200)=[{&(0x7f0000011240)="02", 0x1}, {&(0x7f0000012a40)="03000000", 0x4, 0x1}], 0x0, &(0x7f00000131c0), 0x1)
 openat$incfs(0xffffffffffffff9c, &(0x7f0000000000)='.pending_reads\x00', 0x4040, 0x0)`)),
-		[]*entity.Subsystem{})
+		[]*Subsystem{})
 }