fix(deps): update module github.com/shirou/gopsutil/v4 to v4.25.2

Signed-off-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

go.mod

@@ -63,7 +63,7 @@ require (
 	github.com/opencontainers/selinux v1.11.1
 	github.com/openshift/imagebuilder v1.2.15
 	github.com/rootless-containers/rootlesskit/v2 v2.3.2
-	github.com/shirou/gopsutil/v4 v4.25.1
+	github.com/shirou/gopsutil/v4 v4.25.2
 	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/cobra v1.9.1
 	github.com/spf13/pflag v1.0.6
@@ -146,7 +146,7 @@ require (
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
 	github.com/golang/protobuf v1.5.4 // indirect
-	github.com/google/go-cmp v0.6.0 // indirect
+	github.com/google/go-cmp v0.7.0 // indirect
 	github.com/google/go-containerregistry v0.20.2 // indirect
 	github.com/google/go-intervals v0.0.2 // indirect
 	github.com/google/pprof v0.0.0-20241210010833-40e02aabc2ad // indirect

go.sum

@@ -245,8 +245,9 @@ github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/go-containerregistry v0.20.2 h1:B1wPJ1SN/S7pB+ZAimcciVD+r+yV/l/DSArMxlbwseo=
 github.com/google/go-containerregistry v0.20.2/go.mod h1:z38EKdKh4h7IP2gSfUUqEvalZBqs6AoLeWfUy34nQC8=
 github.com/google/go-intervals v0.0.2 h1:FGrVEiUnTRKR8yE04qzXYaJMtnIYqobR5QbblK3ixcM=
@@ -453,8 +454,8 @@ github.com/segmentio/ksuid v1.0.4 h1:sBo2BdShXjmcugAMwjugoGUdUV0pcxY5mW4xKRn3v4c
 github.com/segmentio/ksuid v1.0.4/go.mod h1:/XUiZBD3kVx5SmUOl55voK5yeAbBNNIed+2O73XgrPE=
 github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
 github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
-github.com/shirou/gopsutil/v4 v4.25.1 h1:QSWkTc+fu9LTAWfkZwZ6j8MSUk4A2LV7rbH0ZqmLjXs=
+github.com/shirou/gopsutil/v4 v4.25.2 h1:NMscG3l2CqtWFS86kj3vP7soOczqrQYIEhO/pMvvQkk=
-github.com/shirou/gopsutil/v4 v4.25.1/go.mod h1:RoUCUpndaJFtT+2zsZzzmhvbfGoDCJ7nFXKJf8GqJbI=
+github.com/shirou/gopsutil/v4 v4.25.2/go.mod h1:34gBYJzyqCDT11b6bMHP0XCvWeU3J61XRT7a2EmCRTA=
 github.com/sigstore/fulcio v1.6.4 h1:d86obfxUAG3Y6CYwOx1pdwCZwKmROB6w6927pKOVIRY=
 github.com/sigstore/fulcio v1.6.4/go.mod h1:Y6bn3i3KGhXpaHsAtYP3Z4Np0+VzCo1fLv8Ci6mbPDs=
 github.com/sigstore/rekor v1.3.8 h1:B8kJI8mpSIXova4Jxa6vXdJyysRxFGsEsLKBDl0rRjA=

vendor/github.com/google/go-cmp/cmp/internal/function/func.go

@@ -19,6 +19,7 @@ const (
 
 	tbFunc  // func(T) bool
 	ttbFunc // func(T, T) bool
+	ttiFunc // func(T, T) int
 	trbFunc // func(T, R) bool
 	tibFunc // func(T, I) bool
 	trFunc  // func(T) R
@@ -28,11 +29,13 @@ const (
 	Transformer       = trFunc  // func(T) R
 	ValueFilter       = ttbFunc // func(T, T) bool
 	Less              = ttbFunc // func(T, T) bool
+	Compare           = ttiFunc // func(T, T) int
 	ValuePredicate    = tbFunc  // func(T) bool
 	KeyValuePredicate = trbFunc // func(T, R) bool
 )
 
 var boolType = reflect.TypeOf(true)
+var intType = reflect.TypeOf(0)
 
 // IsType reports whether the reflect.Type is of the specified function type.
 func IsType(t reflect.Type, ft funcType) bool {
@@ -49,6 +52,10 @@ func IsType(t reflect.Type, ft funcType) bool {
 		if ni == 2 && no == 1 && t.In(0) == t.In(1) && t.Out(0) == boolType {
 			return true
 		}
+	case ttiFunc: // func(T, T) int
+		if ni == 2 && no == 1 && t.In(0) == t.In(1) && t.Out(0) == intType {
+			return true
+		}
 	case trbFunc: // func(T, R) bool
 		if ni == 2 && no == 1 && t.Out(0) == boolType {
 			return true

vendor/github.com/google/go-cmp/cmp/options.go

@@ -232,7 +232,15 @@ func (validator) apply(s *state, vx, vy reflect.Value) {
 		if t := s.curPath.Index(-2).Type(); t.Name() != "" {
 			// Named type with unexported fields.
 			name = fmt.Sprintf("%q.%v", t.PkgPath(), t.Name()) // e.g., "path/to/package".MyType
-			if _, ok := reflect.New(t).Interface().(error); ok {
+			isProtoMessage := func(t reflect.Type) bool {
+				m, ok := reflect.PointerTo(t).MethodByName("ProtoReflect")
+				return ok && m.Type.NumIn() == 1 && m.Type.NumOut() == 1 &&
+					m.Type.Out(0).PkgPath() == "google.golang.org/protobuf/reflect/protoreflect" &&
+					m.Type.Out(0).Name() == "Message"
+			}
+			if isProtoMessage(t) {
+				help = `consider using "google.golang.org/protobuf/testing/protocmp".Transform to compare proto.Message types`
+			} else if _, ok := reflect.New(t).Interface().(error); ok {
 				help = "consider using cmpopts.EquateErrors to compare error values"
 			} else if t.Comparable() {
 				help = "consider using cmpopts.EquateComparable to compare comparable Go types"

vendor/github.com/shirou/gopsutil/v4/cpu/cpu_dragonfly.go

@@ -11,9 +11,10 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/shirou/gopsutil/v4/internal/common"
 	"github.com/tklauser/go-sysconf"
 	"golang.org/x/sys/unix"
+
+	"github.com/shirou/gopsutil/v4/internal/common"
 )
 
 var (
@@ -135,7 +136,7 @@ func parseDmesgBoot(fileName string) (InfoStat, error) {
 			c.VendorID = matches[1]
 			t, err := strconv.ParseInt(matches[2], 10, 32)
 			if err != nil {
-				return c, fmt.Errorf("unable to parse DragonflyBSD CPU stepping information from %q: %v", line, err)
+				return c, fmt.Errorf("unable to parse DragonflyBSD CPU stepping information from %q: %w", line, err)
 			}
 			c.Stepping = int32(t)
 		} else if matches := featuresMatch.FindStringSubmatch(line); matches != nil {

vendor/github.com/shirou/gopsutil/v4/cpu/cpu_netbsd.go

@@ -57,7 +57,7 @@ func TimesWithContext(ctx context.Context, percpu bool) (ret []TimesStat, err er
 
 	ncpu, err := unix.SysctlUint32("hw.ncpu")
 	if err != nil {
-		return
+		return //nolint:nakedret //FIXME
 	}
 
 	var i uint32

vendor/github.com/shirou/gopsutil/v4/cpu/cpu_openbsd.go

@@ -9,9 +9,10 @@ import (
 	"runtime"
 	"unsafe"
 
-	"github.com/shirou/gopsutil/v4/internal/common"
 	"github.com/tklauser/go-sysconf"
 	"golang.org/x/sys/unix"
+
+	"github.com/shirou/gopsutil/v4/internal/common"
 )
 
 const (
@@ -74,7 +75,7 @@ func TimesWithContext(ctx context.Context, percpu bool) (ret []TimesStat, err er
 
 	ncpu, err := unix.SysctlUint32("hw.ncpu")
 	if err != nil {
-		return
+		return //nolint:nakedret //FIXME
 	}
 
 	var i uint32

vendor/github.com/shirou/gopsutil/v4/cpu/cpu_plan9.go

@@ -9,6 +9,7 @@ import (
 	"runtime"
 
 	stats "github.com/lufia/plan9stats"
+
 	"github.com/shirou/gopsutil/v4/internal/common"
 )
 

vendor/github.com/shirou/gopsutil/v4/cpu/cpu_solaris.go

@@ -42,7 +42,7 @@ var kstatSplit = regexp.MustCompile(`[:\s]+`)
 func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
 	kstatSysOut, err := invoke.CommandWithContext(ctx, "kstat", "-p", "cpu_stat:*:*:/^idle$|^user$|^kernel$|^iowait$|^swap$/")
 	if err != nil {
-		return nil, fmt.Errorf("cannot execute kstat: %s", err)
+		return nil, fmt.Errorf("cannot execute kstat: %w", err)
 	}
 	cpu := make(map[float64]float64)
 	idle := make(map[float64]float64)
@@ -57,29 +57,29 @@ func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
 		}
 		cpuNumber, err := strconv.ParseFloat(fields[1], 64)
 		if err != nil {
-			return nil, fmt.Errorf("cannot parse cpu number: %s", err)
+			return nil, fmt.Errorf("cannot parse cpu number: %w", err)
 		}
 		cpu[cpuNumber] = cpuNumber
 		switch fields[3] {
 		case "idle":
 			idle[cpuNumber], err = strconv.ParseFloat(fields[4], 64)
 			if err != nil {
-				return nil, fmt.Errorf("cannot parse idle: %s", err)
+				return nil, fmt.Errorf("cannot parse idle: %w", err)
 			}
 		case "user":
 			user[cpuNumber], err = strconv.ParseFloat(fields[4], 64)
 			if err != nil {
-				return nil, fmt.Errorf("cannot parse user: %s", err)
+				return nil, fmt.Errorf("cannot parse user: %w", err)
 			}
 		case "kernel":
 			kern[cpuNumber], err = strconv.ParseFloat(fields[4], 64)
 			if err != nil {
-				return nil, fmt.Errorf("cannot parse kernel: %s", err)
+				return nil, fmt.Errorf("cannot parse kernel: %w", err)
 			}
 		case "iowait":
 			iowt[cpuNumber], err = strconv.ParseFloat(fields[4], 64)
 			if err != nil {
-				return nil, fmt.Errorf("cannot parse iowait: %s", err)
+				return nil, fmt.Errorf("cannot parse iowait: %w", err)
 			}
 			//not sure how this translates, don't report, add to kernel, something else?
 			/*case "swap":
@@ -121,22 +121,22 @@ func Info() ([]InfoStat, error) {
 func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
 	psrInfoOut, err := invoke.CommandWithContext(ctx, "psrinfo", "-p", "-v")
 	if err != nil {
-		return nil, fmt.Errorf("cannot execute psrinfo: %s", err)
+		return nil, fmt.Errorf("cannot execute psrinfo: %w", err)
 	}
 
 	procs, err := parseProcessorInfo(string(psrInfoOut))
 	if err != nil {
-		return nil, fmt.Errorf("error parsing psrinfo output: %s", err)
+		return nil, fmt.Errorf("error parsing psrinfo output: %w", err)
 	}
 
 	isaInfoOut, err := invoke.CommandWithContext(ctx, "isainfo", "-b", "-v")
 	if err != nil {
-		return nil, fmt.Errorf("cannot execute isainfo: %s", err)
+		return nil, fmt.Errorf("cannot execute isainfo: %w", err)
 	}
 
 	flags, err := parseISAInfo(string(isaInfoOut))
 	if err != nil {
-		return nil, fmt.Errorf("error parsing isainfo output: %s", err)
+		return nil, fmt.Errorf("error parsing isainfo output: %w", err)
 	}
 
 	result := make([]InfoStat, 0, len(flags))
@@ -160,7 +160,7 @@ func parseISAInfo(cmdOutput string) ([]string, error) {
 	}
 
 	flags := make([]string, len(words)-4)
-	for i, val := range words[4:] {
+	for i, val := range words[4:] { //nolint:gosimple //FIXME
 		flags[i] = val
 	}
 	sort.Strings(flags)
@@ -194,7 +194,7 @@ func parseProcessorInfo(cmdOutput string) ([]InfoStat, error) {
 		if physicalCPU[psrStepOffset] != "" {
 			stepParsed, err := strconv.ParseInt(physicalCPU[psrStepOffset], 10, 32)
 			if err != nil {
-				return nil, fmt.Errorf("cannot parse value %q for step as 32-bit integer: %s", physicalCPU[9], err)
+				return nil, fmt.Errorf("cannot parse value %q for step as 32-bit integer: %w", physicalCPU[9], err)
 			}
 			step = int32(stepParsed)
 		}
@@ -202,7 +202,7 @@ func parseProcessorInfo(cmdOutput string) ([]InfoStat, error) {
 		if physicalCPU[psrClockOffset] != "" {
 			clockParsed, err := strconv.ParseInt(physicalCPU[psrClockOffset], 10, 64)
 			if err != nil {
-				return nil, fmt.Errorf("cannot parse value %q for clock as 32-bit integer: %s", physicalCPU[10], err)
+				return nil, fmt.Errorf("cannot parse value %q for clock as 32-bit integer: %w", physicalCPU[10], err)
 			}
 			clock = float64(clockParsed)
 		}
@@ -214,7 +214,7 @@ func parseProcessorInfo(cmdOutput string) ([]InfoStat, error) {
 		case physicalCPU[psrNumCoresOffset] != "":
 			numCores, err = strconv.ParseInt(physicalCPU[psrNumCoresOffset], 10, 32)
 			if err != nil {
-				return nil, fmt.Errorf("cannot parse value %q for core count as 32-bit integer: %s", physicalCPU[1], err)
+				return nil, fmt.Errorf("cannot parse value %q for core count as 32-bit integer: %w", physicalCPU[1], err)
 			}
 
 			for i := 0; i < int(numCores); i++ {
@@ -235,12 +235,12 @@ func parseProcessorInfo(cmdOutput string) ([]InfoStat, error) {
 		case physicalCPU[psrNumCoresHTOffset] != "":
 			numCores, err = strconv.ParseInt(physicalCPU[psrNumCoresHTOffset], 10, 32)
 			if err != nil {
-				return nil, fmt.Errorf("cannot parse value %q for core count as 32-bit integer: %s", physicalCPU[3], err)
+				return nil, fmt.Errorf("cannot parse value %q for core count as 32-bit integer: %w", physicalCPU[3], err)
 			}
 
 			numHT, err = strconv.ParseInt(physicalCPU[psrNumHTOffset], 10, 32)
 			if err != nil {
-				return nil, fmt.Errorf("cannot parse value %q for hyperthread count as 32-bit integer: %s", physicalCPU[4], err)
+				return nil, fmt.Errorf("cannot parse value %q for hyperthread count as 32-bit integer: %w", physicalCPU[4], err)
 			}
 
 			for i := 0; i < int(numCores); i++ {

vendor/github.com/shirou/gopsutil/v4/cpu/cpu_windows.go

@@ -6,11 +6,13 @@ package cpu
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"unsafe"
 
-	"github.com/shirou/gopsutil/v4/internal/common"
 	"github.com/yusufpapurcu/wmi"
 	"golang.org/x/sys/windows"
+
+	"github.com/shirou/gopsutil/v4/internal/common"
 )
 
 var procGetNativeSystemInfo = common.Modkernel32.NewProc("GetNativeSystemInfo")
@@ -110,7 +112,7 @@ func InfoWithContext(ctx context.Context) ([]InfoStat, error) {
 
 		cpu := InfoStat{
 			CPU:        int32(i),
-			Family:     fmt.Sprintf("%d", l.Family),
+			Family:     strconv.FormatUint(uint64(l.Family), 10),
 			VendorID:   l.Manufacturer,
 			ModelName:  l.Name,
 			Cores:      int32(l.NumberOfLogicalProcessors),

vendor/github.com/shirou/gopsutil/v4/internal/common/binary.go

@@ -137,7 +137,7 @@ func (bigEndian) GoString() string { return "binary.BigEndian" }
 // blank (_) field names is skipped; i.e., blank field names
 // may be used for padding.
 // When reading into a struct, all non-blank fields must be exported.
-func Read(r io.Reader, order ByteOrder, data interface{}) error {
+func Read(r io.Reader, order ByteOrder, data any) error {
 	// Fast path for basic types and slices.
 	if n := intDataSize(data); n != 0 {
 		var b [8]byte
@@ -229,7 +229,7 @@ func Read(r io.Reader, order ByteOrder, data interface{}) error {
 // and read from successive fields of the data.
 // When writing structs, zero values are written for fields
 // with blank (_) field names.
-func Write(w io.Writer, order ByteOrder, data interface{}) error {
+func Write(w io.Writer, order ByteOrder, data any) error {
 	// Fast path for basic types and slices.
 	if n := intDataSize(data); n != 0 {
 		var b [8]byte
@@ -339,7 +339,7 @@ func Write(w io.Writer, order ByteOrder, data interface{}) error {
 // Size returns how many bytes Write would generate to encode the value v, which
 // must be a fixed-size value or a slice of fixed-size values, or a pointer to such data.
 // If v is neither of these, Size returns -1.
-func Size(v interface{}) int {
+func Size(v any) int {
 	return dataSize(reflect.Indirect(reflect.ValueOf(v)))
 }
 
@@ -607,7 +607,7 @@ func (e *encoder) skip(v reflect.Value) {
 
 // intDataSize returns the size of the data required to represent the data when encoded.
 // It returns zero if the type cannot be implemented by the fast path in Read or Write.
-func intDataSize(data interface{}) int {
+func intDataSize(data any) int {
 	switch data := data.(type) {
 	case int8, *int8, *uint8:
 		return 1

vendor/github.com/shirou/gopsutil/v4/internal/common/common.go

@@ -311,7 +311,7 @@ func IntContains(target []int, src int) bool {
 
 // get struct attributes.
 // This method is used only for debugging platform dependent code.
-func attributes(m interface{}) map[string]reflect.Type {
+func attributes(m any) map[string]reflect.Type {
 	typ := reflect.TypeOf(m)
 	if typ.Kind() == reflect.Ptr {
 		typ = typ.Elem()

vendor/github.com/shirou/gopsutil/v4/internal/common/common_darwin.go

@@ -5,6 +5,7 @@ package common
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"os/exec"
@@ -306,7 +307,7 @@ const (
 
 func NewSMC(ioKit *Library) (*SMC, error) {
 	if ioKit.path != IOKit {
-		return nil, fmt.Errorf("library is not IOKit")
+		return nil, errors.New("library is not IOKit")
 	}
 
 	ioServiceGetMatchingService := GetFunc[IOServiceGetMatchingServiceFunc](ioKit, IOServiceGetMatchingServiceSym)
@@ -324,7 +325,7 @@ func NewSMC(ioKit *Library) (*SMC, error) {
 
 	var conn uint32
 	if result := ioServiceOpen(service, machTaskSelf(), 0, &conn); result != 0 {
-		return nil, fmt.Errorf("ERROR: IOServiceOpen failed")
+		return nil, errors.New("ERROR: IOServiceOpen failed")
 	}
 
 	ioObjectRelease(service)
@@ -343,7 +344,7 @@ func (s *SMC) Close() error {
 	ioServiceClose := GetFunc[IOServiceCloseFunc](s.lib, IOServiceCloseSym)
 
 	if result := ioServiceClose(s.conn); result != 0 {
-		return fmt.Errorf("ERROR: IOServiceClose failed")
+		return errors.New("ERROR: IOServiceClose failed")
 	}
 	return nil
 }
@@ -367,8 +368,8 @@ func (s CStr) Ptr() *byte {
 	return &s[0]
 }
 
-func (c CStr) Addr() uintptr {
+func (s CStr) Addr() uintptr {
-	return uintptr(unsafe.Pointer(c.Ptr()))
+	return uintptr(unsafe.Pointer(s.Ptr()))
 }
 
 func (s CStr) GoString() string {

vendor/github.com/shirou/gopsutil/v4/internal/common/common_windows.go

@@ -197,7 +197,7 @@ func ProcessorQueueLengthCounter() (*Win32PerformanceCounter, error) {
 }
 
 // WMIQueryWithContext - wraps wmi.Query with a timed-out context to avoid hanging
-func WMIQueryWithContext(ctx context.Context, query string, dst interface{}, connectServerArgs ...interface{}) error {
+func WMIQueryWithContext(ctx context.Context, query string, dst any, connectServerArgs ...any) error {
 	if _, ok := ctx.Deadline(); !ok {
 		ctxTimeout, cancel := context.WithTimeout(ctx, Timeout)
 		defer cancel()
@@ -273,19 +273,19 @@ type SystemExtendedHandleInformation struct {
 // CallWithExpandingBuffer https://github.com/hillu/go-ntdll
 func CallWithExpandingBuffer(fn func() NtStatus, buf *[]byte, resultLength *uint32) NtStatus {
 	for {
-		if st := fn(); st == STATUS_BUFFER_OVERFLOW || st == STATUS_BUFFER_TOO_SMALL || st == STATUS_INFO_LENGTH_MISMATCH {
+		st := fn()
+		if st == STATUS_BUFFER_OVERFLOW || st == STATUS_BUFFER_TOO_SMALL || st == STATUS_INFO_LENGTH_MISMATCH {
 			if int(*resultLength) <= cap(*buf) {
 				(*reflect.SliceHeader)(unsafe.Pointer(buf)).Len = int(*resultLength)
 			} else {
 				*buf = make([]byte, int(*resultLength))
 			}
 			continue
-		} else {
-			if !st.IsError() {
-				*buf = (*buf)[:int(*resultLength)]
-			}
-			return st
 		}
+		if !st.IsError() {
+			*buf = (*buf)[:int(*resultLength)]
+		}
+		return st
 	}
 }
 

vendor/github.com/shirou/gopsutil/v4/mem/mem_openbsd.go

@@ -10,8 +10,9 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/shirou/gopsutil/v4/internal/common"
 	"golang.org/x/sys/unix"
+
+	"github.com/shirou/gopsutil/v4/internal/common"
 )
 
 func GetPageSize() (uint64, error) {

vendor/github.com/shirou/gopsutil/v4/mem/mem_plan9.go

@@ -8,6 +8,7 @@ import (
 	"os"
 
 	stats "github.com/lufia/plan9stats"
+
 	"github.com/shirou/gopsutil/v4/internal/common"
 )
 

vendor/github.com/shirou/gopsutil/v4/mem/mem_solaris.go

@@ -11,8 +11,9 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/shirou/gopsutil/v4/internal/common"
 	"github.com/tklauser/go-sysconf"
+
+	"github.com/shirou/gopsutil/v4/internal/common"
 )
 
 // VirtualMemory for Solaris is a minimal implementation which only returns
@@ -24,17 +25,17 @@ func VirtualMemory() (*VirtualMemoryStat, error) {
 func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
 	result := &VirtualMemoryStat{}
 
-	zoneName, err := zoneName()
+	zoneName, err := zoneName() //nolint:contextcheck //FIXME
 	if err != nil {
 		return nil, err
 	}
 
 	if zoneName == "global" {
-		cap, err := globalZoneMemoryCapacity()
+		capacity, err := globalZoneMemoryCapacity() //nolint:contextcheck //FIXME
 		if err != nil {
 			return nil, err
 		}
-		result.Total = cap
+		result.Total = capacity
 		freemem, err := globalZoneFreeMemory(ctx)
 		if err != nil {
 			return nil, err
@@ -43,11 +44,11 @@ func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) {
 		result.Free = freemem
 		result.Used = result.Total - result.Free
 	} else {
-		cap, err := nonGlobalZoneMemoryCapacity()
+		capacity, err := nonGlobalZoneMemoryCapacity() //nolint:contextcheck //FIXME
 		if err != nil {
 			return nil, err
 		}
-		result.Total = cap
+		result.Total = capacity
 	}
 
 	return result, nil

vendor/github.com/shirou/gopsutil/v4/mem/mem_windows.go

@@ -9,8 +9,9 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/shirou/gopsutil/v4/internal/common"
 	"golang.org/x/sys/windows"
+
+	"github.com/shirou/gopsutil/v4/internal/common"
 )
 
 var (

vendor/github.com/shirou/gopsutil/v4/net/net.go

@@ -255,7 +255,7 @@ func InterfacesWithContext(ctx context.Context) (InterfaceStatList, error) {
 	return ret, nil
 }
 
-func getIOCountersAll(n []IOCountersStat) ([]IOCountersStat, error) {
+func getIOCountersAll(n []IOCountersStat) []IOCountersStat {
 	r := IOCountersStat{
 		Name: "all",
 	}
@@ -270,7 +270,7 @@ func getIOCountersAll(n []IOCountersStat) ([]IOCountersStat, error) {
 		r.Dropout += nic.Dropout
 	}
 
-	return []IOCountersStat{r}, nil
+	return []IOCountersStat{r}
 }
 
 // NetIOCounters returns network I/O statistics for every network

vendor/github.com/shirou/gopsutil/v4/net/net_darwin.go

@@ -30,14 +30,14 @@ func parseNetstatLine(line string) (stat *IOCountersStat, linkID *uint, err erro
 
 	if columns[0] == "Name" {
 		err = errNetstatHeader
-		return
+		return //nolint:nakedret //FIXME
 	}
 
 	// try to extract the numeric value from <Link#123>
 	if subMatch := netstatLinkRegexp.FindStringSubmatch(columns[2]); len(subMatch) == 2 {
 		numericValue, err = strconv.ParseUint(subMatch[1], 10, 64)
 		if err != nil {
-			return
+			return //nolint:nakedret //FIXME
 		}
 		linkIDUint := uint(numericValue)
 		linkID = &linkIDUint
@@ -51,7 +51,7 @@ func parseNetstatLine(line string) (stat *IOCountersStat, linkID *uint, err erro
 	}
 	if numberColumns < 11 || numberColumns > 13 {
 		err = fmt.Errorf("Line %q do have an invalid number of columns %d", line, numberColumns)
-		return
+		return //nolint:nakedret //FIXME
 	}
 
 	parsed := make([]uint64, 0, 7)
@@ -74,7 +74,7 @@ func parseNetstatLine(line string) (stat *IOCountersStat, linkID *uint, err erro
 		}
 
 		if numericValue, err = strconv.ParseUint(target, 10, 64); err != nil {
-			return
+			return //nolint:nakedret //FIXME
 		}
 		parsed = append(parsed, numericValue)
 	}
@@ -91,7 +91,7 @@ func parseNetstatLine(line string) (stat *IOCountersStat, linkID *uint, err erro
 	if len(parsed) == 7 {
 		stat.Dropout = parsed[6]
 	}
-	return
+	return //nolint:nakedret //FIXME
 }
 
 type netstatInterface struct {
@@ -249,7 +249,7 @@ func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat,
 	}
 
 	if !pernic {
-		return getIOCountersAll(ret)
+		return getIOCountersAll(ret), nil
 	}
 	return ret, nil
 }

vendor/github.com/shirou/gopsutil/v4/net/net_freebsd.go

@@ -85,7 +85,7 @@ func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat,
 	}
 
 	if !pernic {
-		return getIOCountersAll(ret)
+		return getIOCountersAll(ret), nil
 	}
 
 	return ret, nil

vendor/github.com/shirou/gopsutil/v4/net/net_linux.go

@@ -128,7 +128,7 @@ func IOCountersByFileWithContext(ctx context.Context, pernic bool, filename stri
 	}
 
 	if !pernic {
-		return getIOCountersAll(ret)
+		return getIOCountersAll(ret), nil
 	}
 
 	return ret, nil

vendor/github.com/shirou/gopsutil/v4/net/net_openbsd.go

@@ -150,15 +150,15 @@ func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat,
 		ret = append(ret, ioc)
 	}
 
-	if pernic == false {
+	if !pernic {
-		return getIOCountersAll(ret)
+		return getIOCountersAll(ret), nil
 	}
 
 	return ret, nil
 }
 
 func IOCountersByFileWithContext(ctx context.Context, pernic bool, filename string) ([]IOCountersStat, error) {
-	return IOCounters(pernic)
+	return IOCounters(pernic) //nolint:contextcheck //FIXME
 }
 
 func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) {

vendor/github.com/shirou/gopsutil/v4/net/net_solaris.go

@@ -5,6 +5,7 @@ package net
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"regexp"
 	"runtime"
@@ -29,7 +30,7 @@ func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat,
 
 	lines := strings.Split(strings.TrimSpace(string(kstatSysOut)), "\n")
 	if len(lines) == 0 {
-		return nil, fmt.Errorf("no interface found")
+		return nil, errors.New("no interface found")
 	}
 	rbytes64arr := make(map[string]uint64)
 	ipackets64arr := make(map[string]uint64)
@@ -104,7 +105,7 @@ func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat,
 	}
 
 	if !pernic {
-		return getIOCountersAll(ret)
+		return getIOCountersAll(ret), nil
 	}
 
 	return ret, nil

vendor/github.com/shirou/gopsutil/v4/net/net_windows.go

@@ -5,14 +5,16 @@ package net
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net"
 	"os"
 	"syscall"
 	"unsafe"
 
-	"github.com/shirou/gopsutil/v4/internal/common"
 	"golang.org/x/sys/windows"
+
+	"github.com/shirou/gopsutil/v4/internal/common"
 )
 
 var (
@@ -191,13 +193,13 @@ func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat,
 	}
 
 	if !pernic {
-		return getIOCountersAll(counters)
+		return getIOCountersAll(counters), nil
 	}
 	return counters, nil
 }
 
 func IOCountersByFileWithContext(ctx context.Context, pernic bool, filename string) ([]IOCountersStat, error) {
-	return IOCounters(pernic)
+	return IOCounters(pernic) //nolint:contextcheck //FIXME
 }
 
 func ConnectionsWithContext(ctx context.Context, kind string) ([]ConnectionStat, error) {
@@ -238,7 +240,7 @@ func getProcInet(kinds []netConnectionKindType, pid int32) ([]ConnectionStat, er
 
 func getNetStatWithKind(kindType netConnectionKindType) ([]ConnectionStat, error) {
 	if kindType.filename == "" {
-		return nil, fmt.Errorf("kind filename must be required")
+		return nil, errors.New("kind filename must be required")
 	}
 
 	switch kindType.filename {
@@ -326,7 +328,7 @@ func getTableUintptr(family uint32, buf []byte) uintptr {
 	return p
 }
 
-func getTableInfo(filename string, table interface{}) (index, step, length int) {
+func getTableInfo(filename string, table any) (index, step, length int) {
 	switch filename {
 	case kindTCP4.filename:
 		index = int(unsafe.Sizeof(table.(pmibTCPTableOwnerPidAll).DwNumEntries))
@@ -360,7 +362,7 @@ func getTCPConnections(family uint32) ([]ConnectionStat, error) {
 	)
 
 	if family == 0 {
-		return nil, fmt.Errorf("faimly must be required")
+		return nil, errors.New("faimly must be required")
 	}
 
 	for {
@@ -390,7 +392,7 @@ func getTCPConnections(family uint32) ([]ConnectionStat, error) {
 		if err == nil {
 			break
 		}
-		if err != windows.ERROR_INSUFFICIENT_BUFFER {
+		if !errors.Is(err, windows.ERROR_INSUFFICIENT_BUFFER) {
 			return nil, err
 		}
 		buf = make([]byte, size)
@@ -441,7 +443,7 @@ func getUDPConnections(family uint32) ([]ConnectionStat, error) {
 	)
 
 	if family == 0 {
-		return nil, fmt.Errorf("faimly must be required")
+		return nil, errors.New("faimly must be required")
 	}
 
 	for {
@@ -473,7 +475,7 @@ func getUDPConnections(family uint32) ([]ConnectionStat, error) {
 		if err == nil {
 			break
 		}
-		if err != windows.ERROR_INSUFFICIENT_BUFFER {
+		if !errors.Is(err, windows.ERROR_INSUFFICIENT_BUFFER) {
 			return nil, err
 		}
 		buf = make([]byte, size)

vendor/github.com/shirou/gopsutil/v4/process/process.go

@@ -408,6 +408,11 @@ func (p *Process) Cmdline() (string, error) {
 
 // CmdlineSlice returns the command line arguments of the process as a slice with each
 // element being an argument.
+//
+// On Windows, this assumes the command line is encoded according to the convention accepted by
+// [golang.org/x/sys/windows.CmdlineToArgv] (the most common convention). If this is not suitable,
+// you should instead use [Process.Cmdline] and parse the command line according to your specific
+// requirements.
 func (p *Process) CmdlineSlice() ([]string, error) {
 	return p.CmdlineSliceWithContext(context.Background())
 }

vendor/github.com/shirou/gopsutil/v4/process/process_darwin.go

@@ -7,6 +7,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"path/filepath"
 	"runtime"
@@ -348,7 +349,7 @@ func (p *Process) CwdWithContext(ctx context.Context) (string, error) {
 	ret := procPidInfo(p.Pid, common.PROC_PIDVNODEPATHINFO, 0, uintptr(unsafe.Pointer(&vpi)), vpiSize)
 	errno, _ := lib.Dlsym("errno")
 	err = *(**unix.Errno)(unsafe.Pointer(&errno))
-	if err == unix.EPERM {
+	if errors.Is(err, unix.EPERM) {
 		return "", ErrorNotPermitted
 	}
 
@@ -373,11 +374,11 @@ func procArgs(pid int32) ([]byte, int, error) {
 	return procargs, int(binary.LittleEndian.Uint32(nargs)), nil
 }
 
-func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error) {
+func (p *Process) CmdlineSliceWithContext(_ context.Context) ([]string, error) {
-	return p.cmdlineSliceWithContext(ctx, true)
+	return p.cmdlineSlice()
 }
 
-func (p *Process) cmdlineSliceWithContext(ctx context.Context, fallback bool) ([]string, error) {
+func (p *Process) cmdlineSlice() ([]string, error) {
 	pargs, nargs, err := procArgs(p.Pid)
 	if err != nil {
 		return nil, err
@@ -408,8 +409,8 @@ func (p *Process) cmdlineSliceWithContext(ctx context.Context, fallback bool) ([
 }
 
 // cmdNameWithContext returns the command name (including spaces) without any arguments
-func (p *Process) cmdNameWithContext(ctx context.Context) (string, error) {
+func (p *Process) cmdNameWithContext(_ context.Context) (string, error) {
-	r, err := p.cmdlineSliceWithContext(ctx, false)
+	r, err := p.cmdlineSlice()
 	if err != nil {
 		return "", err
 	}

vendor/github.com/shirou/gopsutil/v4/process/process_openbsd.go

@@ -8,7 +8,6 @@ import (
 	"context"
 	"encoding/binary"
 	"errors"
-	"fmt"
 	"io"
 	"path/filepath"
 	"sort"
@@ -16,11 +15,12 @@ import (
 	"strings"
 	"unsafe"
 
-	cpu "github.com/shirou/gopsutil/v4/cpu"
-	"github.com/shirou/gopsutil/v4/internal/common"
-	mem "github.com/shirou/gopsutil/v4/mem"
-	net "github.com/shirou/gopsutil/v4/net"
 	"golang.org/x/sys/unix"
+
+	"github.com/shirou/gopsutil/v4/cpu"
+	"github.com/shirou/gopsutil/v4/internal/common"
+	"github.com/shirou/gopsutil/v4/mem"
+	"github.com/shirou/gopsutil/v4/net"
 )
 
 func pidsWithContext(ctx context.Context) ([]int32, error) {
@@ -130,7 +130,7 @@ func readPtr(r io.Reader) (uintptr, error) {
 		}
 		return uintptr(p), nil
 	default:
-		return 0, fmt.Errorf("unsupported pointer size")
+		return 0, errors.New("unsupported pointer size")
 	}
 }
 

vendor/github.com/shirou/gopsutil/v4/process/process_solaris.go

@@ -247,10 +247,7 @@ func (p *Process) fillFromCmdlineWithContext(ctx context.Context) (string, error
 		return "", err
 	}
 	ret := strings.FieldsFunc(string(cmdline), func(r rune) bool {
-		if r == '\u0000' {
+		return r == '\u0000'
-			return true
-		}
-		return false
 	})
 
 	return strings.Join(ret, " "), nil

vendor/github.com/shirou/gopsutil/v4/process/process_windows.go

@@ -12,16 +12,16 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
-	"strings"
 	"syscall"
 	"time"
 	"unicode/utf16"
 	"unsafe"
 
+	"golang.org/x/sys/windows"
+
 	"github.com/shirou/gopsutil/v4/cpu"
 	"github.com/shirou/gopsutil/v4/internal/common"
 	"github.com/shirou/gopsutil/v4/net"
-	"golang.org/x/sys/windows"
 )
 
 type Signal = syscall.Signal
@@ -245,7 +245,7 @@ func pidsWithContext(ctx context.Context) ([]int32, error) {
 	// inspired by https://gist.github.com/henkman/3083408
 	// and https://github.com/giampaolo/psutil/blob/1c3a15f637521ba5c0031283da39c733fda53e4c/psutil/arch/windows/process_info.c#L315-L329
 	var ret []int32
-	var read uint32 = 0
+	var read uint32
 	var psSize uint32 = 1024
 	const dwordSize uint32 = 4
 
@@ -288,10 +288,10 @@ func PidExistsWithContext(ctx context.Context, pid int32) (bool, error) {
 		return false, err
 	}
 	h, err := windows.OpenProcess(windows.SYNCHRONIZE, false, uint32(pid))
-	if err == windows.ERROR_ACCESS_DENIED {
+	if errors.Is(err, windows.ERROR_ACCESS_DENIED) {
 		return true, nil
 	}
-	if err == windows.ERROR_INVALID_PARAMETER {
+	if errors.Is(err, windows.ERROR_INVALID_PARAMETER) {
 		return false, nil
 	}
 	if err != nil {
@@ -330,7 +330,7 @@ func (p *Process) NameWithContext(ctx context.Context) (string, error) {
 
 	exe, err := p.ExeWithContext(ctx)
 	if err != nil {
-		return "", fmt.Errorf("could not get Name: %s", err)
+		return "", fmt.Errorf("could not get Name: %w", err)
 	}
 
 	return filepath.Base(exe), nil
@@ -370,7 +370,7 @@ func (p *Process) ExeWithContext(ctx context.Context) (string, error) {
 func (p *Process) CmdlineWithContext(_ context.Context) (string, error) {
 	cmdline, err := getProcessCommandLine(p.Pid)
 	if err != nil {
-		return "", fmt.Errorf("could not get CommandLine: %s", err)
+		return "", fmt.Errorf("could not get CommandLine: %w", err)
 	}
 	return cmdline, nil
 }
@@ -380,13 +380,33 @@ func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error)
 	if err != nil {
 		return nil, err
 	}
-	return strings.Split(cmdline, " "), nil
+	return parseCmdline(cmdline)
+}
+
+func parseCmdline(cmdline string) ([]string, error) {
+	cmdlineptr, err := windows.UTF16PtrFromString(cmdline)
+	if err != nil {
+		return nil, err
+	}
+
+	var argc int32
+	argvptr, err := windows.CommandLineToArgv(cmdlineptr, &argc)
+	if err != nil {
+		return nil, err
+	}
+	defer windows.LocalFree(windows.Handle(uintptr(unsafe.Pointer(argvptr))))
+
+	argv := make([]string, argc)
+	for i, v := range (*argvptr)[:argc] {
+		argv[i] = windows.UTF16ToString((*v)[:])
+	}
+	return argv, nil
 }
 
 func (p *Process) createTimeWithContext(ctx context.Context) (int64, error) {
 	ru, err := getRusage(p.Pid)
 	if err != nil {
-		return 0, fmt.Errorf("could not get CreationDate: %s", err)
+		return 0, fmt.Errorf("could not get CreationDate: %w", err)
 	}
 
 	return ru.CreationTime.Nanoseconds() / 1000000, nil
@@ -394,7 +414,7 @@ func (p *Process) createTimeWithContext(ctx context.Context) (int64, error) {
 
 func (p *Process) CwdWithContext(_ context.Context) (string, error) {
 	h, err := windows.OpenProcess(processQueryInformation|windows.PROCESS_VM_READ, false, uint32(p.Pid))
-	if err == windows.ERROR_ACCESS_DENIED || err == windows.ERROR_INVALID_PARAMETER {
+	if errors.Is(err, windows.ERROR_ACCESS_DENIED) || errors.Is(err, windows.ERROR_INVALID_PARAMETER) {
 		return "", nil
 	}
 	if err != nil {
@@ -822,9 +842,9 @@ func (p *Process) KillWithContext(ctx context.Context) error {
 }
 
 func (p *Process) EnvironWithContext(ctx context.Context) ([]string, error) {
-	envVars, err := getProcessEnvironmentVariables(p.Pid, ctx)
+	envVars, err := getProcessEnvironmentVariables(ctx, p.Pid)
 	if err != nil {
-		return nil, fmt.Errorf("could not get environment variables: %s", err)
+		return nil, fmt.Errorf("could not get environment variables: %w", err)
 	}
 	return envVars, nil
 }
@@ -844,7 +864,7 @@ func (p *Process) setPpid(ppid int32) {
 	p.parent = ppid
 }
 
-func getFromSnapProcess(pid int32) (int32, int32, string, error) {
+func getFromSnapProcess(pid int32) (int32, int32, string, error) { //nolint:unparam //FIXME
 	snap, err := windows.CreateToolhelp32Snapshot(windows.TH32CS_SNAPPROCESS, uint32(pid))
 	if err != nil {
 		return 0, 0, "", err
@@ -872,7 +892,7 @@ func ProcessesWithContext(ctx context.Context) ([]*Process, error) {
 
 	pids, err := PidsWithContext(ctx)
 	if err != nil {
-		return out, fmt.Errorf("could not get Processes %s", err)
+		return out, fmt.Errorf("could not get Processes %w", err)
 	}
 
 	for _, pid := range pids {
@@ -963,13 +983,13 @@ func getUserProcessParams32(handle windows.Handle) (rtlUserProcessParameters32,
 
 	buf := readProcessMemory(syscall.Handle(handle), true, pebAddress, uint(unsafe.Sizeof(processEnvironmentBlock32{})))
 	if len(buf) != int(unsafe.Sizeof(processEnvironmentBlock32{})) {
-		return rtlUserProcessParameters32{}, fmt.Errorf("cannot read process PEB")
+		return rtlUserProcessParameters32{}, errors.New("cannot read process PEB")
 	}
 	peb := (*processEnvironmentBlock32)(unsafe.Pointer(&buf[0]))
 	userProcessAddress := uint64(peb.ProcessParameters)
 	buf = readProcessMemory(syscall.Handle(handle), true, userProcessAddress, uint(unsafe.Sizeof(rtlUserProcessParameters32{})))
 	if len(buf) != int(unsafe.Sizeof(rtlUserProcessParameters32{})) {
-		return rtlUserProcessParameters32{}, fmt.Errorf("cannot read user process parameters")
+		return rtlUserProcessParameters32{}, errors.New("cannot read user process parameters")
 	}
 	return *(*rtlUserProcessParameters32)(unsafe.Pointer(&buf[0])), nil
 }
@@ -982,13 +1002,13 @@ func getUserProcessParams64(handle windows.Handle) (rtlUserProcessParameters64,
 
 	buf := readProcessMemory(syscall.Handle(handle), false, pebAddress, uint(unsafe.Sizeof(processEnvironmentBlock64{})))
 	if len(buf) != int(unsafe.Sizeof(processEnvironmentBlock64{})) {
-		return rtlUserProcessParameters64{}, fmt.Errorf("cannot read process PEB")
+		return rtlUserProcessParameters64{}, errors.New("cannot read process PEB")
 	}
 	peb := (*processEnvironmentBlock64)(unsafe.Pointer(&buf[0]))
 	userProcessAddress := peb.ProcessParameters
 	buf = readProcessMemory(syscall.Handle(handle), false, userProcessAddress, uint(unsafe.Sizeof(rtlUserProcessParameters64{})))
 	if len(buf) != int(unsafe.Sizeof(rtlUserProcessParameters64{})) {
-		return rtlUserProcessParameters64{}, fmt.Errorf("cannot read user process parameters")
+		return rtlUserProcessParameters64{}, errors.New("cannot read user process parameters")
 	}
 	return *(*rtlUserProcessParameters64)(unsafe.Pointer(&buf[0])), nil
 }
@@ -1038,9 +1058,9 @@ func is32BitProcess(h windows.Handle) bool {
 	return procIs32Bits
 }
 
-func getProcessEnvironmentVariables(pid int32, ctx context.Context) ([]string, error) {
+func getProcessEnvironmentVariables(ctx context.Context, pid int32) ([]string, error) {
 	h, err := windows.OpenProcess(processQueryInformation|windows.PROCESS_VM_READ, false, uint32(pid))
-	if err == windows.ERROR_ACCESS_DENIED || err == windows.ERROR_INVALID_PARAMETER {
+	if errors.Is(err, windows.ERROR_ACCESS_DENIED) || errors.Is(err, windows.ERROR_INVALID_PARAMETER) {
 		return nil, nil
 	}
 	if err != nil {
@@ -1124,7 +1144,7 @@ func (p *processReader) Read(buf []byte) (int, error) {
 
 func getProcessCommandLine(pid int32) (string, error) {
 	h, err := windows.OpenProcess(processQueryInformation|windows.PROCESS_VM_READ, false, uint32(pid))
-	if err == windows.ERROR_ACCESS_DENIED || err == windows.ERROR_INVALID_PARAMETER {
+	if errors.Is(err, windows.ERROR_ACCESS_DENIED) || errors.Is(err, windows.ERROR_INVALID_PARAMETER) {
 		return "", nil
 	}
 	if err != nil {

vendor/github.com/shirou/gopsutil/v4/process/process_windows_32bit.go

@@ -8,8 +8,9 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/shirou/gopsutil/v4/internal/common"
 	"golang.org/x/sys/windows"
+
+	"github.com/shirou/gopsutil/v4/internal/common"
 )
 
 type PROCESS_MEMORY_COUNTERS struct {
@@ -39,30 +40,27 @@ func queryPebAddress(procHandle syscall.Handle, is32BitProcess bool) (uint64, er
 		)
 		if status := windows.NTStatus(ret); status == windows.STATUS_SUCCESS {
 			return uint64(info.PebBaseAddress), nil
-		} else {
-			return 0, windows.NTStatus(ret)
-		}
-	} else {
-		// we are on a 32-bit process reading an external 64-bit process
-		if common.ProcNtWow64QueryInformationProcess64.Find() == nil { // avoid panic
-			var info processBasicInformation64
-
-			ret, _, _ := common.ProcNtWow64QueryInformationProcess64.Call(
-				uintptr(procHandle),
-				uintptr(common.ProcessBasicInformation),
-				uintptr(unsafe.Pointer(&info)),
-				uintptr(unsafe.Sizeof(info)),
-				uintptr(0),
-			)
-			if status := windows.NTStatus(ret); status == windows.STATUS_SUCCESS {
-				return info.PebBaseAddress, nil
-			} else {
-				return 0, windows.NTStatus(ret)
-			}
-		} else {
-			return 0, errors.New("can't find API to query 64 bit process from 32 bit")
 		}
+		return 0, windows.NTStatus(ret)
 	}
+	// we are on a 32-bit process reading an external 64-bit process
+	if common.ProcNtWow64QueryInformationProcess64.Find() != nil {
+		return 0, errors.New("can't find API to query 64 bit process from 32 bit")
+	}
+	// avoid panic
+	var info processBasicInformation64
+
+	ret, _, _ := common.ProcNtWow64QueryInformationProcess64.Call(
+		uintptr(procHandle),
+		uintptr(common.ProcessBasicInformation),
+		uintptr(unsafe.Pointer(&info)),
+		uintptr(unsafe.Sizeof(info)),
+		uintptr(0),
+	)
+	if status := windows.NTStatus(ret); status == windows.STATUS_SUCCESS {
+		return info.PebBaseAddress, nil
+	}
+	return 0, windows.NTStatus(ret)
 }
 
 func readProcessMemory(h syscall.Handle, is32BitProcess bool, address uint64, size uint) []byte {

vendor/github.com/shirou/gopsutil/v4/process/process_windows_64bit.go

@@ -7,8 +7,9 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/shirou/gopsutil/v4/internal/common"
 	"golang.org/x/sys/windows"
+
+	"github.com/shirou/gopsutil/v4/internal/common"
 )
 
 type PROCESS_MEMORY_COUNTERS struct {
@@ -38,26 +39,23 @@ func queryPebAddress(procHandle syscall.Handle, is32BitProcess bool) (uint64, er
 		)
 		if status := windows.NTStatus(ret); status == windows.STATUS_SUCCESS {
 			return uint64(wow64), nil
-		} else {
-			return 0, windows.NTStatus(ret)
-		}
-	} else {
-		// we are on a 64-bit process reading an external 64-bit process
-		var info processBasicInformation64
-
-		ret, _, _ := common.ProcNtQueryInformationProcess.Call(
-			uintptr(procHandle),
-			uintptr(common.ProcessBasicInformation),
-			uintptr(unsafe.Pointer(&info)),
-			uintptr(unsafe.Sizeof(info)),
-			uintptr(0),
-		)
-		if status := windows.NTStatus(ret); status == windows.STATUS_SUCCESS {
-			return info.PebBaseAddress, nil
-		} else {
-			return 0, windows.NTStatus(ret)
 		}
+		return 0, windows.NTStatus(ret)
 	}
+	// we are on a 64-bit process reading an external 64-bit process
+	var info processBasicInformation64
+
+	ret, _, _ := common.ProcNtQueryInformationProcess.Call(
+		uintptr(procHandle),
+		uintptr(common.ProcessBasicInformation),
+		uintptr(unsafe.Pointer(&info)),
+		uintptr(unsafe.Sizeof(info)),
+		uintptr(0),
+	)
+	if status := windows.NTStatus(ret); status == windows.STATUS_SUCCESS {
+		return info.PebBaseAddress, nil
+	}
+	return 0, windows.NTStatus(ret)
 }
 
 func readProcessMemory(procHandle syscall.Handle, _ bool, address uint64, size uint) []byte {

vendor/modules.txt

@@ -659,8 +659,8 @@ github.com/golang/groupcache/lru
 # github.com/golang/protobuf v1.5.4
 ## explicit; go 1.17
 github.com/golang/protobuf/proto
-# github.com/google/go-cmp v0.6.0
+# github.com/google/go-cmp v0.7.0
-## explicit; go 1.13
+## explicit; go 1.21
 github.com/google/go-cmp/cmp
 github.com/google/go-cmp/cmp/internal/diff
 github.com/google/go-cmp/cmp/internal/flags
@@ -998,7 +998,7 @@ github.com/secure-systems-lab/go-securesystemslib/encrypted
 # github.com/segmentio/ksuid v1.0.4
 ## explicit; go 1.12
 github.com/segmentio/ksuid
-# github.com/shirou/gopsutil/v4 v4.25.1
+# github.com/shirou/gopsutil/v4 v4.25.2
 ## explicit; go 1.18
 github.com/shirou/gopsutil/v4/common
 github.com/shirou/gopsutil/v4/cpu