From e6e35dba937599d098fc034eff2686e5ddc409e9 Mon Sep 17 00:00:00 2001 From: Dmitry Vyukov Date: Mon, 26 Oct 2020 10:51:06 +0100 Subject: [PATCH] sys/targets: add OS/Arch name consts We use strings to identify OS/Arch. These strings are duplicated throughout the code base massively. golangci-lint points to possiblity of typos and duplication. We already had to define these names in pkg/csource and disable checking for prog package. A future change triggers such warnings in another package. Add OS/Arch name consts to sys/targets so that they can be used to refer to OS/Arch. Use the consts everywhere. --- dashboard/app/api.go | 3 +- dashboard/app/app_test.go | 7 +- dashboard/app/email_test.go | 3 +- dashboard/app/reporting.go | 5 +- dashboard/app/reporting_test.go | 13 +- pkg/ast/parser_test.go | 4 +- pkg/bisect/bisect_test.go | 7 +- pkg/build/build.go | 25 ++-- pkg/build/fuchsia.go | 2 +- pkg/build/linux.go | 11 +- pkg/build/netbsd.go | 3 +- pkg/compiler/compiler_test.go | 10 +- pkg/compiler/consts_test.go | 4 +- pkg/compiler/fuzz.go | 2 +- pkg/cover/report.go | 32 ++--- pkg/cover/report_test.go | 4 +- pkg/csource/common.go | 5 - pkg/csource/csource.go | 6 +- pkg/csource/csource_test.go | 4 +- pkg/csource/options.go | 9 +- pkg/csource/options_test.go | 4 +- pkg/host/features.go | 6 +- pkg/host/machine_info_linux_test.go | 28 ++-- pkg/host/syscalls_linux.go | 17 +-- pkg/host/syscalls_linux_test.go | 17 +-- pkg/instance/instance.go | 4 +- pkg/instance/instance_test.go | 15 ++- pkg/ipc/ipc.go | 2 +- pkg/ipc/ipc_test.go | 2 +- pkg/report/fuzz.go | 7 +- pkg/report/linux_test.go | 5 +- pkg/report/report.go | 16 +-- pkg/report/report_test.go | 5 +- pkg/repro/repro_test.go | 3 +- pkg/runtest/run.go | 4 +- pkg/runtest/run_test.go | 10 +- pkg/vcs/vcs.go | 15 ++- prog/test/fuzz.go | 3 +- sys/fuchsia/fidlgen/main.go | 2 +- sys/linux/init.go | 4 +- sys/linux/init_test.go | 3 +- sys/openbsd/init_test.go | 3 +- sys/syz-extract/extract.go | 24 ++-- sys/syz-extract/linux.go | 4 +- sys/syz-sysgen/sysgen.go | 4 +- sys/targets/targets.go | 139 ++++++++++++-------- syz-ci/manager.go | 5 +- syz-ci/updater.go | 3 +- syz-fuzzer/fuzzer_test.go | 5 +- syz-manager/cover.go | 2 +- syz-manager/manager.go | 2 +- tools/syz-check/check.go | 6 +- tools/syz-imagegen/imagegen.go | 8 +- tools/syz-kconf/kconf.go | 6 +- tools/syz-reprolist/reprolist.go | 5 +- tools/syz-runtest/runtest.go | 2 +- tools/syz-trace2syz/proggen/fuzz.go | 3 +- tools/syz-trace2syz/proggen/proggen_test.go | 3 +- tools/syz-trace2syz/trace2syz.go | 5 +- vm/gce/gce.go | 9 +- vm/qemu/qemu.go | 2 +- vm/vm_test.go | 7 +- vm/vmimpl/util.go | 3 +- 63 files changed, 323 insertions(+), 258 deletions(-) diff --git a/dashboard/app/api.go b/dashboard/app/api.go index 73a802d61f5e..f802603d8eef 100644 --- a/dashboard/app/api.go +++ b/dashboard/app/api.go @@ -19,6 +19,7 @@ import ( "github.com/google/syzkaller/dashboard/dashapi" "github.com/google/syzkaller/pkg/email" "github.com/google/syzkaller/pkg/hash" + "github.com/google/syzkaller/sys/targets" "golang.org/x/net/context" "google.golang.org/appengine" db "google.golang.org/appengine/datastore" @@ -784,7 +785,7 @@ func saveCrash(c context.Context, ns string, req *dashapi.Crash, bugKey *db.Key, } else if len(req.ReproSyz) != 0 { prio += 2e12 } - if build.Arch == "amd64" { + if build.Arch == targets.AMD64 { prio += 1e3 } crash := &Crash{ diff --git a/dashboard/app/app_test.go b/dashboard/app/app_test.go index 95b313306176..3f80e5a16ca8 100644 --- a/dashboard/app/app_test.go +++ b/dashboard/app/app_test.go @@ -13,6 +13,7 @@ import ( "time" "github.com/google/syzkaller/dashboard/dashapi" + "github.com/google/syzkaller/sys/targets" "google.golang.org/appengine/user" ) @@ -287,9 +288,9 @@ func testBuild(id int) *dashapi.Build { return &dashapi.Build{ Manager: fmt.Sprintf("manager%v", id), ID: fmt.Sprintf("build%v", id), - OS: "linux", - Arch: "amd64", - VMArch: "amd64", + OS: targets.Linux, + Arch: targets.AMD64, + VMArch: targets.AMD64, SyzkallerCommit: fmt.Sprintf("syzkaller_commit%v", id), CompilerID: fmt.Sprintf("compiler%v", id), KernelRepo: fmt.Sprintf("repo%v", id), diff --git a/dashboard/app/email_test.go b/dashboard/app/email_test.go index 2e73e61f3c59..e3eae3944948 100644 --- a/dashboard/app/email_test.go +++ b/dashboard/app/email_test.go @@ -11,6 +11,7 @@ import ( "github.com/google/syzkaller/dashboard/dashapi" "github.com/google/syzkaller/pkg/email" + "github.com/google/syzkaller/sys/targets" ) // nolint: funlen @@ -121,7 +122,7 @@ For more options, visit https://groups.google.com/d/optout. // Now report syz reproducer and check updated email. build2 := testBuild(10) - build2.Arch = "386" + build2.Arch = targets.I386 build2.KernelRepo = testConfig.Namespaces["test2"].Repos[0].URL build2.KernelBranch = testConfig.Namespaces["test2"].Repos[0].Branch build2.KernelCommitTitle = "a really long title, longer than 80 chars, really long-long-long-long-long-long title" diff --git a/dashboard/app/reporting.go b/dashboard/app/reporting.go index 54ad38cddddf..35a050fcbfe2 100644 --- a/dashboard/app/reporting.go +++ b/dashboard/app/reporting.go @@ -15,6 +15,7 @@ import ( "github.com/google/syzkaller/dashboard/dashapi" "github.com/google/syzkaller/pkg/email" "github.com/google/syzkaller/pkg/html" + "github.com/google/syzkaller/sys/targets" "golang.org/x/net/context" db "google.golang.org/appengine/datastore" "google.golang.org/appengine/log" @@ -1175,9 +1176,9 @@ func (a bugReportSorter) Less(i, j int) bool { // Currently Linux-specific. func kernelArch(arch string) string { switch arch { - case "386": + case targets.I386: return "i386" - case "amd64": + case targets.AMD64: return "" // this is kinda the default, so we don't notify about it default: return arch diff --git a/dashboard/app/reporting_test.go b/dashboard/app/reporting_test.go index 1aa7a49798bb..7be5e023f93b 100644 --- a/dashboard/app/reporting_test.go +++ b/dashboard/app/reporting_test.go @@ -10,6 +10,7 @@ import ( "time" "github.com/google/syzkaller/dashboard/dashapi" + "github.com/google/syzkaller/sys/targets" ) func TestReportBug(t *testing.T) { @@ -45,9 +46,9 @@ func TestReportBug(t *testing.T) { Namespace: "test1", Config: []byte(`{"Index":1}`), ID: rep.ID, - OS: "linux", - Arch: "amd64", - VMArch: "amd64", + OS: targets.Linux, + Arch: targets.AMD64, + VMArch: targets.AMD64, First: true, Moderation: true, Title: "title1", @@ -208,9 +209,9 @@ func TestInvalidBug(t *testing.T) { Namespace: "test1", Config: []byte(`{"Index":1}`), ID: rep.ID, - OS: "linux", - Arch: "amd64", - VMArch: "amd64", + OS: targets.Linux, + Arch: targets.AMD64, + VMArch: targets.AMD64, First: true, Moderation: true, Title: "title1 (2)", diff --git a/pkg/ast/parser_test.go b/pkg/ast/parser_test.go index b5861b5a8525..d3a9049bc7d1 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 c21548a4d97d..b2b7596f1754 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 149d8729c910..9931ce0ea26f 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 f4bb2c8b45f5..ea1e2dccb1a2 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 36f18b84f67d..7566eca21c81 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 43620c9cfcc2..e0f4bcea0bf3 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 e5c7987d1a52..9bc93a519bab 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 77a124b04578..685525bc993b 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 3f888cdbdfda..ecb97834be4b 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 f61c48d11279..4e6b7cd0df26 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 7748c3fabedf..b48ea23709fc 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 24219018067c..0dd76cfbbb83 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 488d277e1b38..49babbf41b96 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, "") { sortedBottom = append(sortedBottom, include) - } else if ctx.target.OS == freebsd && strings.Contains(include, "") { + } else if ctx.target.OS == targets.FreeBSD && strings.Contains(include, "") { sortedTop = append(sortedTop, include) } else { sorted = append(sorted, include) diff --git a/pkg/csource/csource_test.go b/pkg/csource/csource_test.go index 3eec99792c01..f6d04b35ca56 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 ba74eb37cdd3..7f2bc5109490 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 1c403ae06091..43cffd1d5860 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 8b78637fb95b..14d4f5c89409 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 f096666595f1..5075751d5ed8 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 ff41da68baa1..16cfbfa467d4 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 3ce2e351747a..5d4f60082f33 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 b5cbd3bd2230..467998a60508 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 5b9a2840443e..e19f91faf511 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 ffa8a4e6fc3d..06b39af9dd20 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 c8210cdcd5ae..e7c9aa0f8dd4 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 0db6024918bf..f812f78eba37 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 2e31ee75587c..d1b343efeeb6 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 ae618d6e6789..13f76e67da96 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 1545a44e959b..eebbb4c22677 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 3fd9eb1b30d1..9b639cd7d3f3 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 2352028feeb9..8366b8fb37bf 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 e4712033e1a0..d72f5940ebb9 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 4185bf165929..df30992257b8 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) diff --git a/prog/test/fuzz.go b/prog/test/fuzz.go index f3742f6c3019..0d2807f7f43a 100644 --- a/prog/test/fuzz.go +++ b/prog/test/fuzz.go @@ -9,6 +9,7 @@ import ( "math/rand" "github.com/google/syzkaller/prog" + "github.com/google/syzkaller/sys/targets" _ "github.com/google/syzkaller/sys/test/gen" // import the target we use for fuzzing ) @@ -66,7 +67,7 @@ func FuzzParseLog(data []byte) int { var fuzzBuffer = make([]byte, prog.ExecBufferSize) var fuzzTarget, fuzzChoiceTable = func() (*prog.Target, *prog.ChoiceTable) { prog.Debug() - target, err := prog.GetTarget("test", "64") + target, err := prog.GetTarget(targets.TestOS, targets.TestArch64) if err != nil { panic(err) } diff --git a/sys/fuchsia/fidlgen/main.go b/sys/fuchsia/fidlgen/main.go index 8c48ac312eb7..b4942a08d36f 100644 --- a/sys/fuchsia/fidlgen/main.go +++ b/sys/fuchsia/fidlgen/main.go @@ -19,7 +19,7 @@ import ( func main() { targetArch := os.Getenv("TARGETARCH") - target := targets.Get("fuchsia", targetArch) + target := targets.Get(targets.Fuchsia, targetArch) if target == nil { failf("unknown TARGETARCH %s", targetArch) } diff --git a/sys/linux/init.go b/sys/linux/init.go index 928ba17e52a1..a18fa99c462f 100644 --- a/sys/linux/init.go +++ b/sys/linux/init.go @@ -79,11 +79,11 @@ func InitTarget(target *prog.Target) { } switch target.Arch { - case "amd64": + case targets.AMD64: target.SpecialPointers = []uint64{ 0xffffffff81000000, // kernel text } - case "386", "arm64", "arm", "ppc64le", "mips64le", "s390x", "riscv64": + case targets.I386, targets.ARM64, targets.ARM, targets.PPC64LE, targets.MIPS64LE, targets.S390x, targets.RiscV64: default: panic("unknown arch") } diff --git a/sys/linux/init_test.go b/sys/linux/init_test.go index df0622ba3125..201ce762b533 100644 --- a/sys/linux/init_test.go +++ b/sys/linux/init_test.go @@ -8,10 +8,11 @@ import ( "github.com/google/syzkaller/prog" _ "github.com/google/syzkaller/sys/linux/gen" + "github.com/google/syzkaller/sys/targets" ) func TestNeutralize(t *testing.T) { - prog.TestDeserializeHelper(t, "linux", "amd64", nil, []prog.DeserializeTest{ + prog.TestDeserializeHelper(t, targets.Linux, targets.AMD64, nil, []prog.DeserializeTest{ { In: `syslog(0x10000000006, 0x0, 0x0)`, Out: `syslog(0x9, 0x0, 0x0)`, diff --git a/sys/openbsd/init_test.go b/sys/openbsd/init_test.go index 7f3d9a48953b..3a6c2c14c1d1 100644 --- a/sys/openbsd/init_test.go +++ b/sys/openbsd/init_test.go @@ -8,10 +8,11 @@ import ( "github.com/google/syzkaller/prog" _ "github.com/google/syzkaller/sys/openbsd/gen" + "github.com/google/syzkaller/sys/targets" ) func TestNeutralize(t *testing.T) { - prog.TestDeserializeHelper(t, "openbsd", "amd64", nil, []prog.DeserializeTest{ + prog.TestDeserializeHelper(t, targets.OpenBSD, targets.AMD64, nil, []prog.DeserializeTest{ { In: `chflagsat(0x0, 0x0, 0x60004, 0x0)`, Out: `chflagsat(0x0, 0x0, 0x0, 0x0)`, diff --git a/sys/syz-extract/extract.go b/sys/syz-extract/extract.go index 10b8b6541600..a1ddaa86c509 100644 --- a/sys/syz-extract/extract.go +++ b/sys/syz-extract/extract.go @@ -57,15 +57,15 @@ type Extractor interface { } var extractors = map[string]Extractor{ - "akaros": new(akaros), - "linux": new(linux), - "freebsd": new(freebsd), - "netbsd": new(netbsd), - "openbsd": new(openbsd), - "android": new(linux), - "fuchsia": new(fuchsia), - "windows": new(windows), - "trusty": new(trusty), + targets.Akaros: new(akaros), + targets.Linux: new(linux), + targets.FreeBSD: new(freebsd), + targets.NetBSD: new(netbsd), + targets.OpenBSD: new(openbsd), + "android": new(linux), + targets.Fuchsia: new(fuchsia), + targets.Windows: new(windows), + targets.Trusty: new(trusty), } func main() { @@ -243,7 +243,7 @@ func archFileList(os, arch string, files []string) (string, []string, []string, android := false if os == "android" { android = true - os = "linux" + os = targets.Linux } var arches []string if arch != "" { @@ -253,7 +253,7 @@ func archFileList(os, arch string, files []string) (string, []string, []string, arches = append(arches, arch) } if android { - arches = []string{"386", "amd64", "arm", "arm64"} + arches = []string{targets.I386, targets.AMD64, targets.ARM, targets.ARM64} } sort.Strings(arches) } @@ -278,7 +278,7 @@ func archFileList(os, arch string, files []string) (string, []string, []string, } for _, f := range matches { f = filepath.Base(f) - if manualFiles[f] || os == "linux" && android != androidFiles[f] { + if manualFiles[f] || os == targets.Linux && android != androidFiles[f] { continue } files = append(files, f) diff --git a/sys/syz-extract/linux.go b/sys/syz-extract/linux.go index 05789ef55e75..47e5d20e6950 100644 --- a/sys/syz-extract/linux.go +++ b/sys/syz-extract/linux.go @@ -12,6 +12,7 @@ import ( "github.com/google/syzkaller/pkg/compiler" "github.com/google/syzkaller/pkg/osutil" + "github.com/google/syzkaller/sys/targets" ) type linux struct{} @@ -134,7 +135,8 @@ func (*linux) prepareArch(arch *Arch) error { } func (*linux) processFile(arch *Arch, info *compiler.ConstInfo) (map[string]uint64, map[string]bool, error) { - if strings.HasSuffix(info.File, "_kvm.txt") && (arch.target.Arch == "arm" || arch.target.Arch == "riscv64") { + if strings.HasSuffix(info.File, "_kvm.txt") && + (arch.target.Arch == targets.ARM || arch.target.Arch == targets.RiscV64) { // Hack: KVM is not supported on ARM anymore. We may want some more official support // for marking descriptions arch-specific, but so far this combination is the only // one. For riscv64, KVM is not supported yet but might be in the future. diff --git a/sys/syz-sysgen/sysgen.go b/sys/syz-sysgen/sysgen.go index 8dfedb6a25a8..62f36c3d33c8 100644 --- a/sys/syz-sysgen/sysgen.go +++ b/sys/syz-sysgen/sysgen.go @@ -115,7 +115,7 @@ func main() { } consts := constFile.Arch(job.Target.Arch) top := descriptions - if OS == "linux" && (job.Target.Arch == "arm" || job.Target.Arch == "riscv64") { + if OS == targets.Linux && (job.Target.Arch == targets.ARM || job.Target.Arch == targets.RiscV64) { // Hack: KVM is not supported on ARM anymore. On riscv64 it // is not supported yet but might be in the future. // Note: syz-extract also ignores this file for arm and @@ -125,7 +125,7 @@ func main() { return !strings.HasSuffix(pos.File, "_kvm.txt") }) } - if OS == "test" { + if OS == targets.TestOS { constInfo := compiler.ExtractConsts(top, job.Target, eh) compiler.FabricateSyscallConsts(job.Target, constInfo, consts) } diff --git a/sys/targets/targets.go b/sys/targets/targets.go index 28ee5b376b52..ff218aa6c51c 100644 --- a/sys/targets/targets.go +++ b/sys/targets/targets.go @@ -78,6 +78,31 @@ type osCommon struct { cflags []string } +const ( + Akaros = "akaros" + FreeBSD = "freebsd" + Fuchsia = "fuchsia" + Linux = "linux" + NetBSD = "netbsd" + OpenBSD = "openbsd" + TestOS = "test" + Trusty = "trusty" + Windows = "windows" + + AMD64 = "amd64" + ARM64 = "arm64" + ARM = "arm" + I386 = "386" + MIPS64LE = "mips64le" + PPC64LE = "ppc64le" + S390x = "s390x" + RiscV64 = "riscv64" + TestArch64 = "64" + TestArch64Fork = "64_fork" + TestArch32Shmem = "32_shmem" + TestArch32ForkShmem = "32_fork_shmem" +) + func Get(OS, arch string) *Target { return GetEx(OS, arch, useClang) } @@ -103,8 +128,8 @@ func GetEx(OS, arch string, clang bool) *Target { // nolint: lll var List = map[string]map[string]*Target{ - "test": { - "64": { + TestOS: { + TestArch64: { PtrSize: 8, PageSize: 4 << 10, // Compile with -no-pie due to issues with ASan + ASLR on ppc64le. @@ -116,7 +141,7 @@ var List = map[string]map[string]*Target{ ExecutorUsesForkServer: false, }, }, - "64_fork": { + TestArch64Fork: { PtrSize: 8, PageSize: 8 << 10, // Compile with -no-pie due to issues with ASan + ASLR on ppc64le. @@ -128,7 +153,7 @@ var List = map[string]map[string]*Target{ ExecutorUsesForkServer: true, }, }, - "32_shmem": { + TestArch32Shmem: { PtrSize: 4, PageSize: 8 << 10, Int64Alignment: 4, @@ -141,7 +166,7 @@ var List = map[string]map[string]*Target{ ExecutorUsesForkServer: false, }, }, - "32_fork_shmem": { + TestArch32ForkShmem: { PtrSize: 4, PageSize: 4 << 10, CFlags: []string{"-m32", "-static"}, @@ -155,8 +180,8 @@ var List = map[string]map[string]*Target{ }, }, }, - "linux": { - "amd64": { + Linux: { + AMD64: { PtrSize: 8, PageSize: 4 << 10, LittleEndian: true, @@ -170,8 +195,8 @@ var List = map[string]map[string]*Target{ return nr >= 313 }, }, - "386": { - VMArch: "amd64", + I386: { + VMArch: AMD64, PtrSize: 4, PageSize: 4 << 10, Int64Alignment: 4, @@ -181,7 +206,7 @@ var List = map[string]map[string]*Target{ KernelArch: "i386", KernelHeaderArch: "x86", }, - "arm64": { + ARM64: { PtrSize: 8, PageSize: 4 << 10, LittleEndian: true, @@ -189,8 +214,8 @@ var List = map[string]map[string]*Target{ KernelArch: "arm64", KernelHeaderArch: "arm64", }, - "arm": { - VMArch: "arm64", + ARM: { + VMArch: ARM64, PtrSize: 4, PageSize: 4 << 10, LittleEndian: true, @@ -199,8 +224,7 @@ var List = map[string]map[string]*Target{ KernelArch: "arm", KernelHeaderArch: "arm", }, - "mips64le": { - VMArch: "mips64le", + MIPS64LE: { PtrSize: 8, PageSize: 4 << 10, LittleEndian: true, @@ -209,7 +233,7 @@ var List = map[string]map[string]*Target{ KernelArch: "mips", KernelHeaderArch: "mips", }, - "ppc64le": { + PPC64LE: { PtrSize: 8, PageSize: 64 << 10, LittleEndian: true, @@ -218,7 +242,7 @@ var List = map[string]map[string]*Target{ KernelArch: "powerpc", KernelHeaderArch: "powerpc", }, - "s390x": { + S390x: { PtrSize: 8, PageSize: 4 << 10, DataOffset: 0xfffff000, @@ -234,7 +258,7 @@ var List = map[string]map[string]*Target{ "mmap": "mmap", }, }, - "riscv64": { + RiscV64: { PtrSize: 8, PageSize: 4 << 10, LittleEndian: true, @@ -243,8 +267,8 @@ var List = map[string]map[string]*Target{ KernelHeaderArch: "riscv", }, }, - "freebsd": { - "amd64": { + FreeBSD: { + AMD64: { PtrSize: 8, PageSize: 4 << 10, LittleEndian: true, @@ -252,8 +276,8 @@ var List = map[string]map[string]*Target{ CFlags: []string{"-m64"}, NeedSyscallDefine: dontNeedSyscallDefine, }, - "386": { - VMArch: "amd64", + I386: { + VMArch: AMD64, PtrSize: 4, PageSize: 4 << 10, // The default DataOffset doesn't work with 32-bit @@ -266,8 +290,8 @@ var List = map[string]map[string]*Target{ NeedSyscallDefine: dontNeedSyscallDefine, }, }, - "netbsd": { - "amd64": { + NetBSD: { + AMD64: { PtrSize: 8, PageSize: 4 << 10, LittleEndian: true, @@ -279,8 +303,8 @@ var List = map[string]map[string]*Target{ CCompiler: sourceDirVar + "/tools/bin/x86_64--netbsd-g++", }, }, - "openbsd": { - "amd64": { + OpenBSD: { + AMD64: { PtrSize: 8, PageSize: 4 << 10, LittleEndian: true, @@ -313,8 +337,8 @@ var List = map[string]map[string]*Target{ }, }, }, - "fuchsia": { - "amd64": { + Fuchsia: { + AMD64: { PtrSize: 8, PageSize: 4 << 10, LittleEndian: true, @@ -323,26 +347,26 @@ var List = map[string]map[string]*Target{ Objdump: sourceDirVar + "/prebuilt/third_party/clang/linux-x64/bin/llvm-objdump", CFlags: fuchsiaCFlags("x64", "x86_64"), }, - "arm64": { + ARM64: { PtrSize: 8, PageSize: 4 << 10, LittleEndian: true, - KernelHeaderArch: "arm64", + KernelHeaderArch: ARM64, CCompiler: sourceDirVar + "/prebuilt/third_party/clang/linux-x64/bin/clang", Objdump: sourceDirVar + "/prebuilt/third_party/clang/linux-x64/bin/llvm-objdump", - CFlags: fuchsiaCFlags("arm64", "aarch64"), + CFlags: fuchsiaCFlags(ARM64, "aarch64"), }, }, - "windows": { - "amd64": { + Windows: { + AMD64: { PtrSize: 8, // TODO(dvyukov): what should we do about 4k vs 64k? PageSize: 4 << 10, LittleEndian: true, }, }, - "akaros": { - "amd64": { + Akaros: { + AMD64: { PtrSize: 8, PageSize: 4 << 10, LittleEndian: true, @@ -354,8 +378,8 @@ var List = map[string]map[string]*Target{ }, }, }, - "trusty": { - "arm": { + Trusty: { + ARM: { PtrSize: 4, PageSize: 4 << 10, LittleEndian: true, @@ -365,7 +389,7 @@ var List = map[string]map[string]*Target{ } var oses = map[string]osCommon{ - "linux": { + Linux: { SyscallNumbers: true, SyscallPrefix: "__NR_", ExecutorUsesShmem: true, @@ -373,7 +397,7 @@ var oses = map[string]osCommon{ KernelObject: "vmlinux", cflags: []string{"-static"}, }, - "freebsd": { + FreeBSD: { SyscallNumbers: true, Int64SyscallArgs: true, SyscallPrefix: "SYS_", @@ -383,15 +407,15 @@ var oses = map[string]osCommon{ CPP: "g++", cflags: []string{"-static", "-lc++"}, }, - "netbsd": { - BuildOS: "linux", + NetBSD: { + BuildOS: Linux, SyscallNumbers: true, SyscallPrefix: "SYS_", ExecutorUsesShmem: true, ExecutorUsesForkServer: true, KernelObject: "netbsd.gdb", }, - "openbsd": { + OpenBSD: { SyscallNumbers: true, SyscallPrefix: "SYS_", ExecutorUsesShmem: true, @@ -399,8 +423,8 @@ var oses = map[string]osCommon{ KernelObject: "bsd.gdb", CPP: "ecpp", }, - "fuchsia": { - BuildOS: "linux", + Fuchsia: { + BuildOS: Linux, SyscallNumbers: false, ExecutorUsesShmem: false, ExecutorUsesForkServer: false, @@ -408,15 +432,15 @@ var oses = map[string]osCommon{ SyzExecutorCmd: "syz-executor", KernelObject: "zircon.elf", }, - "windows": { + Windows: { SyscallNumbers: false, ExecutorUsesShmem: false, ExecutorUsesForkServer: false, ExeExtension: ".exe", KernelObject: "vmlinux", }, - "akaros": { - BuildOS: "linux", + Akaros: { + BuildOS: Linux, SyscallNumbers: true, SyscallPrefix: "SYS_", ExecutorUsesShmem: false, @@ -424,7 +448,7 @@ var oses = map[string]osCommon{ HostFuzzer: true, KernelObject: "akaros-kernel-64b", }, - "trusty": { + Trusty: { SyscallNumbers: true, Int64SyscallArgs: true, SyscallPrefix: "__NR_", @@ -479,14 +503,14 @@ func init() { goarch := runtime.GOARCH goos := runtime.GOOS if goos == "android" { - goos = "linux" + goos = Linux } - for _, target := range List["test"] { + for _, target := range List[TestOS] { if List[goos] != nil { if host := List[goos][goarch]; host != nil { target.CCompiler = host.CCompiler target.CPP = host.CPP - if goos == "freebsd" { + if goos == FreeBSD { // For some configurations -no-pie is passed to the compiler, // which is not used by clang. // Ensure clang does not complain about it. @@ -498,18 +522,18 @@ func init() { // In ESA/390 mode, the CPU is able to address only 31bit of memory but // arithmetic operations are still 32bit // Fix cflags by replacing compiler's -m32 option with -m31 - if goarch == "s390x" { + if goarch == S390x { for i := range target.CFlags { target.CFlags[i] = strings.Replace(target.CFlags[i], "-m32", "-m31", -1) } } } - if target.PtrSize == 4 && goos == "freebsd" && goarch == "amd64" { + if target.PtrSize == 4 && goos == FreeBSD && goarch == AMD64 { // A hack to let 32-bit "test" target tests run on FreeBSD: // freebsd/386 requires a non-default DataOffset to avoid // clobbering mappings created by the C runtime. Since that is the // only target with this constraint, just special-case it for now. - target.DataOffset = List[goos]["386"].DataOffset + target.DataOffset = List[goos][I386].DataOffset } } target.BuildOS = goos @@ -524,6 +548,9 @@ func initTarget(target *Target, OS, arch string) { target.initOther = new(sync.Once) target.OS = OS target.Arch = arch + if target.KernelArch == "" { + target.KernelArch = target.Arch + } if target.NeedSyscallDefine == nil { target.NeedSyscallDefine = needSyscallDefine } @@ -543,7 +570,7 @@ func initTarget(target *Target, OS, arch string) { for i := range target.CFlags { target.replaceSourceDir(&target.CFlags[i], sourceDir) } - if OS == "linux" && arch == runtime.GOARCH { + if OS == Linux && arch == runtime.GOARCH { // Don't use cross-compiler for native compilation, there are cases when this does not work: // https://github.com/google/syzkaller/pull/619 // https://github.com/google/syzkaller/issues/387 @@ -573,8 +600,8 @@ func initTarget(target *Target, OS, arch string) { for _, flags := range [][]string{commonCFlags, target.osCommon.cflags} { target.CFlags = append(target.CFlags, flags...) } - if OS == "test" { - if runtime.GOARCH != "s390x" { + if OS == TestOS { + if runtime.GOARCH != S390x { target.LittleEndian = true } else { target.LittleEndian = false diff --git a/syz-ci/manager.go b/syz-ci/manager.go index 121169e05f8e..59dc6bf210bf 100644 --- a/syz-ci/manager.go +++ b/syz-ci/manager.go @@ -143,7 +143,8 @@ func (mgr *Manager) loop() { nextBuildTime := time.Now() var managerRestartTime, coverUploadTime time.Time latestInfo := mgr.checkLatest() - if latestInfo != nil && time.Since(latestInfo.Time) < kernelRebuildPeriod/2 && mgr.managercfg.TargetOS != "fuchsia" { + if latestInfo != nil && time.Since(latestInfo.Time) < kernelRebuildPeriod/2 && + mgr.managercfg.TargetOS != targets.Fuchsia { // If we have a reasonably fresh build, // start manager straight away and don't rebuild kernel for a while. // Fuchsia is a special case: it builds with syz-executor, so if we just updated syzkaller, we need @@ -410,7 +411,7 @@ func (mgr *Manager) testImage(imageDir string, info *BuildInfo) error { switch err := res.(type) { case *instance.TestError: if rep := err.Report; rep != nil { - what := "test" + what := targets.TestOS if err.Boot { what = "boot" } diff --git a/syz-ci/updater.go b/syz-ci/updater.go index 2463cfa975e6..795d331511ba 100644 --- a/syz-ci/updater.go +++ b/syz-ci/updater.go @@ -18,6 +18,7 @@ import ( "github.com/google/syzkaller/pkg/osutil" "github.com/google/syzkaller/pkg/vcs" "github.com/google/syzkaller/prog" + "github.com/google/syzkaller/sys/targets" ) const ( @@ -232,7 +233,7 @@ func (upd *SyzUpdater) build(commit *vcs.Commit) error { } for _, f := range files { src := filepath.Join(upd.descriptions, f.Name()) - dst := filepath.Join(upd.syzkallerDir, "sys", "linux", f.Name()) + dst := filepath.Join(upd.syzkallerDir, "sys", targets.Linux, f.Name()) if err := osutil.CopyFile(src, dst); err != nil { return err } diff --git a/syz-fuzzer/fuzzer_test.go b/syz-fuzzer/fuzzer_test.go index 04b5826226d5..dae8329f77f2 100644 --- a/syz-fuzzer/fuzzer_test.go +++ b/syz-fuzzer/fuzzer_test.go @@ -11,6 +11,7 @@ import ( "github.com/google/syzkaller/pkg/hash" "github.com/google/syzkaller/pkg/signal" "github.com/google/syzkaller/prog" + "github.com/google/syzkaller/sys/targets" ) type InputTest struct { @@ -22,7 +23,7 @@ type InputTest struct { func TestChooseProgram(t *testing.T) { rs := rand.NewSource(0) r := rand.New(rs) - target := getTarget(t, "test", "64") + target := getTarget(t, targets.TestOS, targets.TestArch64) fuzzer := &Fuzzer{corpusHashes: make(map[hash.Sig]struct{})} const ( @@ -56,7 +57,7 @@ func TestChooseProgram(t *testing.T) { } func TestAddInputConcurrency(t *testing.T) { - target := getTarget(t, "test", "64") + target := getTarget(t, targets.TestOS, targets.TestArch64) fuzzer := &Fuzzer{corpusHashes: make(map[hash.Sig]struct{})} const ( diff --git a/syz-manager/cover.go b/syz-manager/cover.go index 328f9fbd4075..69041fe5b180 100644 --- a/syz-manager/cover.go +++ b/syz-manager/cover.go @@ -52,7 +52,7 @@ func coverToPCs(target *targets.Target, cov []uint32) []uint64 { } func getVMOffset(target *targets.Target, vmlinux string) (uint32, error) { - if target.OS == "freebsd" { + if target.OS == targets.FreeBSD { return 0xffffffff, nil } readelf := "readelf" diff --git a/syz-manager/manager.go b/syz-manager/manager.go index 05af6d30b740..bac2a773a512 100644 --- a/syz-manager/manager.go +++ b/syz-manager/manager.go @@ -454,7 +454,7 @@ func (mgr *Manager) preloadCorpus() { } mgr.corpusDB = corpusDB - if seedDir := filepath.Join(mgr.cfg.Syzkaller, "sys", mgr.cfg.TargetOS, "test"); osutil.IsExist(seedDir) { + if seedDir := filepath.Join(mgr.cfg.Syzkaller, "sys", mgr.cfg.TargetOS, targets.TestOS); osutil.IsExist(seedDir) { seeds, err := ioutil.ReadDir(seedDir) if err != nil { log.Fatalf("failed to read seeds dir: %v", err) diff --git a/tools/syz-check/check.go b/tools/syz-check/check.go index 86048f9a49bf..de7145dfbebe 100644 --- a/tools/syz-check/check.go +++ b/tools/syz-check/check.go @@ -52,7 +52,7 @@ func main() { flagNetlink = flag.Bool("netlink", true, "do checking of netlink policies") ) arches := make(map[string]*string) - for arch := range targets.List["linux"] { + for arch := range targets.List[targets.Linux] { arches[arch] = flag.String("obj-"+arch, "", arch+" kernel object file") } failf := func(msg string, args ...interface{}) { @@ -152,7 +152,7 @@ func writeWarnings(OS string, narches int, warnings []Warn) error { byFile := make(map[string][]Warn) for _, warn := range warnings { // KVM is not supported on ARM completely. - if OS == "linux" && warn.arch == "arm" && strings.HasSuffix(warn.pos.File, "_kvm.txt") { + if OS == targets.Linux && warn.arch == targets.ARM && strings.HasSuffix(warn.pos.File, "_kvm.txt") { continue } byFile[warn.pos.File] = append(byFile[warn.pos.File], warn) @@ -358,7 +358,7 @@ func parseDescriptions(OS, arch string) ([]prog.Type, map[string]*ast.Struct, [] // Finally we compare our descriptions with the kernel policy description. func checkNetlink(OS, arch, obj string, structTypes []prog.Type, locs map[string]*ast.Struct) ([]Warn, error) { - if arch != "amd64" { + if arch != targets.AMD64 { // Netlink policies are arch-independent (?), // so no need to check all arches. // Also our definition of nlaPolicy below is 64-bit specific. diff --git a/tools/syz-imagegen/imagegen.go b/tools/syz-imagegen/imagegen.go index 033a1dd58634..4ca608254607 100644 --- a/tools/syz-imagegen/imagegen.go +++ b/tools/syz-imagegen/imagegen.go @@ -29,6 +29,7 @@ import ( "github.com/google/syzkaller/pkg/osutil" "github.com/google/syzkaller/prog" _ "github.com/google/syzkaller/sys" + "github.com/google/syzkaller/sys/targets" ) // FileSystem represents one file system. @@ -478,7 +479,7 @@ func main() { } return } - target, err := prog.GetTarget("linux", "amd64") + target, err := prog.GetTarget(targets.Linux, targets.AMD64) if err != nil { failf("%v", err) } @@ -587,7 +588,7 @@ func generateImages(target *prog.Target, flagFS string, list bool) ([]*Image, er fmt.Printf("%v [%v images]\n", fs.Name, index) continue } - files, err := filepath.Glob(filepath.Join("sys", "linux", "test", "syz_mount_image_"+fs.Name+"_*")) + files, err := filepath.Glob(filepath.Join("sys", targets.Linux, "test", "syz_mount_image_"+fs.Name+"_*")) if err != nil { return nil, fmt.Errorf("error reading output dir: %v", err) } @@ -634,7 +635,8 @@ func (image *Image) generate() error { } func (image *Image) generateSize() error { - outFile := filepath.Join("sys", "linux", "test", fmt.Sprintf("syz_mount_image_%v_%v", image.fs.Name, image.index)) + outFile := filepath.Join("sys", targets.Linux, "test", + fmt.Sprintf("syz_mount_image_%v_%v", image.fs.Name, image.index)) image.disk = outFile + ".img" f, err := os.Create(image.disk) if err != nil { diff --git a/tools/syz-kconf/kconf.go b/tools/syz-kconf/kconf.go index 02ce0e9294f5..841366146bb1 100644 --- a/tools/syz-kconf/kconf.go +++ b/tools/syz-kconf/kconf.go @@ -49,7 +49,7 @@ func main() { if *flagSourceDir == "" { failf("missing mandatory flag -sourcedir") } - repo, err := vcs.NewRepo("linux", "", *flagSourceDir, vcs.OptPrecious) + repo, err := vcs.NewRepo(targets.Linux, "", *flagSourceDir, vcs.OptPrecious) if err != nil { failf("failed to create repo: %v", err) } @@ -307,12 +307,12 @@ func (ctx *Context) addDependentConfigs(dst *kconfig.ConfigFile, include []strin } func (ctx *Context) setTarget() error { - for _, target := range targets.List["linux"] { + for _, target := range targets.List[targets.Linux] { if ctx.Inst.Features[target.KernelArch] { if ctx.Target != nil { return fmt.Errorf("arch is set twice") } - ctx.Target = targets.GetEx("linux", target.Arch, ctx.Inst.Features[featClang]) + ctx.Target = targets.GetEx(targets.Linux, target.Arch, ctx.Inst.Features[featClang]) } } if ctx.Target == nil { diff --git a/tools/syz-reprolist/reprolist.go b/tools/syz-reprolist/reprolist.go index 5c096bfdfa91..366f82116cfc 100644 --- a/tools/syz-reprolist/reprolist.go +++ b/tools/syz-reprolist/reprolist.go @@ -19,6 +19,7 @@ import ( "github.com/google/syzkaller/pkg/csource" "github.com/google/syzkaller/pkg/osutil" "github.com/google/syzkaller/pkg/vcs" + "github.com/google/syzkaller/sys/targets" ) var ( @@ -114,7 +115,7 @@ func writeRepros(bugchan chan *dashapi.BugReport) { } log.Printf("%v: %v: C repro", bug.ID, bug.BugStatus) arch := "" - if bug.Arch != "" && bug.Arch != "amd64" { + if bug.Arch != "" && bug.Arch != targets.AMD64 { arch = fmt.Sprintf(" arch:%v", bug.Arch) } repro := []byte(fmt.Sprintf("// %v\n// %v/bug?id=%v\n// status:%v%v\n", @@ -173,7 +174,7 @@ func createProg2CArgs(bug *dashapi.BugReport, opts csource.Options, file string) if haveOSFlag { args = append(args, "-os", *flagOS) } - if bug.Arch != "" && bug.Arch != "amd64" { + if bug.Arch != "" && bug.Arch != targets.AMD64 { args = append(args, "-arch", bug.Arch) } if opts.Fault { diff --git a/tools/syz-runtest/runtest.go b/tools/syz-runtest/runtest.go index d961dc8672fa..b6f25d784972 100644 --- a/tools/syz-runtest/runtest.go +++ b/tools/syz-runtest/runtest.go @@ -116,7 +116,7 @@ func main() { fmt.Printf("%-24v: %v calls enabled\n", sandbox+" sandbox", len(calls)) } ctx := &runtest.Context{ - Dir: filepath.Join(cfg.Syzkaller, "sys", target.OS, "test"), + Dir: filepath.Join(cfg.Syzkaller, "sys", target.OS, targets.TestOS), Target: target, Features: mgr.checkResult.Features, EnabledCalls: enabledCalls, diff --git a/tools/syz-trace2syz/proggen/fuzz.go b/tools/syz-trace2syz/proggen/fuzz.go index 7f74534b93ab..da4fae7bb19c 100644 --- a/tools/syz-trace2syz/proggen/fuzz.go +++ b/tools/syz-trace2syz/proggen/fuzz.go @@ -8,10 +8,11 @@ package proggen import ( "github.com/google/syzkaller/prog" _ "github.com/google/syzkaller/sys/linux/gen" // pull in the target + "github.com/google/syzkaller/sys/targets" ) var linuxTarget = func() *prog.Target { - target, err := prog.GetTarget("linux", "amd64") + target, err := prog.GetTarget(targets.Linux, targets.AMD64) if err != nil { panic(err) } diff --git a/tools/syz-trace2syz/proggen/proggen_test.go b/tools/syz-trace2syz/proggen/proggen_test.go index 0eaec0d8deeb..451147bed986 100644 --- a/tools/syz-trace2syz/proggen/proggen_test.go +++ b/tools/syz-trace2syz/proggen/proggen_test.go @@ -12,6 +12,7 @@ import ( "github.com/google/syzkaller/prog" _ "github.com/google/syzkaller/sys" + "github.com/google/syzkaller/sys/targets" "github.com/google/syzkaller/tools/syz-trace2syz/parser" ) @@ -265,7 +266,7 @@ r0 = openat$rtc(0xffffffffffffff9c, &(0x7f0000000000)='/dev/rtc0\x00', 0x0, 0x0) ioctl$RTC_WKALM_SET(r0, 0x4028700f, &(0x7f0000000040)={0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x10000, 0x5181}})`, }, } - target, err := prog.GetTarget("linux", "amd64") + target, err := prog.GetTarget(targets.Linux, targets.AMD64) if err != nil { t.Fatal(err) } diff --git a/tools/syz-trace2syz/trace2syz.go b/tools/syz-trace2syz/trace2syz.go index d634f137fcc8..89081d57cfde 100644 --- a/tools/syz-trace2syz/trace2syz.go +++ b/tools/syz-trace2syz/trace2syz.go @@ -22,6 +22,7 @@ import ( "github.com/google/syzkaller/pkg/osutil" "github.com/google/syzkaller/prog" _ "github.com/google/syzkaller/sys" + "github.com/google/syzkaller/sys/targets" "github.com/google/syzkaller/tools/syz-trace2syz/proggen" ) @@ -32,8 +33,8 @@ var ( ) const ( - goos = "linux" // Target OS - arch = "amd64" // Target architecture + goos = targets.Linux // Target OS + arch = targets.AMD64 // Target architecture ) func main() { diff --git a/vm/gce/gce.go b/vm/gce/gce.go index 7bc049cb2239..e3f23ccee6c1 100644 --- a/vm/gce/gce.go +++ b/vm/gce/gce.go @@ -28,6 +28,7 @@ import ( "github.com/google/syzkaller/pkg/kd" "github.com/google/syzkaller/pkg/log" "github.com/google/syzkaller/pkg/osutil" + "github.com/google/syzkaller/sys/targets" "github.com/google/syzkaller/vm/vmimpl" ) @@ -248,7 +249,7 @@ func (inst *instance) Run(timeout time.Duration, stop <-chan bool, command strin } merger := vmimpl.NewOutputMerger(tee) var decoder func(data []byte) (int, int, []byte) - if inst.env.OS == "windows" { + if inst.env.OS == targets.Windows { decoder = kd.Decode } merger.AddDecoder("console", conRpipe, decoder) @@ -264,7 +265,7 @@ func (inst *instance) Run(timeout time.Duration, stop <-chan bool, command strin sshRpipe.Close() return nil, nil, err } - if inst.env.OS == "linux" { + if inst.env.OS == targets.Linux { if inst.sshUser != "root" { command = fmt.Sprintf("sudo bash -c '%v'", command) } @@ -369,10 +370,10 @@ func waitForConsoleConnect(merger *vmimpl.OutputMerger) error { } func (inst *instance) Diagnose() ([]byte, bool) { - if inst.env.OS == "freebsd" { + if inst.env.OS == targets.FreeBSD { return vmimpl.DiagnoseFreeBSD(inst.consolew) } - if inst.env.OS == "openbsd" { + if inst.env.OS == targets.OpenBSD { return vmimpl.DiagnoseOpenBSD(inst.consolew) } return nil, false diff --git a/vm/qemu/qemu.go b/vm/qemu/qemu.go index 222dc4d8abe9..15b8e08544f2 100644 --- a/vm/qemu/qemu.go +++ b/vm/qemu/qemu.go @@ -259,7 +259,7 @@ func ctor(env *vmimpl.Env) (vmimpl.Pool, error) { return nil, err } if env.Image == "9p" { - if env.OS != "linux" { + if env.OS != targets.Linux { return nil, fmt.Errorf("9p image is supported for linux only") } if cfg.Kernel == "" { diff --git a/vm/vm_test.go b/vm/vm_test.go index 8c1f82917e02..31dd65045f34 100644 --- a/vm/vm_test.go +++ b/vm/vm_test.go @@ -13,6 +13,7 @@ import ( "github.com/google/syzkaller/pkg/mgrconfig" "github.com/google/syzkaller/pkg/report" + "github.com/google/syzkaller/sys/targets" "github.com/google/syzkaller/vm/vmimpl" ) @@ -340,9 +341,9 @@ func testMonitorExecution(t *testing.T, test *Test) { defer os.RemoveAll(dir) cfg := &mgrconfig.Config{ Workdir: dir, - TargetOS: "linux", - TargetArch: "amd64", - TargetVMArch: "amd64", + TargetOS: targets.Linux, + TargetArch: targets.AMD64, + TargetVMArch: targets.AMD64, Type: "test", } pool, err := Create(cfg, false) diff --git a/vm/vmimpl/util.go b/vm/vmimpl/util.go index 418ae2d663ac..47340ccde246 100644 --- a/vm/vmimpl/util.go +++ b/vm/vmimpl/util.go @@ -9,6 +9,7 @@ import ( "github.com/google/syzkaller/pkg/log" "github.com/google/syzkaller/pkg/osutil" + "github.com/google/syzkaller/sys/targets" ) // Sleep for d. @@ -24,7 +25,7 @@ func SleepInterruptible(d time.Duration) bool { func WaitForSSH(debug bool, timeout time.Duration, addr, sshKey, sshUser, OS string, port int, stop chan error) error { pwd := "pwd" - if OS == "windows" { + if OS == targets.Windows { pwd = "dir" } startTime := time.Now()