Fix lints on Darwin

Fixes lint errors lke these:

    Error: pkg/apis/k0s/v1beta1/cplb.go:143:4: SA4023(related information): the lhs of the comparison is the 2nd return value of this function call (staticcheck)
    			k.VRRPInstances[i].Interface, err = getNIC(k.VRRPInstances[i].Interface)
    			^
    Error: pkg/apis/k0s/v1beta1/cplb.go:144:7: SA4023: this comparison is always true (staticcheck)
    			if err != nil {
    			   ^
    Error: pkg/supervisor/supervisor.go:244:2: SA4023(related information): the lhs of the comparison is the 2nd return value of this function call (staticcheck)
    	ph, err := openPID(p)
    	^
    Error: pkg/supervisor/supervisor.go:245:5: SA4023: this comparison is always true (staticcheck)
    	if err != nil {
    	   ^

Signed-off-by: Tom Wieczorek <[email protected]>

Author: twz123

pkg/apis/k0s/v1beta1/cplb.go

@@ -140,10 +140,7 @@ func (k *KeepalivedSpec) validateVRRPInstances(getDefaultNICFn func() (string, e
 			}
 			k.VRRPInstances[i].Interface = nic
 		} else if _, err := net.ParseMAC(k.VRRPInstances[i].Interface); err == nil {
-			k.VRRPInstances[i].Interface, err = getNIC(k.VRRPInstances[i].Interface)
-			if err != nil {
-				errs = append(errs, fmt.Errorf("failed to get NIC for MAC address %s: %w", k.VRRPInstances[i].Interface, err))
-			}
+			macToInterfaceName(&k.VRRPInstances[i].Interface, &errs)
 		}
 
 		if k.VRRPInstances[i].VirtualRouterID == 0 {

pkg/apis/k0s/v1beta1/cplb_linux.go

@@ -32,6 +32,14 @@ func getDefaultNIC() (string, error) {
 	return "", errors.New("default route not found")
 }
 
+func macToInterfaceName(val *string, errs *[]error) {
+	if interfaceName, err := getNIC(*val); err != nil {
+		*errs = append(*errs, fmt.Errorf("failed to get NIC for MAC address %s: %w", *val, err))
+	} else {
+		*val = interfaceName
+	}
+}
+
 func getNIC(mac string) (string, error) {
 	links, err := netlink.LinkList()
 	if err != nil {

pkg/apis/k0s/v1beta1/cplb_other.go

@@ -6,6 +6,7 @@
 package v1beta1
 
 import (
+	"errors"
 	"fmt"
 	"runtime"
 )
@@ -14,6 +15,6 @@ func getDefaultNIC() (string, error) {
 	return "", fmt.Errorf("getDefaultNIC on %s is not supported", runtime.GOOS)
 }
 
-func getNIC(_ string) (string, error) {
-	return "", fmt.Errorf("getNIC on %s is not supported", runtime.GOOS)
+func macToInterfaceName(_ *string, errs *[]error) {
+	*errs = append(*errs, fmt.Errorf("%w on %s: resolving interface names for MAC addresses", errors.ErrUnsupported, runtime.GOOS))
 }

pkg/supervisor/prochandle.go

@@ -1,12 +1,115 @@
+//go:build linux || windows
+
 // SPDX-FileCopyrightText: 2024 k0s authors
 // SPDX-License-Identifier: Apache-2.0
 
 package supervisor
 
 import (
+	"context"
+	"errors"
+	"fmt"
 	"io"
+	"math"
+	"os"
+	"slices"
+	"syscall"
+	"time"
+
+	"k8s.io/apimachinery/pkg/util/wait"
 )
 
+func (s *Supervisor) cleanupPID(pid int) error {
+	ph, err := openPID(pid)
+	if err != nil {
+		if errors.Is(err, syscall.ESRCH) {
+			return nil // no such process, nothing to cleanup
+		}
+		return fmt.Errorf("cannot open process for PID %d from PID file %s: %w", pid, s.PidFile, err)
+	}
+	defer ph.Close()
+
+	if managed, err := s.isK0sManaged(ph); err != nil {
+		if errors.Is(err, os.ErrProcessDone) {
+			return nil
+		}
+		return err
+	} else if !managed {
+		return nil
+	}
+
+	if err := s.terminateAndWait(ph); err != nil {
+		return fmt.Errorf("while waiting for termination of PID %d from PID file %s: %w", pid, s.PidFile, err)
+	}
+
+	return nil
+}
+
+// Tries to gracefully terminate a process and waits for it to exit. If the
+// process is still running after several attempts, it returns an error instead
+// of forcefully killing the process.
+func (s *Supervisor) terminateAndWait(ph procHandle) error {
+	if err := ph.requestGracefulTermination(); err != nil {
+		if errors.Is(err, os.ErrProcessDone) {
+			return nil
+		}
+		return fmt.Errorf("failed to request graceful termination: %w", err)
+	}
+
+	errTimeout := errors.New("process did not terminate in time")
+	ctx, cancel := context.WithTimeoutCause(context.TODO(), s.TimeoutStop, errTimeout)
+	defer cancel()
+	return s.awaitTermination(ctx, ph)
+}
+
+// Checks if the process handle refers to a k0s-managed process. A process is
+// considered k0s-managed if:
+//   - The executable path matches.
+//   - The process environment contains `_K0S_MANAGED=yes`.
+func (s *Supervisor) isK0sManaged(ph procHandle) (bool, error) {
+	if cmd, err := ph.cmdline(); err != nil {
+		// Only error out if the error doesn't indicate that getting the command
+		// line is unsupported. In that case, ignore the error and proceed to
+		// the environment check.
+		if !errors.Is(err, errors.ErrUnsupported) {
+			return false, err
+		}
+	} else if len(cmd) > 0 && cmd[0] != s.BinPath {
+		return false, nil
+	}
+
+	if env, err := ph.environ(); err != nil {
+		return false, err
+	} else if !slices.Contains(env, k0sManaged) {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+func (s *Supervisor) awaitTermination(ctx context.Context, ph procHandle) error {
+	s.log.Debug("Polling for process termination")
+	backoff := wait.Backoff{
+		Duration: 25 * time.Millisecond,
+		Cap:      3 * time.Second,
+		Steps:    math.MaxInt32,
+		Factor:   1.5,
+		Jitter:   0.1,
+	}
+
+	if err := wait.ExponentialBackoffWithContext(ctx, backoff, func(context.Context) (bool, error) {
+		return ph.hasTerminated()
+	}); err != nil {
+		if err == ctx.Err() { //nolint:errorlint // the equal check is intended
+			return context.Cause(ctx)
+		}
+
+		return err
+	}
+
+	return nil
+}
+
 // A handle to a running process. May be used to inspect the process properties
 // and terminate it.
 type procHandle interface {

pkg/supervisor/prochandle_darwin.go

@@ -0,0 +1,16 @@
+//go:build !linux && !windows
+
+// SPDX-FileCopyrightText: 2025 k0s authors
+// SPDX-License-Identifier: Apache-2.0
+
+package supervisor
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+)
+
+func (s *Supervisor) cleanupPID(pid int) error {
+	return fmt.Errorf("%w on %s: cleanup for PID %d from PID file %s", errors.ErrUnsupported, runtime.GOOS, pid, s.PidFile)
+}

pkg/supervisor/prochandle_other.go

@@ -8,20 +8,16 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"slices"
 	"sort"
 	"strconv"
 	"strings"
 	"sync"
-	"syscall"
 	"time"
 
 	"github.com/sirupsen/logrus"
-	"k8s.io/apimachinery/pkg/util/wait"
 
 	"github.com/k0sproject/k0s/internal/pkg/dir"
 	"github.com/k0sproject/k0s/internal/pkg/log"
@@ -241,94 +237,7 @@ func (s *Supervisor) maybeCleanupPIDFile() error {
 		return fmt.Errorf("failed to parse PID file %s: %w", s.PidFile, err)
 	}
 
-	ph, err := openPID(p)
-	if err != nil {
-		if errors.Is(err, syscall.ESRCH) {
-			return nil // no such process, nothing to cleanup
-		}
-		return fmt.Errorf("cannot interact with PID %d from PID file %s: %w", p, s.PidFile, err)
-	}
-	defer ph.Close()
-
-	if managed, err := s.isK0sManaged(ph); err != nil {
-		if errors.Is(err, os.ErrProcessDone) {
-			return nil
-		}
-		return err
-	} else if !managed {
-		return nil
-	}
-
-	if err := s.terminateAndWait(ph); err != nil {
-		return fmt.Errorf("while waiting for termination of PID %d from PID file %s: %w", p, s.PidFile, err)
-	}
-
-	return nil
-}
-
-// Tries to gracefully terminate a process and waits for it to exit. If the
-// process is still running after several attempts, it returns an error instead
-// of forcefully killing the process.
-func (s *Supervisor) terminateAndWait(ph procHandle) error {
-	if err := ph.requestGracefulTermination(); err != nil {
-		if errors.Is(err, os.ErrProcessDone) {
-			return nil
-		}
-		return fmt.Errorf("failed to request graceful termination: %w", err)
-	}
-
-	errTimeout := errors.New("process did not terminate in time")
-	ctx, cancel := context.WithTimeoutCause(context.TODO(), s.TimeoutStop, errTimeout)
-	defer cancel()
-	return s.awaitTermination(ctx, ph)
-}
-
-// Checks if the process handle refers to a k0s-managed process. A process is
-// considered k0s-managed if:
-//   - The executable path matches.
-//   - The process environment contains `_K0S_MANAGED=yes`.
-func (s *Supervisor) isK0sManaged(ph procHandle) (bool, error) {
-	if cmd, err := ph.cmdline(); err != nil {
-		// Only error out if the error doesn't indicate that getting the command
-		// line is unsupported. In that case, ignore the error and proceed to
-		// the environment check.
-		if !errors.Is(err, errors.ErrUnsupported) {
-			return false, err
-		}
-	} else if len(cmd) > 0 && cmd[0] != s.BinPath {
-		return false, nil
-	}
-
-	if env, err := ph.environ(); err != nil {
-		return false, err
-	} else if !slices.Contains(env, k0sManaged) {
-		return false, nil
-	}
-
-	return true, nil
-}
-
-func (s *Supervisor) awaitTermination(ctx context.Context, ph procHandle) error {
-	s.log.Debug("Polling for process termination")
-	backoff := wait.Backoff{
-		Duration: 25 * time.Millisecond,
-		Cap:      3 * time.Second,
-		Steps:    math.MaxInt32,
-		Factor:   1.5,
-		Jitter:   0.1,
-	}
-
-	if err := wait.ExponentialBackoffWithContext(ctx, backoff, func(context.Context) (bool, error) {
-		return ph.hasTerminated()
-	}); err != nil {
-		if err == ctx.Err() { //nolint:errorlint // the equal check is intended
-			return context.Cause(ctx)
-		}
-
-		return err
-	}
-
-	return nil
+	return s.cleanupPID(p)
 }
 
 // Prepare the env for exec: