few assorted changes in preparation syz-agent binary

pkg/bisect/bisect.go

@@ -36,8 +36,8 @@ type Config struct {
 	Syzkaller       SyzkallerConfig
 	Repro           ReproConfig
 	Manager         *mgrconfig.Config
-	BuildSemaphore  *instance.Semaphore
-	TestSemaphore   *instance.Semaphore
+	BuildSemaphore  *osutil.Semaphore
+	TestSemaphore   *osutil.Semaphore
 	BuildCPUs       int
 	// CrossTree specifies whether a cross tree bisection is to take place, i.e.
 	// Kernel.Commit is not reachable from Kernel.Branch.

pkg/hash/hash.go

@@ -16,7 +16,12 @@ type Sig [sha1.Size]byte
 func Hash(pieces ...any) Sig {
 	h := sha1.New()
 	for _, data := range pieces {
-		binary.Write(h, binary.LittleEndian, data)
+		if str, ok := data.(string); ok {
+			data = []byte(str)
+		}
+		if err := binary.Write(h, binary.LittleEndian, data); err != nil {
+			panic(err)
+		}
 	}
 	var sig Sig
 	copy(sig[:], h.Sum(nil))

pkg/instance/instance.go

@@ -40,8 +40,8 @@ type Env interface {
 type env struct {
 	cfg           *mgrconfig.Config
 	optionalFlags bool
-	buildSem      *Semaphore
-	testSem       *Semaphore
+	buildSem      *osutil.Semaphore
+	testSem       *osutil.Semaphore
 }
 
 type BuildKernelConfig struct {
@@ -56,7 +56,7 @@ type BuildKernelConfig struct {
 	BuildCPUs    int
 }
 
-func NewEnv(cfg *mgrconfig.Config, buildSem, testSem *Semaphore) (Env, error) {
+func NewEnv(cfg *mgrconfig.Config, buildSem, testSem *osutil.Semaphore) (Env, error) {
 	if !vm.AllowsOvercommit(cfg.Type) {
 		return nil, fmt.Errorf("test instances are not supported for %v VMs", cfg.Type)
 	}
@@ -508,40 +508,6 @@ func RunnerCmd(prog, fwdAddr, os, arch string, poolIdx, vmIdx int, threaded, new
 		"-threaded=%t -new-env=%t", prog, fwdAddr, os, arch, poolIdx, vmIdx, threaded, newEnv)
 }
 
-type Semaphore struct {
-	ch chan struct{}
-}
-
-func NewSemaphore(count int) *Semaphore {
-	s := &Semaphore{
-		ch: make(chan struct{}, count),
-	}
-	for i := 0; i < count; i++ {
-		s.Signal()
-	}
-	return s
-}
-
-func (s *Semaphore) Wait() {
-	<-s.ch
-}
-
-func (s *Semaphore) WaitC() <-chan struct{} {
-	return s.ch
-}
-
-func (s *Semaphore) Available() int {
-	return len(s.ch)
-}
-
-func (s *Semaphore) Signal() {
-	if av := s.Available(); av == cap(s.ch) {
-		// Not super reliable, but let it be here just in case.
-		panic(fmt.Sprintf("semaphore capacity (%d) is exceeded (%d)", cap(s.ch), av))
-	}
-	s.ch <- struct{}{}
-}
-
 // RunSmokeTest executes syz-manager in the smoke test mode and returns two values:
 // The crash report, if the testing failed.
 // An error if there was a problem not related to testing the kernel.

pkg/mgrconfig/load.go

@@ -130,19 +130,9 @@ var (
 
 func SetTargets(cfg *Config) error {
 	var err error
-	cfg.TargetOS, cfg.TargetVMArch, cfg.TargetArch, err = splitTarget(cfg.RawTarget)
-	if err != nil {
-		return err
-	}
-	cfg.Target, err = prog.GetTarget(cfg.TargetOS, cfg.TargetArch)
-	if err != nil {
-		return err
-	}
-	cfg.SysTarget = targets.Get(cfg.TargetOS, cfg.TargetVMArch)
-	if cfg.SysTarget == nil {
-		return fmt.Errorf("unsupported OS/arch: %v/%v", cfg.TargetOS, cfg.TargetVMArch)
-	}
-	return nil
+	cfg.TargetOS, cfg.TargetVMArch, cfg.TargetArch, cfg.Target, cfg.SysTarget,
+		err = SplitTarget(cfg.RawTarget)
+	return err
 }
 
 func Complete(cfg *Config) error {
@@ -402,21 +392,29 @@ func (cfg *Config) completeFocusAreas() error {
 	return nil
 }
 
-func splitTarget(target string) (string, string, string, error) {
-	if target == "" {
-		return "", "", "", fmt.Errorf("target is empty")
+func SplitTarget(str string) (os, vmarch, arch string, target *prog.Target, sysTarget *targets.Target, err error) {
+	if str == "" {
+		err = fmt.Errorf("target is empty")
+		return
 	}
-	targetParts := strings.Split(target, "/")
+	targetParts := strings.Split(str, "/")
 	if len(targetParts) != 2 && len(targetParts) != 3 {
-		return "", "", "", fmt.Errorf("bad config param target")
+		err = fmt.Errorf("bad config param target")
+		return
 	}
-	os := targetParts[0]
-	vmarch := targetParts[1]
-	arch := targetParts[1]
+	os = targetParts[0]
+	vmarch = targetParts[1]
+	arch = targetParts[1]
 	if len(targetParts) == 3 {
 		arch = targetParts[2]
 	}
-	return os, vmarch, arch, nil
+	sysTarget = targets.Get(os, vmarch)
+	if sysTarget == nil {
+		err = fmt.Errorf("unsupported OS/arch: %v/%v", os, vmarch)
+		return
+	}
+	target, err = prog.GetTarget(os, arch)
+	return
 }
 
 func ParseEnabledSyscalls(target *prog.Target, enabled, disabled []string,

pkg/osutil/semaphore.go

@@ -0,0 +1,42 @@
+// Copyright 2025 syzkaller project authors. All rights reserved.
+// Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
+
+package osutil
+
+import (
+	"fmt"
+)
+
+type Semaphore struct {
+	ch chan struct{}
+}
+
+func NewSemaphore(count int) *Semaphore {
+	s := &Semaphore{
+		ch: make(chan struct{}, count),
+	}
+	for i := 0; i < count; i++ {
+		s.Signal()
+	}
+	return s
+}
+
+func (s *Semaphore) Wait() {
+	<-s.ch
+}
+
+func (s *Semaphore) WaitC() <-chan struct{} {
+	return s.ch
+}
+
+func (s *Semaphore) Available() int {
+	return len(s.ch)
+}
+
+func (s *Semaphore) Signal() {
+	if av := s.Available(); av == cap(s.ch) {
+		// Not super reliable, but let it be here just in case.
+		panic(fmt.Sprintf("semaphore capacity (%v) is exceeded (%v)", cap(s.ch), av))
+	}
+	s.ch <- struct{}{}
+}