pkg/build: modify builder interface

Modify the `builder` interface in such a way that build method also
returns a struct containing extra information about the build process.

This allows to fetch compiler ID from individual builders. Also, this
makes the `signer` interface obsolete, as this information can also go
into that structure.

10 files changed, 89 insertions, 94 deletions

diff --git a/pkg/build/akaros.go b/pkg/build/akaros.go
index 046096708..9e1ecc66f 100644
--- a/pkg/build/akaros.go
+++ b/pkg/build/akaros.go
@@ -16,13 +16,13 @@ import (
 
 type akaros struct{}
 
-func (ctx akaros) build(params Params) error {
+func (ctx akaros) build(params Params) (ImageDetails, error) {
 	configFile := filepath.Join(params.KernelDir, ".config")
 	if err := osutil.WriteFile(configFile, params.Config); err != nil {
-		return fmt.Errorf("failed to write config file: %v", err)
+		return ImageDetails{}, fmt.Errorf("failed to write config file: %v", err)
 	}
 	if err := osutil.SandboxChown(configFile); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	sshkey := filepath.Join(params.KernelDir, "key")
 	sshkeyPub := sshkey + ".pub"
@@ -30,29 +30,29 @@ func (ctx akaros) build(params Params) error {
 	os.Remove(sshkeyPub)
 	if _, err := osutil.RunCmd(10*time.Minute, "", "ssh-keygen", "-t", "rsa", "-b", "2048",
 		"-N", "", "-C", "", "-f", sshkey); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := osutil.SandboxChown(sshkeyPub); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := ctx.make(params.KernelDir, "", "olddefconfig", "ARCH=x86"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := ctx.make(params.KernelDir, "", "xcc"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := ctx.make(params.KernelDir, "tools/dev-libs/elfutils", "install"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := ctx.make(params.KernelDir, "", "apps-install"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := ctx.make(params.KernelDir, "", "fill-kfs"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	targetKey := filepath.Join(params.KernelDir, "kern", "kfs", ".ssh", "authorized_keys")
 	if err := osutil.Rename(sshkeyPub, targetKey); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	const init = `#!/bin/bash
 /ifconfig
@@ -61,28 +61,28 @@ bash
 `
 	initFile := filepath.Join(params.KernelDir, "kern", "kfs", "init.sh")
 	if err := osutil.WriteFile(initFile, []byte(init)); err != nil {
-		return fmt.Errorf("failed to write init script: %v", err)
+		return ImageDetails{}, fmt.Errorf("failed to write init script: %v", err)
 	}
 	if err := osutil.SandboxChown(initFile); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := os.Chmod(initFile, 0770); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := ctx.cmd(params.KernelDir, "dropbear", "./CONFIGURE_AKAROS"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := ctx.make(params.KernelDir, "dropbear/build"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := ctx.make(params.KernelDir, "dropbear/build", "install"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := ctx.make(params.KernelDir, ""); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := osutil.WriteFile(filepath.Join(params.OutputDir, "image"), nil); err != nil {
-		return fmt.Errorf("failed to write image file: %v", err)
+		return ImageDetails{}, fmt.Errorf("failed to write image file: %v", err)
 	}
 	for src, dst := range map[string]string{
 		".config":                    "kernel.config",
@@ -93,10 +93,10 @@ bash
 		fullSrc := filepath.Join(params.KernelDir, filepath.FromSlash(src))
 		fullDst := filepath.Join(params.OutputDir, filepath.FromSlash(dst))
 		if err := osutil.CopyFile(fullSrc, fullDst); err != nil {
-			return fmt.Errorf("failed to copy %v: %v", src, err)
+			return ImageDetails{}, fmt.Errorf("failed to copy %v: %v", src, err)
 		}
 	}
-	return nil
+	return ImageDetails{}, nil
 }
 
 func (ctx akaros) clean(kernelDir, targetArch string) error {
diff --git a/pkg/build/build.go b/pkg/build/build.go
index ba971ec94..c1b0302e9 100644
--- a/pkg/build/build.go
+++ b/pkg/build/build.go
@@ -75,7 +75,7 @@ func Image(params Params) (details ImageDetails, err error) {
 			return
 		}
 	}
-	err = builder.build(params)
+	details, err = builder.build(params)
 	if err != nil {
 		err = extractRootCause(err, params.TargetOS, params.KernelDir)
 		return
@@ -85,12 +85,6 @@ func Image(params Params) (details ImageDetails, err error) {
 			return details, fmt.Errorf("failed to chmod 0600 %v: %v", key, err)
 		}
 	}
-	if signer, ok := builder.(signer); ok {
-		details.Signature, err = signer.sign(params)
-		if err != nil {
-			return
-		}
-	}
 	if details.CompilerID == "" {
 		details.CompilerID, err = compilerIdentity(params.Compiler)
 		if err != nil {
@@ -120,14 +114,10 @@ func (err *KernelError) Error() string {
 }
 
 type builder interface {
-	build(params Params) error
+	build(params Params) (ImageDetails, error)
 	clean(kernelDir, targetArch string) error
 }
 
-type signer interface {
-	sign(params Params) (string, error)
-}
-
 func getBuilder(targetOS, targetArch, vmType string) (builder, error) {
 	var supported = []struct {
 		OS    string
diff --git a/pkg/build/darwin.go b/pkg/build/darwin.go
index fa4007eb5..fbfbc0adc 100644
--- a/pkg/build/darwin.go
+++ b/pkg/build/darwin.go
@@ -9,9 +9,9 @@ import (
 
 type darwin struct{}
 
-func (ctx darwin) build(params Params) error {
+func (ctx darwin) build(params Params) (ImageDetails, error) {
 	// TODO(HerrSpace): Implement this.
-	return fmt.Errorf("pkg/build: darwin.build not implemented")
+	return ImageDetails{}, fmt.Errorf("pkg/build: darwin.build not implemented")
 }
 
 func (ctx darwin) clean(kernelDir, targetArch string) error {
diff --git a/pkg/build/freebsd.go b/pkg/build/freebsd.go
index f8ac801ea..2d95d2415 100644
--- a/pkg/build/freebsd.go
+++ b/pkg/build/freebsd.go
@@ -16,7 +16,7 @@ import (
 
 type freebsd struct{}
 
-func (ctx freebsd) build(params Params) error {
+func (ctx freebsd) build(params Params) (ImageDetails, error) {
 	confDir := fmt.Sprintf("%v/sys/%v/conf/", params.KernelDir, params.TargetArch)
 	confFile := "SYZKALLER"
 
@@ -38,16 +38,16 @@ options 	DIAGNOSTIC
 `)
 	}
 	if err := osutil.WriteFile(filepath.Join(confDir, confFile), config); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	objPrefix := filepath.Join(params.KernelDir, "obj")
 	if err := ctx.make(params.KernelDir, objPrefix, "kernel-toolchain", "-DNO_CLEAN"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if err := ctx.make(params.KernelDir, objPrefix, "buildkernel", "WITH_EXTRA_TCP_STACKS=",
 		fmt.Sprintf("KERNCONF=%v", confFile)); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	kernelObjDir := filepath.Join(objPrefix, params.KernelDir,
@@ -60,7 +60,7 @@ options 	DIAGNOSTIC
 		fullSrc := filepath.Join(s.dir, s.src)
 		fullDst := filepath.Join(params.OutputDir, s.dst)
 		if err := osutil.CopyFile(fullSrc, fullDst); err != nil {
-			return fmt.Errorf("failed to copy %v -> %v: %v", fullSrc, fullDst, err)
+			return ImageDetails{}, fmt.Errorf("failed to copy %v -> %v: %v", fullSrc, fullDst, err)
 		}
 	}
 
@@ -105,9 +105,9 @@ sudo mdconfig -d -u ${md#md}
 `, objPrefix, params.KernelDir, confFile)
 
 	if debugOut, err := osutil.RunCmd(10*time.Minute, params.OutputDir, "/bin/sh", "-c", script); err != nil {
-		return fmt.Errorf("error copying kernel: %v\n%v", err, debugOut)
+		return ImageDetails{}, fmt.Errorf("error copying kernel: %v\n%v", err, debugOut)
 	}
-	return nil
+	return ImageDetails{}, nil
 }
 
 func (ctx freebsd) clean(kernelDir, targetArch string) error {
diff --git a/pkg/build/fuchsia.go b/pkg/build/fuchsia.go
index 8ad06f1af..4feaefe6a 100644
--- a/pkg/build/fuchsia.go
+++ b/pkg/build/fuchsia.go
@@ -27,15 +27,15 @@ func syzRoot() (string, error) {
 	return filepath.Abs(filepath.Join(filepath.Dir(selfPath), "../.."))
 }
 
-func (fu fuchsia) build(params Params) error {
+func (fu fuchsia) build(params Params) (ImageDetails, error) {
 	syzDir, err := syzRoot()
 	if err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	sysTarget := targets.Get(targets.Fuchsia, params.TargetArch)
 	if sysTarget == nil {
-		return fmt.Errorf("unsupported fuchsia arch %v", params.TargetArch)
+		return ImageDetails{}, fmt.Errorf("unsupported fuchsia arch %v", params.TargetArch)
 	}
 	arch := sysTarget.KernelHeaderArch
 	product := fmt.Sprintf("%s.%s", "core", arch)
@@ -48,16 +48,16 @@ func (fu fuchsia) build(params Params) error {
 		"--variant", "kasan",
 		"--no-goma",
 	); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if _, err := runSandboxed(time.Hour*2, params.KernelDir, "scripts/fx", "clean-build"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	// Add ssh keys to the zbi image so syzkaller can access the fuchsia vm.
 	_, sshKeyPub, err := genSSHKeys(params.OutputDir)
 	if err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	sshZBI := filepath.Join(params.OutputDir, "initrd")
@@ -66,7 +66,7 @@ func (fu fuchsia) build(params Params) error {
 
 	if _, err := osutil.RunCmd(time.Minute, params.KernelDir, "out/"+arch+"/host_x64/zbi",
 		"-o", sshZBI, kernelZBI, "--entry", authorizedKeys); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	// Copy and extend the fvm.
@@ -74,10 +74,10 @@ func (fu fuchsia) build(params Params) error {
 	fvmDst := filepath.Join(params.OutputDir, "image")
 	fvmSrc := filepath.Join(params.KernelDir, "out", arch, "obj/build/images/fvm.blk")
 	if err := osutil.CopyFile(fvmSrc, fvmDst); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	if _, err := osutil.RunCmd(time.Minute*5, params.KernelDir, fvmTool, fvmDst, "extend", "--length", "3G"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	for src, dst := range map[string]string{
@@ -87,10 +87,10 @@ func (fu fuchsia) build(params Params) error {
 		fullSrc := filepath.Join(params.KernelDir, filepath.FromSlash(src))
 		fullDst := filepath.Join(params.OutputDir, filepath.FromSlash(dst))
 		if err := osutil.CopyFile(fullSrc, fullDst); err != nil {
-			return fmt.Errorf("failed to copy %v: %v", src, err)
+			return ImageDetails{}, fmt.Errorf("failed to copy %v: %v", src, err)
 		}
 	}
-	return nil
+	return ImageDetails{}, nil
 }
 
 func (fu fuchsia) clean(kernelDir, targetArch string) error {
diff --git a/pkg/build/gvisor.go b/pkg/build/gvisor.go
index 0925a7b7c..d1fafdf77 100644
--- a/pkg/build/gvisor.go
+++ b/pkg/build/gvisor.go
@@ -19,7 +19,7 @@ type gvisor struct{}
 
 var bazelTargetPath = regexp.MustCompile(`(?sm:.*^)\s*Outputs: \[(.*)\](?sm:$.*)`)
 
-func (gvisor gvisor) build(params Params) error {
+func (gvisor gvisor) build(params Params) (ImageDetails, error) {
 	if params.Compiler == "" {
 		params.Compiler = "bazel"
 	}
@@ -67,7 +67,7 @@ func (gvisor gvisor) build(params Params) error {
 	// on the first build after bazel/deps update. Also other gvisor instances running
 	// on the same machine contribute to longer build times.
 	if _, err := osutil.RunCmd(60*time.Minute, params.KernelDir, params.Compiler, buildArgs...); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	// Find out a path to the runsc binary.
@@ -76,20 +76,20 @@ func (gvisor gvisor) build(params Params) error {
 	log.Logf(0, "bazel: %v", aqueryArgs)
 	out, err := osutil.RunCmd(time.Minute, params.KernelDir, params.Compiler, aqueryArgs...)
 	if err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	match := bazelTargetPath.FindSubmatch(out)
 	if match == nil {
-		return fmt.Errorf("failed to find the runsc binary")
+		return ImageDetails{}, fmt.Errorf("failed to find the runsc binary")
 	}
 	outBinary := filepath.Join(params.KernelDir, filepath.FromSlash(string(match[1])))
 
 	if err := osutil.CopyFile(outBinary, filepath.Join(params.OutputDir, "image")); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	sysTarget := targets.Get(params.TargetOS, params.TargetArch)
-	return osutil.CopyFile(outBinary, filepath.Join(params.OutputDir, "obj", sysTarget.KernelObject))
+	return ImageDetails{}, osutil.CopyFile(outBinary, filepath.Join(params.OutputDir, "obj", sysTarget.KernelObject))
 }
 
 func (gvisor) clean(kernelDir, targetArch string) error {
diff --git a/pkg/build/linux.go b/pkg/build/linux.go
index 7aedaef16..7632712f2 100644
--- a/pkg/build/linux.go
+++ b/pkg/build/linux.go
@@ -24,31 +24,36 @@ import (
 
 type linux struct{}
 
-var _ signer = linux{}
-
-func (linux linux) build(params Params) error {
+func (linux linux) build(params Params) (ImageDetails, error) {
 	if err := linux.buildKernel(params); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	kernelPath := filepath.Join(params.KernelDir, filepath.FromSlash(kernelBin(params.TargetArch)))
 	if fileInfo, err := os.Stat(params.UserspaceDir); err == nil && fileInfo.IsDir() {
 		// The old way of assembling the image from userspace dir.
 		// It should be removed once all syzbot instances are switched.
-		return linux.createImage(params, kernelPath)
-	}
-	if params.VMType == "qemu" {
+		if err := linux.createImage(params, kernelPath); err != nil {
+			return ImageDetails{}, err
+		}
+	} else if params.VMType == "qemu" {
 		// If UserspaceDir is a file (image) and we use qemu, we just copy image and kernel to the output dir
 		// assuming that qemu will use injected kernel boot. In this mode we also assume password/key-less ssh.
 		if err := osutil.CopyFile(kernelPath, filepath.Join(params.OutputDir, "kernel")); err != nil {
-			return err
+			return ImageDetails{}, err
 		}
-		return osutil.CopyFile(params.UserspaceDir, filepath.Join(params.OutputDir, "image"))
+		if err := osutil.CopyFile(params.UserspaceDir, filepath.Join(params.OutputDir, "image")); err != nil {
+			return ImageDetails{}, err
+		}
+	} else if err := embedLinuxKernel(params, kernelPath); err != nil {
+		return ImageDetails{}, err
 	}
-	return embedLinuxKernel(params, kernelPath)
-}
-
-func (linux linux) sign(params Params) (string, error) {
-	return elfBinarySignature(filepath.Join(params.OutputDir, "obj", "vmlinux"))
+	signature, err := elfBinarySignature(filepath.Join(params.OutputDir, "obj", "vmlinux"))
+	if err != nil {
+		return ImageDetails{}, err
+	}
+	return ImageDetails{
+		Signature: signature,
+	}, nil
 }
 
 func (linux linux) buildKernel(params Params) error {
diff --git a/pkg/build/netbsd.go b/pkg/build/netbsd.go
index 89b22cf82..b569b9833 100644
--- a/pkg/build/netbsd.go
+++ b/pkg/build/netbsd.go
@@ -22,23 +22,23 @@ import (
 
 type netbsd struct{}
 
-func (ctx netbsd) build(params Params) error {
+func (ctx netbsd) build(params Params) (ImageDetails, error) {
 	const kernelName = "GENERIC_SYZKALLER"
 	confDir := fmt.Sprintf("%v/sys/arch/%v/conf", params.KernelDir, params.TargetArch)
 	compileDir := fmt.Sprintf("%v/sys/arch/%v/compile/obj/%v", params.KernelDir, params.TargetArch, kernelName)
 
 	if err := osutil.WriteFile(filepath.Join(confDir, kernelName), params.Config); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	// Clear the tools.
 	if _, err := osutil.RunCmd(5*time.Minute, params.KernelDir, "rm", "-rf", "obj/"); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	// Clear the build files.
 	if _, err := osutil.RunCmd(5*time.Minute, params.KernelDir, "rm", "-rf", compileDir); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	if strings.HasSuffix(params.Compiler, "clang++") {
@@ -46,24 +46,24 @@ func (ctx netbsd) build(params Params) error {
 		if _, err := osutil.RunCmd(60*time.Minute, params.KernelDir, "./build.sh", "-m", params.TargetArch,
 			"-U", "-j"+strconv.Itoa(runtime.NumCPU()), "-V", "MKCTF=no",
 			"-V", "MKLLVM=yes", "-V", "MKGCC=no", "-V", "HAVE_LLVM=yes", "tools"); err != nil {
-			return err
+			return ImageDetails{}, err
 		}
 
 		// Build kernel.
 		if _, err := osutil.RunCmd(20*time.Minute, params.KernelDir, "./build.sh", "-m", params.TargetArch,
 			"-U", "-j"+strconv.Itoa(runtime.NumCPU()), "-V", "MKCTF=no",
 			"-V", "MKLLVM=yes", "-V", "MKGCC=no", "-V", "HAVE_LLVM=yes", "kernel="+kernelName); err != nil {
-			return err
+			return ImageDetails{}, err
 		}
 	} else if strings.HasSuffix(params.Compiler, "g++") {
 		if _, err := osutil.RunCmd(30*time.Minute, params.KernelDir, "./build.sh", "-m", params.TargetArch,
 			"-U", "-j"+strconv.Itoa(runtime.NumCPU()), "-V", "MKCTF=no", "tools"); err != nil {
-			return err
+			return ImageDetails{}, err
 		}
 
 		if _, err := osutil.RunCmd(20*time.Minute, params.KernelDir, "./build.sh", "-m", params.TargetArch,
 			"-U", "-j"+strconv.Itoa(runtime.NumCPU()), "-V", "MKCTF=no", "kernel="+kernelName); err != nil {
-			return err
+			return ImageDetails{}, err
 		}
 	}
 
@@ -75,14 +75,14 @@ func (ctx netbsd) build(params Params) error {
 		fullSrc := filepath.Join(s.dir, s.src)
 		fullDst := filepath.Join(params.OutputDir, s.dst)
 		if err := osutil.CopyFile(fullSrc, fullDst); err != nil {
-			return fmt.Errorf("failed to copy %v -> %v: %v", fullSrc, fullDst, err)
+			return ImageDetails{}, fmt.Errorf("failed to copy %v -> %v: %v", fullSrc, fullDst, err)
 		}
 	}
 	keyFile := filepath.Join(params.OutputDir, "key")
 	if err := os.Chmod(keyFile, 0600); err != nil {
-		return fmt.Errorf("failed to chmod 0600 %v: %v", keyFile, err)
+		return ImageDetails{}, fmt.Errorf("failed to chmod 0600 %v: %v", keyFile, err)
 	}
-	return ctx.copyKernelToDisk(params.TargetArch, params.VMType, params.OutputDir,
+	return ImageDetails{}, ctx.copyKernelToDisk(params.TargetArch, params.VMType, params.OutputDir,
 		filepath.Join(compileDir, "netbsd"))
 }
 
diff --git a/pkg/build/openbsd.go b/pkg/build/openbsd.go
index 1446d1e18..60a35d190 100644
--- a/pkg/build/openbsd.go
+++ b/pkg/build/openbsd.go
@@ -15,25 +15,25 @@ import (
 
 type openbsd struct{}
 
-func (ctx openbsd) build(params Params) error {
+func (ctx openbsd) build(params Params) (ImageDetails, error) {
 	const kernelName = "SYZKALLER"
 	confDir := fmt.Sprintf("%v/sys/arch/%v/conf", params.KernelDir, params.TargetArch)
 	compileDir := fmt.Sprintf("%v/sys/arch/%v/compile/%v", params.KernelDir, params.TargetArch, kernelName)
 
 	if err := osutil.WriteFile(filepath.Join(confDir, kernelName), params.Config); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 
 	if err := osutil.MkdirAll(compileDir); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	makefile := []byte(".include \"../Makefile.inc\"\n")
 	if err := osutil.WriteFile(filepath.Join(compileDir, "Makefile"), makefile); err != nil {
-		return err
+		return ImageDetails{}, err
 	}
 	for _, tgt := range []string{"clean", "obj", "config", "all"} {
 		if err := ctx.make(compileDir, tgt); err != nil {
-			return err
+			return ImageDetails{}, err
 		}
 	}
 	for _, s := range []struct{ dir, src, dst string }{
@@ -45,14 +45,14 @@ func (ctx openbsd) build(params Params) error {
 		fullSrc := filepath.Join(s.dir, s.src)
 		fullDst := filepath.Join(params.OutputDir, s.dst)
 		if err := osutil.CopyFile(fullSrc, fullDst); err != nil {
-			return fmt.Errorf("failed to copy %v -> %v: %v", fullSrc, fullDst, err)
+			return ImageDetails{}, fmt.Errorf("failed to copy %v -> %v: %v", fullSrc, fullDst, err)
 		}
 	}
 	if params.VMType == "gce" {
-		return ctx.copyFilesToImage(
+		return ImageDetails{}, ctx.copyFilesToImage(
 			filepath.Join(params.UserspaceDir, "overlay"), params.OutputDir)
 	}
-	return nil
+	return ImageDetails{}, nil
 }
 
 func (ctx openbsd) clean(kernelDir, targetArch string) error {
diff --git a/pkg/build/test.go b/pkg/build/test.go
index 93ae27f96..a4f59d562 100644
--- a/pkg/build/test.go
+++ b/pkg/build/test.go
@@ -5,8 +5,8 @@ package build
 
 type test struct{}
 
-func (tb test) build(params Params) error {
-	return nil
+func (tb test) build(params Params) (ImageDetails, error) {
+	return ImageDetails{}, nil
 }
 
 func (tb test) clean(string, string) error {