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.

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)