Merge pull request #2119 from shirou/fix/darwin-errno-and-libcache

[darwin][process]: fix errno handling and library lifetime on darwin

Author: shirou

cpu/cpu_darwin.go

@@ -143,7 +143,7 @@ func perCPUTimes(sys *common.SystemLib) ([]TimesStat, error) {
 	var cpuload *hostCpuLoadInfoData
 
 	status := sys.HostProcessorInfo(sys.MachHostSelf(), processorCpuLoadInfo,
-		&ncpu, uintptr(unsafe.Pointer(&cpuload)), &count)
+		&ncpu, unsafe.Pointer(&cpuload), &count)
 
 	if status != common.KERN_SUCCESS {
 		return nil, fmt.Errorf("host_processor_info error=%d", status)
@@ -177,7 +177,7 @@ func allCPUTimes(sys *common.SystemLib) ([]TimesStat, error) {
 	count := uint32(cpuStateMax)
 
 	status := sys.HostStatistics(sys.MachHostSelf(), common.HOST_CPU_LOAD_INFO,
-		uintptr(unsafe.Pointer(&cpuload)), &count)
+		unsafe.Pointer(&cpuload), &count)
 
 	if status != common.KERN_SUCCESS {
 		return nil, fmt.Errorf("host_statistics error=%d", status)

disk/disk_darwin.go

@@ -327,7 +327,7 @@ func (i *ioCounters) fillStat(d uint32) (*IOCountersStat, error) {
 	for key, off := range statstab {
 		s := i.cfStr(key)
 		if num := i.corefoundation.CFDictionaryGetValue(uintptr(v), uintptr(s)); num != nil {
-			i.corefoundation.CFNumberGetValue(uintptr(num), common.KCFNumberSInt64Type, uintptr(unsafe.Add(unsafe.Pointer(&stat), off)))
+			i.corefoundation.CFNumberGetValue(uintptr(num), common.KCFNumberSInt64Type, unsafe.Add(unsafe.Pointer(&stat), off))
 		}
 		i.corefoundation.CFRelease(uintptr(s))
 	}

internal/common/common_darwin.go

@@ -27,16 +27,37 @@ const (
 	SystemLibPath         = "/usr/lib/libSystem.B.dylib"
 )
 
+// Library handles are opened once and shared for the process lifetime.
+// Opening and closing them on every call causes SIGBUS/SIGSEGV crashes because
+// the Go runtime (GC, timers) can interact with invalidated library handles
+// after Dlclose. Sharing also keeps the resolved-symbol cache in fnMap warm,
+// so a symbol lookup is not repeated on every call.
+// See: https://github.com/shirou/gopsutil/issues/1832
+var (
+	libCacheMu sync.Mutex
+	libCache   = make(map[string]*library)
+)
+
 func newLibrary(path string) (*library, error) {
-	lib, err := purego.Dlopen(path, purego.RTLD_LAZY|purego.RTLD_GLOBAL)
+	libCacheMu.Lock()
+	defer libCacheMu.Unlock()
+
+	if lib, ok := libCache[path]; ok {
+		return lib, nil
+	}
+
+	handle, err := purego.Dlopen(path, purego.RTLD_LAZY|purego.RTLD_GLOBAL)
 	if err != nil {
 		return nil, err
 	}
 
-	return &library{
-		handle: lib,
+	lib := &library{
+		handle: handle,
 		fnMap:  make(map[string]any),
-	}, nil
+	}
+	libCache[path] = lib
+
+	return lib, nil
 }
 
 func (lib *library) Dlsym(symbol string) (uintptr, error) {
@@ -69,9 +90,10 @@ func getFunc[T any](lib *library, symbol string) T {
 	return dlfun.fn
 }
 
-func (lib *library) Close() {
-	purego.Dlclose(lib.handle)
-}
+// Close is a no-op, kept so that existing defer-Close call sites keep working.
+// Library handles are shared process-wide and are deliberately never unloaded;
+// see newLibrary for why.
+func (*library) Close() {}
 
 type dlFunc[T any] struct {
 	sym string
@@ -103,12 +125,12 @@ func (c *CoreFoundationLib) CFGetTypeID(cf uintptr) int64 {
 	return fn(cf)
 }
 
-func (c *CoreFoundationLib) CFNumberCreate(allocator uintptr, theType int64, valuePtr uintptr) unsafe.Pointer {
+func (c *CoreFoundationLib) CFNumberCreate(allocator uintptr, theType int64, valuePtr unsafe.Pointer) unsafe.Pointer {
 	fn := getFunc[CFNumberCreateFunc](c.library, "CFNumberCreate")
 	return fn(allocator, theType, valuePtr)
 }
 
-func (c *CoreFoundationLib) CFNumberGetValue(num uintptr, theType int64, valuePtr uintptr) bool {
+func (c *CoreFoundationLib) CFNumberGetValue(num uintptr, theType int64, valuePtr unsafe.Pointer) bool {
 	fn := getFunc[CFNumberGetValueFunc](c.library, "CFNumberGetValue")
 	return fn(num, theType, valuePtr)
 }
@@ -247,7 +269,9 @@ func (l *IOKitLib) IOObjectRelease(object uint32) int32 {
 	return fn(object)
 }
 
-func (l *IOKitLib) IOConnectCallStructMethod(connection, selector uint32, inputStruct, inputStructCnt, outputStruct uintptr, outputStructCnt *uintptr) int32 {
+func (l *IOKitLib) IOConnectCallStructMethod(connection, selector uint32, inputStruct unsafe.Pointer, inputStructCnt uintptr,
+	outputStruct unsafe.Pointer, outputStructCnt *uintptr,
+) int32 {
 	fn := getFunc[IOConnectCallStructMethodFunc](l.library, "IOConnectCallStructMethod")
 	return fn(connection, selector, inputStruct, inputStructCnt, outputStruct, outputStructCnt)
 }
@@ -294,14 +318,14 @@ func NewSystemLib() (*SystemLib, error) {
 	return &SystemLib{library}, nil
 }
 
-func (s *SystemLib) HostProcessorInfo(host uint32, flavor int32, outProcessorCount *uint32, outProcessorInfo uintptr,
+func (s *SystemLib) HostProcessorInfo(host uint32, flavor int32, outProcessorCount *uint32, outProcessorInfo unsafe.Pointer,
 	outProcessorInfoCnt *uint32,
 ) int32 {
 	fn := getFunc[HostProcessorInfoFunc](s.library, "host_processor_info")
 	return fn(host, flavor, outProcessorCount, outProcessorInfo, outProcessorInfoCnt)
 }
 
-func (s *SystemLib) HostStatistics(host uint32, flavor int32, hostInfoOut uintptr, hostInfoOutCnt *uint32) int32 {
+func (s *SystemLib) HostStatistics(host uint32, flavor int32, hostInfoOut unsafe.Pointer, hostInfoOutCnt *uint32) int32 {
 	fn := getFunc[HostStatisticsFunc](s.library, "host_statistics")
 	return fn(host, flavor, hostInfoOut, hostInfoOutCnt)
 }
@@ -316,7 +340,7 @@ func (s *SystemLib) MachTaskSelf() uint32 {
 	return fn()
 }
 
-func (s *SystemLib) MachTimeBaseInfo(info uintptr) int32 {
+func (s *SystemLib) MachTimeBaseInfo(info unsafe.Pointer) int32 {
 	fn := getFunc[MachTimeBaseInfoFunc](s.library, "mach_timebase_info")
 	return fn(info)
 }
@@ -326,12 +350,12 @@ func (s *SystemLib) VMDeallocate(targetTask uint32, vmAddress, vmSize uintptr) i
 	return fn(targetTask, vmAddress, vmSize)
 }
 
-func (s *SystemLib) ProcPidPath(pid int32, buffer uintptr, bufferSize uint32) int32 {
+func (s *SystemLib) ProcPidPath(pid int32, buffer unsafe.Pointer, bufferSize uint32) int32 {
 	fn := getFunc[ProcPidPathFunc](s.library, "proc_pidpath")
 	return fn(pid, buffer, bufferSize)
 }
 
-func (s *SystemLib) ProcPidInfo(pid, flavor int32, arg uint64, buffer uintptr, bufferSize int32) int32 {
+func (s *SystemLib) ProcPidInfo(pid, flavor int32, arg uint64, buffer unsafe.Pointer, bufferSize int32) int32 {
 	fn := getFunc[ProcPidInfoFunc](s.library, "proc_pidinfo")
 	return fn(pid, flavor, arg, buffer, bufferSize)
 }
@@ -341,16 +365,36 @@ func (s *SystemLib) ProcPidRusage(pid, flavor int32, buffer unsafe.Pointer) int3
 	return fn(pid, flavor, buffer)
 }
 
-func (s *SystemLib) Errno() int32 {
+// ErrnoLocation returns a pointer to the calling OS thread's errno, as given by
+// libc's __error(). The pointer is thread-local, so callers must hold
+// runtime.LockOSThread() across this call, the libc call being checked, and the
+// dereference of the returned pointer.
+//
+// Resolve the pointer *before* the libc call whose errno is to be inspected.
+// Resolving a symbol performs a dlsym and allocates, and either may overwrite
+// errno; doing it afterwards would race with the value being read.
+func (s *SystemLib) ErrnoLocation() *int32 {
 	fn := getFunc[ErrnoFunc](s.library, "__error")
-	return *fn()
+	return fn()
 }
 
 // status codes
 const (
 	KERN_SUCCESS = 0
 )
 
+// Arguments that point at Go memory are declared as unsafe.Pointer, a Go
+// pointer type, or a slice -- never as uintptr. purego maps uintptr to
+// uintptr_t, i.e. a plain integer: it neither keeps the pointee alive nor makes
+// it escape, so a Go local stays on the goroutine stack and the address goes
+// stale the moment the stack grows. Every such call then reads or writes the old
+// stack and silently sees or produces zeroes. The other kinds are passed through
+// reflect.Value.Pointer() and stay reachable for the duration of the call.
+//
+// uintptr remains correct for handles that are not Go memory: CoreFoundation and
+// IOKit object references, mach ports, addresses of dylib data symbols obtained
+// through Dlsym, and kernel-allocated vm addresses.
+
 // IOKit types and constants.
 type (
 	IOServiceGetMatchingServiceFunc       func(mainPort uint32, matching uintptr) uint32
@@ -365,7 +409,8 @@ type (
 	IORegistryEntryCreateCFPropertiesFunc func(entry uint32, properties unsafe.Pointer, allocator uintptr, options uint32) int32
 	IOObjectConformsToFunc                func(object uint32, className string) bool
 	IOObjectReleaseFunc                   func(object uint32) int32
-	IOConnectCallStructMethodFunc         func(connection, selector uint32, inputStruct, inputStructCnt, outputStruct uintptr, outputStructCnt *uintptr) int32
+	IOConnectCallStructMethodFunc         func(connection, selector uint32, inputStruct unsafe.Pointer, inputStructCnt uintptr,
+		outputStruct unsafe.Pointer, outputStructCnt *uintptr) int32
 
 	IOHIDEventSystemClientCreateFunc      func(allocator uintptr) unsafe.Pointer
 	IOHIDEventSystemClientSetMatchingFunc func(client, match uintptr) int32
@@ -390,10 +435,14 @@ const (
 )
 
 // CoreFoundation types and constants.
+//
+// valuePtr on CFNumberCreate and CFNumberGetValue points at a caller-owned Go
+// value that CoreFoundation reads from or writes into, hence unsafe.Pointer; see
+// the note above the IOKit function types.
 type (
 	CFGetTypeIDFunc        func(cf uintptr) int64
-	CFNumberCreateFunc     func(allocator uintptr, theType int64, valuePtr uintptr) unsafe.Pointer
-	CFNumberGetValueFunc   func(num uintptr, theType int64, valuePtr uintptr) bool
+	CFNumberCreateFunc     func(allocator uintptr, theType int64, valuePtr unsafe.Pointer) unsafe.Pointer
+	CFNumberGetValueFunc   func(num uintptr, theType int64, valuePtr unsafe.Pointer) bool
 	CFDictionaryCreateFunc func(allocator uintptr, keys, values *unsafe.Pointer, numValues int64,
 		keyCallBacks, valueCallBacks uintptr) unsafe.Pointer
 	CFDictionaryAddValueFunc      func(theDict, key, value uintptr)
@@ -423,13 +472,16 @@ type MachTimeBaseInfo struct {
 	Denom uint32
 }
 
+// Buffers the kernel writes into are declared as unsafe.Pointer; see the note
+// above the IOKit function types. vmAddress on VMDeallocateFunc stays a uintptr
+// because it names kernel-allocated memory rather than Go memory.
 type (
-	HostProcessorInfoFunc func(host uint32, flavor int32, outProcessorCount *uint32, outProcessorInfo uintptr,
+	HostProcessorInfoFunc func(host uint32, flavor int32, outProcessorCount *uint32, outProcessorInfo unsafe.Pointer,
 		outProcessorInfoCnt *uint32) int32
-	HostStatisticsFunc   func(host uint32, flavor int32, hostInfoOut uintptr, hostInfoOutCnt *uint32) int32
+	HostStatisticsFunc   func(host uint32, flavor int32, hostInfoOut unsafe.Pointer, hostInfoOutCnt *uint32) int32
 	MachHostSelfFunc     func() uint32
 	MachTaskSelfFunc     func() uint32
-	MachTimeBaseInfoFunc func(info uintptr) int32
+	MachTimeBaseInfoFunc func(info unsafe.Pointer) int32
 	VMDeallocateFunc     func(targetTask uint32, vmAddress, vmSize uintptr) int32
 )
 
@@ -450,8 +502,8 @@ const (
 )
 
 type (
-	ProcPidPathFunc   func(pid int32, buffer uintptr, bufferSize uint32) int32
-	ProcPidInfoFunc   func(pid, flavor int32, arg uint64, buffer uintptr, bufferSize int32) int32
+	ProcPidPathFunc   func(pid int32, buffer unsafe.Pointer, bufferSize uint32) int32
+	ProcPidInfoFunc   func(pid, flavor int32, arg uint64, buffer unsafe.Pointer, bufferSize int32) int32
 	ProcPidRusageFunc func(pid, flavor int32, buffer unsafe.Pointer) int32
 	ErrnoFunc         func() *int32
 )
@@ -525,15 +577,18 @@ func NewSMC() (*SMC, error) {
 	}, nil
 }
 
-func (s *SMC) CallStruct(selector uint32, inputStruct, inputStructCnt, outputStruct uintptr, outputStructCnt *uintptr) int32 {
+func (s *SMC) CallStruct(selector uint32, inputStruct unsafe.Pointer, inputStructCnt uintptr,
+	outputStruct unsafe.Pointer, outputStructCnt *uintptr,
+) int32 {
 	return s.lib.IOConnectCallStructMethod(s.conn, selector, inputStruct, inputStructCnt, outputStruct, outputStructCnt)
 }
 
+// Close releases the SMC connection. The IOKit handle itself is shared
+// process-wide and is deliberately left open; see newLibrary.
 func (s *SMC) Close() error {
 	if result := s.lib.IOServiceClose(s.conn); result != 0 {
 		return errors.New("ERROR: IOServiceClose failed")
 	}
-	s.lib.Close()
 	return nil
 }
 
@@ -555,10 +610,6 @@ func (s CStr) Ptr() *byte {
 	return &s[0]
 }
 
-func (s CStr) Addr() uintptr {
-	return uintptr(unsafe.Pointer(s.Ptr()))
-}
-
 func (s CStr) GoString() string {
 	if s == nil {
 		return ""

mem/mem_darwin.go

@@ -95,7 +95,7 @@ func VirtualMemoryWithContext(_ context.Context) (*VirtualMemoryStat, error) {
 	var vmstat vmStatisticsData
 
 	status := sys.HostStatistics(sys.MachHostSelf(), common.HOST_VM_INFO,
-		uintptr(unsafe.Pointer(&vmstat)), &count)
+		unsafe.Pointer(&vmstat), &count)
 
 	if status != common.KERN_SUCCESS {
 		return nil, fmt.Errorf("host_statistics error=%d", status)

process/process.go

@@ -109,11 +109,11 @@ type IOCountersStat struct {
 	ReadCount uint64 `json:"readCount"`
 	// WriteCount is a number of read I/O operations such as syscalls.
 	WriteCount uint64 `json:"writeCount"`
-	// ReadBytes is a number of all I/O read in bytes.
-	// On Darwin, only disk I/O bytes are available.
+	// ReadBytes is a number of all I/O read in bytes. This includes disk I/O on Linux and Windows.
+	// Darwin does not expose this and reports 0; use DiskReadBytes there.
 	ReadBytes uint64 `json:"readBytes"`
-	// WriteBytes is a number of all I/O written in bytes.
-	// On Darwin, only disk I/O bytes are available.
+	// WriteBytes is a number of all I/O written in bytes. This includes disk I/O on Linux and Windows.
+	// Darwin does not expose this and reports 0; use DiskWriteBytes there.
 	WriteBytes uint64 `json:"writeBytes"`
 	// DiskReadBytes is a number of disk I/O read in bytes. Currently, Linux and Darwin have this value.
 	DiskReadBytes uint64 `json:"diskReadBytes"`