aboutsummaryrefslogtreecommitdiffstats
path: root/pkg
diff options
context:
space:
mode:
Diffstat (limited to 'pkg')
-rw-r--r--pkg/ast/parser_test.go4
-rw-r--r--pkg/bisect/bisect_test.go7
-rw-r--r--pkg/build/build.go25
-rw-r--r--pkg/build/fuchsia.go2
-rw-r--r--pkg/build/linux.go11
-rw-r--r--pkg/build/netbsd.go3
-rw-r--r--pkg/compiler/compiler_test.go10
-rw-r--r--pkg/compiler/consts_test.go4
-rw-r--r--pkg/compiler/fuzz.go2
-rw-r--r--pkg/cover/report.go32
-rw-r--r--pkg/cover/report_test.go4
-rw-r--r--pkg/csource/common.go5
-rw-r--r--pkg/csource/csource.go6
-rw-r--r--pkg/csource/csource_test.go4
-rw-r--r--pkg/csource/options.go9
-rw-r--r--pkg/csource/options_test.go4
-rw-r--r--pkg/host/features.go6
-rw-r--r--pkg/host/machine_info_linux_test.go28
-rw-r--r--pkg/host/syscalls_linux.go17
-rw-r--r--pkg/host/syscalls_linux_test.go17
-rw-r--r--pkg/instance/instance.go4
-rw-r--r--pkg/instance/instance_test.go15
-rw-r--r--pkg/ipc/ipc.go2
-rw-r--r--pkg/ipc/ipc_test.go2
-rw-r--r--pkg/report/fuzz.go7
-rw-r--r--pkg/report/linux_test.go5
-rw-r--r--pkg/report/report.go16
-rw-r--r--pkg/report/report_test.go5
-rw-r--r--pkg/repro/repro_test.go3
-rw-r--r--pkg/runtest/run.go4
-rw-r--r--pkg/runtest/run_test.go10
-rw-r--r--pkg/vcs/vcs.go15
32 files changed, 152 insertions, 136 deletions
diff --git a/pkg/ast/parser_test.go b/pkg/ast/parser_test.go
index b5861b5a8..d3a9049bc 100644
--- a/pkg/ast/parser_test.go
+++ b/pkg/ast/parser_test.go
@@ -10,10 +10,12 @@ import (
"reflect"
"strings"
"testing"
+
+ "github.com/google/syzkaller/sys/targets"
)
func TestParseAll(t *testing.T) {
- files, err := filepath.Glob(filepath.Join("..", "..", "sys", "linux", "*.txt"))
+ files, err := filepath.Glob(filepath.Join("..", "..", "sys", targets.Linux, "*.txt"))
if err != nil || len(files) == 0 {
t.Fatalf("failed to read sys dir: %v", err)
}
diff --git a/pkg/bisect/bisect_test.go b/pkg/bisect/bisect_test.go
index c21548a4d..b2b7596f1 100644
--- a/pkg/bisect/bisect_test.go
+++ b/pkg/bisect/bisect_test.go
@@ -16,6 +16,7 @@ import (
"github.com/google/syzkaller/pkg/mgrconfig"
"github.com/google/syzkaller/pkg/report"
"github.com/google/syzkaller/pkg/vcs"
+ "github.com/google/syzkaller/sys/targets"
)
// testEnv will implement instance.BuilderTester. This allows us to
@@ -106,7 +107,7 @@ func createTestRepo(t *testing.T) string {
}
func runBisection(t *testing.T, baseDir string, test BisectionTest) (*Result, error) {
- r, err := vcs.NewRepo("test", "64", baseDir, vcs.OptPrecious)
+ r, err := vcs.NewRepo(targets.TestOS, targets.TestArch64, baseDir, vcs.OptPrecious)
if err != nil {
t.Fatal(err)
}
@@ -120,8 +121,8 @@ func runBisection(t *testing.T, baseDir string, test BisectionTest) (*Result, er
Fix: test.fix,
Trace: trace,
Manager: mgrconfig.Config{
- TargetOS: "test",
- TargetVMArch: "64",
+ TargetOS: targets.TestOS,
+ TargetVMArch: targets.TestArch64,
Type: "qemu",
KernelSrc: baseDir,
},
diff --git a/pkg/build/build.go b/pkg/build/build.go
index 149d8729c..9931ce0ea 100644
--- a/pkg/build/build.go
+++ b/pkg/build/build.go
@@ -16,6 +16,7 @@ import (
"github.com/google/syzkaller/pkg/osutil"
"github.com/google/syzkaller/pkg/report"
"github.com/google/syzkaller/pkg/vcs"
+ "github.com/google/syzkaller/sys/targets"
)
// Params is input arguments for the Image function.
@@ -118,17 +119,17 @@ func getBuilder(targetOS, targetArch, vmType string) (builder, error) {
vms []string
b builder
}{
- {"linux", "amd64", []string{"gvisor"}, gvisor{}},
- {"linux", "amd64", []string{"gce", "qemu"}, linux{}},
- {"linux", "ppc64le", []string{"qemu"}, linux{}},
- {"linux", "s390x", []string{"qemu"}, linux{}},
- {"fuchsia", "amd64", []string{"qemu"}, fuchsia{}},
- {"fuchsia", "arm64", []string{"qemu"}, fuchsia{}},
- {"akaros", "amd64", []string{"qemu"}, akaros{}},
- {"openbsd", "amd64", []string{"gce", "vmm"}, openbsd{}},
- {"netbsd", "amd64", []string{"gce", "qemu"}, netbsd{}},
- {"freebsd", "amd64", []string{"gce", "qemu"}, freebsd{}},
- {"test", "64", []string{"qemu"}, test{}},
+ {targets.Linux, targets.AMD64, []string{"gvisor"}, gvisor{}},
+ {targets.Linux, targets.AMD64, []string{"gce", "qemu"}, linux{}},
+ {targets.Linux, targets.PPC64LE, []string{"qemu"}, linux{}},
+ {targets.Linux, targets.S390x, []string{"qemu"}, linux{}},
+ {targets.Fuchsia, targets.AMD64, []string{"qemu"}, fuchsia{}},
+ {targets.Fuchsia, targets.ARM64, []string{"qemu"}, fuchsia{}},
+ {targets.Akaros, targets.AMD64, []string{"qemu"}, akaros{}},
+ {targets.OpenBSD, targets.AMD64, []string{"gce", "vmm"}, openbsd{}},
+ {targets.NetBSD, targets.AMD64, []string{"gce", "qemu"}, netbsd{}},
+ {targets.FreeBSD, targets.AMD64, []string{"gce", "qemu"}, freebsd{}},
+ {targets.TestOS, targets.TestArch64, []string{"qemu"}, test{}},
}
for _, s := range supported {
if targetOS == s.OS && targetArch == s.arch {
@@ -193,7 +194,7 @@ func extractRootCause(err error, OS, kernelSrc string) error {
Output: verr.Output,
guiltyFile: file,
}
- if file != "" && OS == "linux" {
+ if file != "" && OS == targets.Linux {
maintainers, err := report.GetLinuxMaintainers(kernelSrc, file)
if err != nil {
kernelErr.Output = append(kernelErr.Output, err.Error()...)
diff --git a/pkg/build/fuchsia.go b/pkg/build/fuchsia.go
index f4bb2c8b4..ea1e2dccb 100644
--- a/pkg/build/fuchsia.go
+++ b/pkg/build/fuchsia.go
@@ -33,7 +33,7 @@ func (fu fuchsia) build(params *Params) error {
return err
}
- sysTarget := targets.Get("fuchsia", params.TargetArch)
+ sysTarget := targets.Get(targets.Fuchsia, params.TargetArch)
if sysTarget == nil {
return fmt.Errorf("unsupported fuchsia arch %v", params.TargetArch)
}
diff --git a/pkg/build/linux.go b/pkg/build/linux.go
index 36f18b84f..7566eca21 100644
--- a/pkg/build/linux.go
+++ b/pkg/build/linux.go
@@ -18,6 +18,7 @@ import (
"time"
"github.com/google/syzkaller/pkg/osutil"
+ "github.com/google/syzkaller/sys/targets"
)
type linux struct{}
@@ -57,9 +58,9 @@ func (linux linux) buildKernel(params *Params) error {
// We build only zImage/bzImage as we currently don't use modules.
var target string
switch params.TargetArch {
- case "386", "amd64", "s390x":
+ case targets.I386, targets.AMD64, targets.S390x:
target = "bzImage"
- case "ppc64le":
+ case targets.PPC64LE:
target = "zImage"
}
@@ -110,11 +111,11 @@ func (linux) createImage(params *Params) error {
var kernelImage string
switch params.TargetArch {
- case "386", "amd64":
+ case targets.I386, targets.AMD64:
kernelImage = "arch/x86/boot/bzImage"
- case "ppc64le":
+ case targets.PPC64LE:
kernelImage = "arch/powerpc/boot/zImage.pseries"
- case "s390x":
+ case targets.S390x:
kernelImage = "arch/s390/boot/bzImage"
}
kernelImagePath := filepath.Join(params.KernelDir, filepath.FromSlash(kernelImage))
diff --git a/pkg/build/netbsd.go b/pkg/build/netbsd.go
index 43620c9cf..e0f4bcea0 100644
--- a/pkg/build/netbsd.go
+++ b/pkg/build/netbsd.go
@@ -16,6 +16,7 @@ import (
"github.com/google/syzkaller/pkg/mgrconfig"
"github.com/google/syzkaller/pkg/osutil"
"github.com/google/syzkaller/pkg/report"
+ "github.com/google/syzkaller/sys/targets"
"github.com/google/syzkaller/vm"
)
@@ -104,7 +105,7 @@ func (ctx netbsd) copyKernelToDisk(targetArch, vmType, outputDir, kernel string)
Image: filepath.Join(outputDir, "image"),
SSHKey: filepath.Join(outputDir, "key"),
SSHUser: "root",
- TargetOS: "netbsd",
+ TargetOS: targets.NetBSD,
TargetArch: targetArch,
TargetVMArch: targetArch,
Type: "qemu",
diff --git a/pkg/compiler/compiler_test.go b/pkg/compiler/compiler_test.go
index e5c7987d1..9bc93a519 100644
--- a/pkg/compiler/compiler_test.go
+++ b/pkg/compiler/compiler_test.go
@@ -66,11 +66,11 @@ func TestData(t *testing.T) {
// E.g. if we failed to parse descriptions, we won't run type checking at all.
// Because of this we have one file per phase.
for _, name := range []string{"errors.txt", "errors2.txt", "errors3.txt", "warnings.txt", "all.txt"} {
- for _, arch := range []string{"32_shmem", "64"} {
+ for _, arch := range []string{targets.TestArch32Shmem, targets.TestArch64} {
name, arch := name, arch
t.Run(fmt.Sprintf("%v/%v", name, arch), func(t *testing.T) {
t.Parallel()
- target := targets.List["test"][arch]
+ target := targets.List[targets.TestOS][arch]
fileName := filepath.Join("testdata", name)
em := ast.NewErrorMatcher(t, fileName)
astDesc := ast.Parse(em.Data, name, em.ErrorHandler)
@@ -182,7 +182,7 @@ s2 {
if desc == nil {
t.Fatal("failed to parse")
}
- p := Compile(desc, map[string]uint64{"SYS_foo": 1}, targets.List["test"]["64"], eh)
+ p := Compile(desc, map[string]uint64{"SYS_foo": 1}, targets.List[targets.TestOS][targets.TestArch64], eh)
if p == nil {
t.Fatal("failed to compile")
}
@@ -201,7 +201,7 @@ func TestCollectUnusedError(t *testing.T) {
t.Fatal("failed to parse")
}
- _, err := CollectUnused(desc, targets.List["test"]["64"], nopErrorHandler)
+ _, err := CollectUnused(desc, targets.List[targets.TestOS][targets.TestArch64], nopErrorHandler)
if err == nil {
t.Fatal("CollectUnused should have failed but didn't")
}
@@ -252,7 +252,7 @@ func TestCollectUnused(t *testing.T) {
t.Fatalf("Test %d: failed to parse", i)
}
- nodes, err := CollectUnused(desc, targets.List["test"]["64"], nil)
+ nodes, err := CollectUnused(desc, targets.List[targets.TestOS][targets.TestArch64], nil)
if err != nil {
t.Fatalf("Test %d: CollectUnused failed: %v", i, err)
}
diff --git a/pkg/compiler/consts_test.go b/pkg/compiler/consts_test.go
index 77a124b04..685525bc9 100644
--- a/pkg/compiler/consts_test.go
+++ b/pkg/compiler/consts_test.go
@@ -23,7 +23,7 @@ func TestExtractConsts(t *testing.T) {
if desc == nil {
t.Fatalf("failed to parse input")
}
- target := targets.List["linux"]["amd64"]
+ target := targets.List[targets.Linux][targets.AMD64]
fileInfo := ExtractConsts(desc, target, func(pos ast.Pos, msg string) {
t.Fatalf("%v: %v", pos, msg)
})
@@ -69,7 +69,7 @@ func TestConstErrors(t *testing.T) {
em.DumpErrors()
t.Fatalf("parsing failed")
}
- target := targets.List["linux"]["amd64"]
+ target := targets.List[targets.Linux][targets.AMD64]
ExtractConsts(desc, target, em.ErrorHandler)
em.Check()
}
diff --git a/pkg/compiler/fuzz.go b/pkg/compiler/fuzz.go
index 3f888cdbd..ecb97834b 100644
--- a/pkg/compiler/fuzz.go
+++ b/pkg/compiler/fuzz.go
@@ -22,6 +22,6 @@ func Fuzz(data []byte) int {
}
var (
- fuzzTarget = targets.Get("test", "64")
+ fuzzTarget = targets.Get(targets.TestOS, targets.TestArch64)
fuzzConsts = map[string]uint64{"A": 1, "B": 2, "C": 3, "SYS_A": 4, "SYS_B": 5, "SYS_C": 6}
)
diff --git a/pkg/cover/report.go b/pkg/cover/report.go
index f61c48d11..4e6b7cd0d 100644
--- a/pkg/cover/report.go
+++ b/pkg/cover/report.go
@@ -85,7 +85,7 @@ func MakeReportGenerator(target *targets.Target, kernelObject, srcDir, buildDir
errc <- err
return
}
- if target.Arch == "amd64" {
+ if target.Arch == targets.AMD64 {
coverPoints, err = readCoverPoints(file, tracePC)
} else {
coverPoints, err = objdump(target, kernelObject)
@@ -834,23 +834,23 @@ func parseFile(fn string) ([][]byte, error) {
func PreviousInstructionPC(target *targets.Target, pc uint64) uint64 {
switch target.Arch {
- case "amd64":
+ case targets.AMD64:
return pc - 5
- case "386":
+ case targets.I386:
return pc - 5
- case "arm64":
+ case targets.ARM64:
return pc - 4
- case "arm":
+ case targets.ARM:
// THUMB instructions are 2 or 4 bytes with low bit set.
// ARM instructions are always 4 bytes.
return (pc - 3) & ^uint64(1)
- case "ppc64le":
+ case targets.PPC64LE:
return pc - 4
- case "mips64le":
+ case targets.MIPS64LE:
return pc - 8
- case "s390x":
+ case targets.S390x:
return pc - 6
- case "riscv64":
+ case targets.RiscV64:
return pc - 4
default:
panic(fmt.Sprintf("unknown arch %q", target.Arch))
@@ -860,16 +860,16 @@ func PreviousInstructionPC(target *targets.Target, pc uint64) uint64 {
func archCallInsn(target *targets.Target) ([][]byte, [][]byte) {
callName := [][]byte{[]byte(" <__sanitizer_cov_trace_pc>")}
switch target.Arch {
- case "386":
+ case targets.I386:
// c1000102: call c10001f0 <__sanitizer_cov_trace_pc>
return [][]byte{[]byte("\tcall ")}, callName
- case "arm64":
+ case targets.ARM64:
// ffff0000080d9cc0: bl ffff00000820f478 <__sanitizer_cov_trace_pc>
return [][]byte{[]byte("\tbl\t")}, callName
- case "arm":
+ case targets.ARM:
// 8010252c: bl 801c3280 <__sanitizer_cov_trace_pc>
return [][]byte{[]byte("\tbl\t")}, callName
- case "ppc64le":
+ case targets.PPC64LE:
// c00000000006d904: bl c000000000350780 <.__sanitizer_cov_trace_pc>
// This is only known to occur in the test:
// 838: bl 824 <__sanitizer_cov_trace_pc+0x8>
@@ -880,15 +880,15 @@ func archCallInsn(target *targets.Target) ([][]byte, [][]byte) {
[]byte("<__sanitizer_cov_trace_pc+0x8>"),
[]byte(" <.__sanitizer_cov_trace_pc>"),
}
- case "mips64le":
+ case targets.MIPS64LE:
// ffffffff80100420: jal ffffffff80205880 <__sanitizer_cov_trace_pc>
// This is only known to occur in the test:
// b58: bal b30 <__sanitizer_cov_trace_pc>
return [][]byte{[]byte("\tjal\t"), []byte("\tbal\t")}, callName
- case "s390x":
+ case targets.S390x:
// 1001de: brasl %r14,2bc090 <__sanitizer_cov_trace_pc>
return [][]byte{[]byte("\tbrasl\t")}, callName
- case "riscv64":
+ case targets.RiscV64:
// ffffffe000200018: jal ra,ffffffe0002935b0 <__sanitizer_cov_trace_pc>
// ffffffe0000010da: jalr 1242(ra) # ffffffe0002935b0 <__sanitizer_cov_trace_pc>
return [][]byte{[]byte("\tjal\t"), []byte("\tjalr\t")}, callName
diff --git a/pkg/cover/report_test.go b/pkg/cover/report_test.go
index 7748c3fab..b48ea2370 100644
--- a/pkg/cover/report_test.go
+++ b/pkg/cover/report_test.go
@@ -68,7 +68,7 @@ func TestReportGenerator(t *testing.T) {
}
t.Parallel()
for os, arches := range targets.List {
- if os == "test" {
+ if os == targets.TestOS {
continue
}
for _, target := range arches {
@@ -135,7 +135,7 @@ void __sanitizer_cov_trace_pc() { printf("%llu", (long long)__builtin_return_add
errText = strings.ReplaceAll(errText, "‘", "'")
errText = strings.ReplaceAll(errText, "’", "'")
if strings.Contains(errText, "error: unrecognized command line option '-fsanitize-coverage=trace-pc'") &&
- (os.Getenv("SYZ_BIG_ENV") == "" || target.OS == "akaros") {
+ (os.Getenv("SYZ_BIG_ENV") == "" || target.OS == targets.Akaros) {
t.Skip("skipping test, -fsanitize-coverage=trace-pc is not supported")
}
t.Fatal(err)
diff --git a/pkg/csource/common.go b/pkg/csource/common.go
index 242190180..0dd76cfbb 100644
--- a/pkg/csource/common.go
+++ b/pkg/csource/common.go
@@ -19,11 +19,6 @@ import (
)
const (
- linux = "linux"
- freebsd = "freebsd"
- openbsd = "openbsd"
- netbsd = "netbsd"
-
sandboxNone = "none"
sandboxSetuid = "setuid"
sandboxNamespace = "namespace"
diff --git a/pkg/csource/csource.go b/pkg/csource/csource.go
index 488d277e1..49babbf41 100644
--- a/pkg/csource/csource.go
+++ b/pkg/csource/csource.go
@@ -166,7 +166,7 @@ func (ctx *context) generateSyscallDefines() string {
fmt.Fprintf(buf, "#define %v%v %v\n", prefix, name, ctx.calls[name])
fmt.Fprintf(buf, "#endif\n")
}
- if ctx.target.OS == "linux" && ctx.target.PtrSize == 4 {
+ if ctx.target.OS == targets.Linux && ctx.target.PtrSize == 4 {
// This is a dirty hack.
// On 32-bit linux mmap translated to old_mmap syscall which has a different signature.
// mmap2 has the right signature. syz-extract translates mmap to mmap2, do the same here.
@@ -403,7 +403,7 @@ func (ctx *context) copyinVal(w *bytes.Buffer, addr, size uint64, val string, bf
}
func (ctx *context) copyout(w *bytes.Buffer, call prog.ExecCall, resCopyout bool) {
- if ctx.sysTarget.OS == "fuchsia" {
+ if ctx.sysTarget.OS == targets.Fuchsia {
// On fuchsia we have real system calls that return ZX_OK on success,
// and libc calls that are casted to function returning intptr_t,
// as the result int -1 is returned as 0x00000000ffffffff rather than full -1.
@@ -523,7 +523,7 @@ func (ctx *context) hoistIncludes(result []byte) []byte {
sortedBottom = append(sortedBottom, include)
} else if strings.Contains(include, "<netinet/if_ether.h>") {
sortedBottom = append(sortedBottom, include)
- } else if ctx.target.OS == freebsd && strings.Contains(include, "<sys/types.h>") {
+ } else if ctx.target.OS == targets.FreeBSD && strings.Contains(include, "<sys/types.h>") {
sortedTop = append(sortedTop, include)
} else {
sorted = append(sorted, include)
diff --git a/pkg/csource/csource_test.go b/pkg/csource/csource_test.go
index 3eec99792..f6d04b35c 100644
--- a/pkg/csource/csource_test.go
+++ b/pkg/csource/csource_test.go
@@ -136,7 +136,7 @@ func TestSysTests(t *testing.T) {
}
t.Run(target.OS+"/"+target.Arch, func(t *testing.T) {
t.Parallel()
- dir := filepath.Join("..", "..", "sys", target.OS, "test")
+ dir := filepath.Join("..", "..", "sys", target.OS, targets.TestOS)
if !osutil.IsExist(dir) {
return
}
@@ -173,7 +173,7 @@ func TestSysTests(t *testing.T) {
func TestExecutorMacros(t *testing.T) {
// Ensure that executor does not mis-spell any of the SYZ_* macros.
- target, _ := prog.GetTarget("test", "64")
+ target, _ := prog.GetTarget(targets.TestOS, targets.TestArch64)
p := target.Generate(rand.NewSource(0), 1, target.DefaultChoiceTable())
expected := commonDefines(p, Options{})
expected["SYZ_EXECUTOR"] = true
diff --git a/pkg/csource/options.go b/pkg/csource/options.go
index ba74eb37c..7f2bc5109 100644
--- a/pkg/csource/options.go
+++ b/pkg/csource/options.go
@@ -12,6 +12,7 @@ import (
"strings"
"github.com/google/syzkaller/pkg/mgrconfig"
+ "github.com/google/syzkaller/sys/targets"
)
// Options control various aspects of source generation.
@@ -113,10 +114,10 @@ func (opts Options) Check(OS string) error {
}
func (opts Options) checkLinuxOnly(OS string) error {
- if OS == linux {
+ if OS == targets.Linux {
return nil
}
- if opts.NetInjection && !(OS == openbsd || OS == freebsd || OS == netbsd) {
+ if opts.NetInjection && !(OS == targets.OpenBSD || OS == targets.FreeBSD || OS == targets.NetBSD) {
return fmt.Errorf("option NetInjection is not supported on %v", OS)
}
if opts.NetDevices {
@@ -150,7 +151,7 @@ func (opts Options) checkLinuxOnly(OS string) error {
return fmt.Errorf("option Wifi is not supported on %v", OS)
}
if opts.Sandbox == sandboxNamespace ||
- (opts.Sandbox == sandboxSetuid && !(OS == openbsd || OS == freebsd || OS == netbsd)) ||
+ (opts.Sandbox == sandboxSetuid && !(OS == targets.OpenBSD || OS == targets.FreeBSD || OS == targets.NetBSD)) ||
opts.Sandbox == sandboxAndroid {
return fmt.Errorf("option Sandbox=%v is not supported on %v", opts.Sandbox, OS)
}
@@ -183,7 +184,7 @@ func DefaultOpts(cfg *mgrconfig.Config) Options {
HandleSegv: true,
Repro: true,
}
- if cfg.TargetOS != linux {
+ if cfg.TargetOS != targets.Linux {
opts.NetInjection = false
opts.NetDevices = false
opts.NetReset = false
diff --git a/pkg/csource/options_test.go b/pkg/csource/options_test.go
index 1c403ae06..43cffd1d5 100644
--- a/pkg/csource/options_test.go
+++ b/pkg/csource/options_test.go
@@ -7,10 +7,12 @@ import (
"fmt"
"reflect"
"testing"
+
+ "github.com/google/syzkaller/sys/targets"
)
func TestParseOptions(t *testing.T) {
- for _, opts := range allOptionsSingle("linux") {
+ for _, opts := range allOptionsSingle(targets.Linux) {
data := opts.Serialize()
got, err := DeserializeOptions(data)
if err != nil {
diff --git a/pkg/host/features.go b/pkg/host/features.go
index 8b78637fb..14d4f5c89 100644
--- a/pkg/host/features.go
+++ b/pkg/host/features.go
@@ -102,7 +102,7 @@ func Setup(target *prog.Target, features *Features, featureFlags csource.Feature
if features[FeatureFault].Enabled {
args = append(args, "fault")
}
- if target.OS == "linux" && featureFlags["binfmt_misc"].Enabled {
+ if target.OS == targets.Linux && featureFlags["binfmt_misc"].Enabled {
args = append(args, "binfmt_misc")
}
if features[FeatureKCSAN].Enabled {
@@ -117,6 +117,6 @@ func Setup(target *prog.Target, features *Features, featureFlags csource.Feature
func noHostChecks(target *prog.Target) bool {
// HostFuzzer targets can't run Go binaries on the targets,
- // so we actually run on the host on another OS. The same for "test" OS.
- return targets.Get(target.OS, target.Arch).HostFuzzer || target.OS == "test"
+ // so we actually run on the host on another OS. The same for targets.TestOS OS.
+ return targets.Get(target.OS, target.Arch).HostFuzzer || target.OS == targets.TestOS
}
diff --git a/pkg/host/machine_info_linux_test.go b/pkg/host/machine_info_linux_test.go
index f09666659..5075751d5 100644
--- a/pkg/host/machine_info_linux_test.go
+++ b/pkg/host/machine_info_linux_test.go
@@ -10,6 +10,8 @@ import (
"runtime"
"strings"
"testing"
+
+ "github.com/google/syzkaller/sys/targets"
)
func TestReadCPUInfoLinux(t *testing.T) {
@@ -42,14 +44,14 @@ func checkCPUInfo(t *testing.T, data []byte, arch string) {
keys[key] = true
}
importantKeys := map[string][]string{
- "ppc64le": {"cpu", "revision", "platform", "model", "machine"},
- "amd64": {"vendor_id", "model", "flags"},
- "s390x": {"vendor_id", "processor 0", "features"},
- "386": {"vendor_id", "model", "flags"},
- "arm64": {"CPU implementer", "CPU part", "Features"},
- "arm": {"CPU implementer", "CPU part", "Features"},
- "mips64le": {"system type", "cpu model", "ASEs implemented"},
- "riscv64": {"processor", "isa", "mmu"},
+ targets.PPC64LE: {"cpu", "revision", "platform", "model", "machine"},
+ targets.AMD64: {"vendor_id", "model", "flags"},
+ targets.S390x: {"vendor_id", "processor 0", "features"},
+ targets.I386: {"vendor_id", "model", "flags"},
+ targets.ARM64: {"CPU implementer", "CPU part", "Features"},
+ targets.ARM: {"CPU implementer", "CPU part", "Features"},
+ targets.MIPS64LE: {"system type", "cpu model", "ASEs implemented"},
+ targets.RiscV64: {"processor", "isa", "mmu"},
}
archKeys := importantKeys[arch]
if len(archKeys) == 0 {
@@ -149,7 +151,7 @@ type cannedTest struct {
// nolint:lll
var cpuInfoTests = []cannedTest{
{
- arch: "ppc64le",
+ arch: targets.PPC64LE,
data: `
processor : 0
cpu : POWER8 (architected), altivec supported
@@ -179,7 +181,7 @@ MMU : Hash
`,
},
{
- arch: "ppc64le",
+ arch: targets.PPC64LE,
data: `
processor : 0
cpu : POWER8 (architected), altivec supported
@@ -201,7 +203,7 @@ MMU : Hash
`,
},
{
- arch: "ppc64le",
+ arch: targets.PPC64LE,
data: `
processor : 0
cpu : POWER8E, altivec supported
@@ -242,7 +244,7 @@ MMU : Hash
`,
},
{
- arch: "amd64",
+ arch: targets.AMD64,
data: `
processor : 0
vendor_id : GenuineIntel
@@ -302,7 +304,7 @@ power management:
`,
},
{
- arch: "amd64",
+ arch: targets.AMD64,
data: `
processor : 0
vendor_id : GenuineIntel
diff --git a/pkg/host/syscalls_linux.go b/pkg/host/syscalls_linux.go
index ff41da68b..16cfbfa46 100644
--- a/pkg/host/syscalls_linux.go
+++ b/pkg/host/syscalls_linux.go
@@ -18,6 +18,7 @@ import (
"github.com/google/syzkaller/pkg/osutil"
"github.com/google/syzkaller/prog"
+ "github.com/google/syzkaller/sys/targets"
)
func isSupported(c *prog.Syscall, target *prog.Target, sandbox string) (bool, string) {
@@ -74,17 +75,17 @@ func parseKallsyms(kallsyms []byte, arch string) map[string]bool {
set := make(map[string]bool)
var re *regexp.Regexp
switch arch {
- case "386", "amd64":
+ case targets.I386, targets.AMD64:
re = regexp.MustCompile(` T (__ia32_|__x64_)?sys_([^\n]+)\n`)
- case "arm", "arm64":
+ case targets.ARM, targets.ARM64:
re = regexp.MustCompile(` T (__arm64_)?sys_([^\n]+)\n`)
- case "ppc64le":
+ case targets.PPC64LE:
re = regexp.MustCompile(` T ()?sys_([^\n]+)\n`)
- case "mips64le":
+ case targets.MIPS64LE:
re = regexp.MustCompile(` T sys_(mips_)?([^\n]+)\n`)
- case "s390x":
+ case targets.S390x:
re = regexp.MustCompile(` T (__s390_|__s390x_)?sys_([^\n]+)\n`)
- case "riscv64":
+ case targets.RiscV64:
re = regexp.MustCompile(` T sys_(riscv_)?([^\n]+)\n`)
default:
panic("unsupported arch for kallsyms parsing")
@@ -191,11 +192,11 @@ func isWifiEmulationSupported(c *prog.Syscall, target *prog.Target, sandbox stri
func isSyzKvmSetupCPUSupported(c *prog.Syscall, target *prog.Target, sandbox string) (bool, string) {
switch c.Name {
case "syz_kvm_setup_cpu$x86":
- if runtime.GOARCH == "amd64" || runtime.GOARCH == "386" {
+ if runtime.GOARCH == targets.AMD64 || runtime.GOARCH == targets.I386 {
return true, ""
}
case "syz_kvm_setup_cpu$arm64":
- if runtime.GOARCH == "arm64" {
+ if runtime.GOARCH == targets.ARM64 {
return true, ""
}
}
diff --git a/pkg/host/syscalls_linux_test.go b/pkg/host/syscalls_linux_test.go
index 3ce2e3517..5d4f60082 100644
--- a/pkg/host/syscalls_linux_test.go
+++ b/pkg/host/syscalls_linux_test.go
@@ -11,11 +11,12 @@ import (
"testing"
"github.com/google/syzkaller/prog"
+ "github.com/google/syzkaller/sys/targets"
)
func TestSupportedSyscalls(t *testing.T) {
t.Parallel()
- target, err := prog.GetTarget("linux", runtime.GOARCH)
+ target, err := prog.GetTarget(targets.Linux, runtime.GOARCH)
if err != nil {
t.Fatal(err)
}
@@ -58,7 +59,7 @@ func TestKallsymsParse(t *testing.T) {
SupportedSyscalls []string
}{
{
- "amd64",
+ targets.AMD64,
[]byte(`
ffffffff817cdcc0 T __sys_bind
ffffffff817cdda0 T __x64_sys_bind
@@ -74,7 +75,7 @@ ffffffff817ce0a0 T __ia32_sys_accept4
[]string{"bind", "listen", "accept4"},
},
{
- "arm64",
+ targets.ARM64,
[]byte(`
ffff000010a3ddf8 T __sys_bind
ffff000010a3def8 T __arm64_sys_bind
@@ -87,7 +88,7 @@ ffff000010a3e1f0 T __arm64_sys_accept4
[]string{"bind", "listen", "accept4"},
},
{
- "ppc64le",
+ targets.PPC64LE,
[]byte(`
c0000000011ec810 T __sys_bind
c0000000011eca10 T sys_bind
@@ -103,7 +104,7 @@ c0000000011ed050 T __se_sys_accept4
[]string{"bind", "listen", "accept4"},
},
{
- "arm",
+ targets.ARM,
[]byte(`
c037c67c T __se_sys_setfsuid
c037c694 T __sys_setfsgid
@@ -118,7 +119,7 @@ c037c7f8 T sys_getppid
},
// Test kallsymsRenameMap.
{
- "ppc64le",
+ targets.PPC64LE,
[]byte(`
c00000000037eb00 T sys_newstat
`),
@@ -126,7 +127,7 @@ c00000000037eb00 T sys_newstat
[]string{"stat"},
},
{
- "s390x",
+ targets.S390x,
[]byte(`
0000000000e4f760 T __sys_bind
0000000000e4f8e8 T __s390_sys_bind
@@ -145,7 +146,7 @@ c00000000037eb00 T sys_newstat
[]string{"bind", "listen", "accept4"},
},
{
- "riscv64",
+ targets.RiscV64,
[]byte(`
ffffffe0005c9b02 T __sys_bind
ffffffe0005c9ba0 T sys_bind
diff --git a/pkg/instance/instance.go b/pkg/instance/instance.go
index b5cbd3bd2..467998a60 100644
--- a/pkg/instance/instance.go
+++ b/pkg/instance/instance.go
@@ -318,7 +318,7 @@ func (inst *inst) testInstance() error {
}
}
- cmd := OldFuzzerCmd(fuzzerBin, executorCmd, "test", inst.cfg.TargetOS, inst.cfg.TargetArch, fwdAddr,
+ cmd := OldFuzzerCmd(fuzzerBin, executorCmd, targets.TestOS, inst.cfg.TargetOS, inst.cfg.TargetArch, fwdAddr,
inst.cfg.Sandbox, 0, inst.cfg.Cover, true)
outc, errc, err := inst.vm.Run(10*time.Minute, nil, cmd)
if err != nil {
@@ -470,7 +470,7 @@ func ExecprogCmd(execprog, executor, OS, arch, sandbox string, repeat, threaded,
}
var MakeBin = func() string {
- if runtime.GOOS == "freebsd" || runtime.GOOS == "openbsd" {
+ if runtime.GOOS == targets.FreeBSD || runtime.GOOS == targets.OpenBSD {
return "gmake"
}
return "make"
diff --git a/pkg/instance/instance_test.go b/pkg/instance/instance_test.go
index 5b9a28404..e19f91faf 100644
--- a/pkg/instance/instance_test.go
+++ b/pkg/instance/instance_test.go
@@ -9,6 +9,8 @@ import (
"runtime"
"strings"
"testing"
+
+ "github.com/google/syzkaller/sys/targets"
)
func TestFuzzerCmd(t *testing.T) {
@@ -29,7 +31,7 @@ func TestFuzzerCmd(t *testing.T) {
flagSandbox := flags.String("sandbox", "none", "sandbox for fuzzing (none/setuid/namespace)")
flagDebug := flags.Bool("debug", false, "debug output from executor")
flagV := flags.Int("v", 0, "verbosity")
- cmdLine := OldFuzzerCmd(os.Args[0], "/myexecutor", "myname", "linux", "386", "localhost:1234",
+ cmdLine := OldFuzzerCmd(os.Args[0], "/myexecutor", "myname", targets.Linux, targets.I386, "localhost:1234",
"namespace", 3, true, true)
args := strings.Split(cmdLine, " ")[1:]
if err := flags.Parse(args); err != nil {
@@ -38,8 +40,8 @@ func TestFuzzerCmd(t *testing.T) {
if *flagName != "myname" {
t.Errorf("bad name: %q, want: %q", *flagName, "myname")
}
- if *flagArch != "386" {
- t.Errorf("bad arch: %q, want: %q", *flagArch, "386")
+ if *flagArch != targets.I386 {
+ t.Errorf("bad arch: %q, want: %q", *flagArch, targets.I386)
}
if *flagManager != "localhost:1234" {
t.Errorf("bad manager: %q, want: %q", *flagManager, "localhost:1234")
@@ -91,7 +93,8 @@ func TestExecprogCmd(t *testing.T) {
flagCollide := flags.Bool("collide", true, "collide syscalls to provoke data races")
flagSignal := flags.Bool("cover", false, "collect feedback signals (coverage)")
flagSandbox := flags.String("sandbox", "none", "sandbox for fuzzing (none/setuid/namespace)")
- cmdLine := ExecprogCmd(os.Args[0], "/myexecutor", "freebsd", "386", "namespace", true, false, false, 7, 2, 3, "myprog")
+ cmdLine := ExecprogCmd(os.Args[0], "/myexecutor", targets.FreeBSD, targets.I386,
+ "namespace", true, false, false, 7, 2, 3, "myprog")
args := strings.Split(cmdLine, " ")[1:]
if err := flags.Parse(args); err != nil {
t.Fatal(err)
@@ -102,8 +105,8 @@ func TestExecprogCmd(t *testing.T) {
if *flagOS != runtime.GOOS {
t.Errorf("bad os: %q, want: %q", *flagOS, runtime.GOOS)
}
- if *flagArch != "386" {
- t.Errorf("bad arch: %q, want: %q", *flagArch, "386")
+ if *flagArch != targets.I386 {
+ t.Errorf("bad arch: %q, want: %q", *flagArch, targets.I386)
}
if *flagRepeat != 0 {
t.Errorf("bad repeat: %v, want: %v", *flagRepeat, 0)
diff --git a/pkg/ipc/ipc.go b/pkg/ipc/ipc.go
index ffa8a4e6f..06b39af9d 100644
--- a/pkg/ipc/ipc.go
+++ b/pkg/ipc/ipc.go
@@ -268,7 +268,7 @@ func (env *Env) Exec(opts *ExecOpts, p *prog.Prog) (output []byte, info *ProgInf
atomic.AddUint64(&env.StatExecs, 1)
if env.cmd == nil {
- if p.Target.OS != "test" && targets.Get(p.Target.OS, p.Target.Arch).HostFuzzer {
+ if p.Target.OS != targets.TestOS && targets.Get(p.Target.OS, p.Target.Arch).HostFuzzer {
// The executor is actually ssh,
// starting them too frequently leads to timeouts.
<-rateLimit.C
diff --git a/pkg/ipc/ipc_test.go b/pkg/ipc/ipc_test.go
index c8210cdcd..e7c9aa0f8 100644
--- a/pkg/ipc/ipc_test.go
+++ b/pkg/ipc/ipc_test.go
@@ -73,7 +73,7 @@ func TestExecutor(t *testing.T) {
bin := buildExecutor(t, target)
defer os.Remove(bin)
// qemu-user may allow us to run some cross-arch binaries.
- if _, err := osutil.RunCmd(time.Minute, "", bin, "test"); err != nil {
+ if _, err := osutil.RunCmd(time.Minute, "", bin, targets.TestOS); err != nil {
if sysTarget.Arch == runtime.GOOS || sysTarget.VMArch == runtime.GOOS {
t.Fatal(err)
}
diff --git a/pkg/report/fuzz.go b/pkg/report/fuzz.go
index 0db602491..f812f78eb 100644
--- a/pkg/report/fuzz.go
+++ b/pkg/report/fuzz.go
@@ -7,6 +7,7 @@ import (
"fmt"
"github.com/google/syzkaller/pkg/mgrconfig"
+ "github.com/google/syzkaller/sys/targets"
)
func Fuzz(data []byte) int {
@@ -32,7 +33,7 @@ func Fuzz(data []byte) int {
if len(rep.Output) == 0 {
panic(fmt.Sprintf("%v: len(Output) == 0", typ))
}
- if os == "fuchsia" {
+ if os == targets.Fuchsia {
// Fuchsia has Start/End/SkipPos set incorrectly because it symbolizes before parsing.
continue
}
@@ -66,12 +67,12 @@ func Fuzz(data []byte) int {
var fuzzReporters = func() map[string]Reporter {
reporters := make(map[string]Reporter)
for os := range ctors {
- if os == "windows" {
+ if os == targets.Windows {
continue
}
cfg := &mgrconfig.Config{
TargetOS: os,
- TargetArch: "amd64",
+ TargetArch: targets.AMD64,
}
reporter, err := NewReporter(cfg)
if err != nil {
diff --git a/pkg/report/linux_test.go b/pkg/report/linux_test.go
index 2e31ee755..d1b343efe 100644
--- a/pkg/report/linux_test.go
+++ b/pkg/report/linux_test.go
@@ -9,12 +9,13 @@ import (
"github.com/google/syzkaller/pkg/mgrconfig"
"github.com/google/syzkaller/pkg/symbolizer"
+ "github.com/google/syzkaller/sys/targets"
)
func TestLinuxIgnores(t *testing.T) {
cfg := &mgrconfig.Config{
- TargetOS: "linux",
- TargetArch: "amd64",
+ TargetOS: targets.Linux,
+ TargetArch: targets.AMD64,
}
reporter, err := NewReporter(cfg)
if err != nil {
diff --git a/pkg/report/report.go b/pkg/report/report.go
index ae618d6e6..13f76e67d 100644
--- a/pkg/report/report.go
+++ b/pkg/report/report.go
@@ -132,14 +132,14 @@ const (
)
var ctors = map[string]fn{
- "akaros": ctorAkaros,
- "linux": ctorLinux,
- "gvisor": ctorGvisor,
- "freebsd": ctorFreebsd,
- "netbsd": ctorNetbsd,
- "openbsd": ctorOpenbsd,
- "fuchsia": ctorFuchsia,
- "windows": ctorStub,
+ targets.Akaros: ctorAkaros,
+ targets.Linux: ctorLinux,
+ "gvisor": ctorGvisor,
+ targets.FreeBSD: ctorFreebsd,
+ targets.NetBSD: ctorNetbsd,
+ targets.OpenBSD: ctorOpenbsd,
+ targets.Fuchsia: ctorFuchsia,
+ targets.Windows: ctorStub,
}
type config struct {
diff --git a/pkg/report/report_test.go b/pkg/report/report_test.go
index 1545a44e9..eebbb4c22 100644
--- a/pkg/report/report_test.go
+++ b/pkg/report/report_test.go
@@ -16,6 +16,7 @@ import (
"github.com/google/syzkaller/pkg/mgrconfig"
"github.com/google/syzkaller/pkg/osutil"
+ "github.com/google/syzkaller/sys/targets"
)
var flagUpdate = flag.Bool("update", false, "update test files accordingly to current results")
@@ -303,12 +304,12 @@ func testGuiltyFile(t *testing.T, reporter Reporter, fn string) {
func forEachFile(t *testing.T, dir string, fn func(t *testing.T, reporter Reporter, fn string)) {
for os := range ctors {
- if os == "windows" {
+ if os == targets.Windows {
continue // not implemented
}
cfg := &mgrconfig.Config{
TargetOS: os,
- TargetArch: "amd64",
+ TargetArch: targets.AMD64,
}
reporter, err := NewReporter(cfg)
if err != nil {
diff --git a/pkg/repro/repro_test.go b/pkg/repro/repro_test.go
index 3fd9eb1b3..9b639cd7d 100644
--- a/pkg/repro/repro_test.go
+++ b/pkg/repro/repro_test.go
@@ -11,6 +11,7 @@ import (
"github.com/google/syzkaller/pkg/csource"
"github.com/google/syzkaller/prog"
+ "github.com/google/syzkaller/sys/targets"
)
func initTest(t *testing.T) (*rand.Rand, int) {
@@ -92,7 +93,7 @@ func TestSimplifies(t *testing.T) {
}
var check func(opts csource.Options, i int)
check = func(opts csource.Options, i int) {
- if err := opts.Check("linux"); err != nil {
+ if err := opts.Check(targets.Linux); err != nil {
t.Fatalf("opts are invalid: %v", err)
}
if i == len(cSimplifies) {
diff --git a/pkg/runtest/run.go b/pkg/runtest/run.go
index 2352028fe..8366b8fb3 100644
--- a/pkg/runtest/run.go
+++ b/pkg/runtest/run.go
@@ -430,7 +430,7 @@ func (ctx *Context) createCTest(p *prog.Prog, sandbox string, threaded bool, tim
Sandbox: sandbox,
UseTmpDir: true,
HandleSegv: true,
- Cgroups: p.Target.OS == "linux" && sandbox != "",
+ Cgroups: p.Target.OS == targets.Linux && sandbox != "",
Trace: true,
}
if sandbox != "" {
@@ -512,7 +512,7 @@ func checkCallResult(req *RunRequest, isC bool, run, call int, info *ipc.ProgInf
continue
}
}
- if runtime.GOOS == "freebsd" && flag == ipc.CallBlocked {
+ if runtime.GOOS == targets.FreeBSD && flag == ipc.CallBlocked {
// Blocking detection is flaky on freebsd.
// TODO(dvyukov): try to increase the timeout in executor to make it non-flaky.
continue
diff --git a/pkg/runtest/run_test.go b/pkg/runtest/run_test.go
index e4712033e..d72f5940e 100644
--- a/pkg/runtest/run_test.go
+++ b/pkg/runtest/run_test.go
@@ -26,12 +26,12 @@ var flagFilter = flag.String("filter", "", "prefix to match test file names")
func Test(t *testing.T) {
switch runtime.GOOS {
- case "openbsd":
+ case targets.OpenBSD:
t.Skipf("broken on %v", runtime.GOOS)
}
// Test only one target in short mode (each takes 5+ seconds to run).
- shortTarget := targets.Get("test", "64")
- for _, sysTarget := range targets.List["test"] {
+ shortTarget := targets.Get(targets.TestOS, targets.TestArch64)
+ for _, sysTarget := range targets.List[targets.TestOS] {
if testing.Short() && sysTarget != shortTarget {
continue
}
@@ -80,7 +80,7 @@ func test(t *testing.T, sysTarget *targets.Target) {
}
}()
ctx := &Context{
- Dir: filepath.Join("..", "..", "sys", target.OS, "test"),
+ Dir: filepath.Join("..", "..", "sys", target.OS, targets.TestOS),
Target: target,
Tests: *flagFilter,
Features: features,
@@ -100,7 +100,7 @@ func test(t *testing.T, sysTarget *targets.Target) {
func TestParsing(t *testing.T) {
for OS, arches := range targets.List {
- dir := filepath.Join("..", "..", "sys", OS, "test")
+ dir := filepath.Join("..", "..", "sys", OS, targets.TestOS)
if !osutil.IsExist(dir) {
continue
}
diff --git a/pkg/vcs/vcs.go b/pkg/vcs/vcs.go
index 4185bf165..df3099225 100644
--- a/pkg/vcs/vcs.go
+++ b/pkg/vcs/vcs.go
@@ -16,6 +16,7 @@ import (
"github.com/google/syzkaller/dashboard/dashapi"
"github.com/google/syzkaller/pkg/osutil"
+ "github.com/google/syzkaller/sys/targets"
)
type RecipientType int
@@ -168,19 +169,19 @@ const (
func NewRepo(os, vm, dir string, opts ...RepoOpt) (Repo, error) {
switch os {
- case "linux":
+ case targets.Linux:
return newLinux(dir, opts), nil
- case "akaros":
+ case targets.Akaros:
return newAkaros(dir, opts), nil
- case "fuchsia":
+ case targets.Fuchsia:
return newFuchsia(dir, opts), nil
- case "openbsd":
+ case targets.OpenBSD:
return newGit(dir, nil, opts), nil
- case "netbsd":
+ case targets.NetBSD:
return newGit(dir, nil, opts), nil
- case "freebsd":
+ case targets.FreeBSD:
return newGit(dir, nil, opts), nil
- case "test":
+ case targets.TestOS:
return newTestos(dir, opts), nil
}
return nil, fmt.Errorf("vcs is unsupported for %v", os)
generated by ggit (джигит) mrf-deployment (git 2.46.0) at 2026-03-11 21:40:52 +0000