gpu: fix windows_gpu_info metric (#2130)

internal/headers/gdi32/gdi32.go

@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+
+package gdi32
+
+import (
+	"errors"
+	"fmt"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+)
+
+// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/d3dkmthk/ne-d3dkmthk-_kmtqueryadapterinfotype
+// https://github.com/nalilord/AMDPlugin/blob/bb405b6d58ea543ff630f3488384473bee79f447/Common/d3dkmthk.pas#L54
+const (
+	// KMTQAITYPE_GETSEGMENTSIZE pPrivateDriverData points to a D3DKMT_SEGMENTSIZEINFO structure that contains information about the size of memory and aperture segments.
+	KMTQAITYPE_GETSEGMENTSIZE = 3
+	// KMTQAITYPE_ADAPTERADDRESS pPrivateDriverData points to a D3DKMT_ADAPTERADDRESS structure that contains information about the physical location on the PCI bus of the adapter.
+	KMTQAITYPE_ADAPTERADDRESS = 6
+	// KMTQAITYPE_ADAPTERREGISTRYINFO pPrivateDriverData points to a D3DKMT_ADAPTERREGISTRYINFO structure that contains registry information about the graphics adapter.
+	KMTQAITYPE_ADAPTERREGISTRYINFO = 8
+)
+
+var ErrNoGPUDevices = errors.New("no GPU devices found")
+
+func GetGPUDeviceByLUID(adapterLUID windows.LUID) (GPUDevice, error) {
+	open := D3DKMT_OPENADAPTERFROMLUID{
+		AdapterLUID: adapterLUID,
+	}
+
+	if err := D3DKMTOpenAdapterFromLuid(&open); err != nil {
+		return GPUDevice{}, fmt.Errorf("D3DKMTOpenAdapterFromLuid failed: %w", err)
+	}
+
+	errs := make([]error, 0)
+
+	gpuDevice, err := GetGPUDevice(open.HAdapter)
+	if err != nil {
+		errs = append(errs, fmt.Errorf("GetGPUDevice failed: %w", err))
+	}
+
+	if err := D3DKMTCloseAdapter(&D3DKMT_CLOSEADAPTER{
+		HAdapter: open.HAdapter,
+	}); err != nil {
+		errs = append(errs, fmt.Errorf("D3DKMTCloseAdapter failed: %w", err))
+	}
+
+	if len(errs) > 0 {
+		return gpuDevice, fmt.Errorf("errors occurred while getting GPU device: %w", errors.Join(errs...))
+	}
+
+	gpuDevice.LUID = adapterLUID
+
+	return gpuDevice, nil
+}
+
+func GetGPUDevice(hAdapter D3DKMT_HANDLE) (GPUDevice, error) {
+	var gpuDevice GPUDevice
+
+	// Try segment size first
+	var size D3DKMT_SEGMENTSIZEINFO
+
+	query := D3DKMT_QUERYADAPTERINFO{
+		hAdapter:              hAdapter,
+		queryType:             KMTQAITYPE_GETSEGMENTSIZE,
+		pPrivateDriverData:    unsafe.Pointer(&size),
+		privateDriverDataSize: uint32(unsafe.Sizeof(size)),
+	}
+
+	if err := D3DKMTQueryAdapterInfo(&query); err != nil {
+		return gpuDevice, fmt.Errorf("D3DKMTQueryAdapterInfo (segment size) failed: %w", err)
+	}
+
+	gpuDevice.DedicatedVideoMemorySize = size.DedicatedVideoMemorySize
+	gpuDevice.DedicatedSystemMemorySize = size.DedicatedSystemMemorySize
+	gpuDevice.SharedSystemMemorySize = size.SharedSystemMemorySize
+
+	// Now try registry info
+	var address D3DKMT_ADAPTERADDRESS
+
+	query.queryType = KMTQAITYPE_ADAPTERADDRESS
+	query.pPrivateDriverData = unsafe.Pointer(&address)
+	query.privateDriverDataSize = uint32(unsafe.Sizeof(address))
+
+	if err := D3DKMTQueryAdapterInfo(&query); err != nil {
+		return gpuDevice, fmt.Errorf("D3DKMTQueryAdapterInfo (adapter address) failed: %w", err)
+	}
+
+	gpuDevice.BusNumber = address.BusNumber
+	gpuDevice.DeviceNumber = address.DeviceNumber
+	gpuDevice.FunctionNumber = address.FunctionNumber
+
+	// Now try registry info
+	var info D3DKMT_ADAPTERREGISTRYINFO
+
+	query.queryType = KMTQAITYPE_ADAPTERREGISTRYINFO
+	query.pPrivateDriverData = unsafe.Pointer(&info)
+	query.privateDriverDataSize = uint32(unsafe.Sizeof(info))
+
+	if err := D3DKMTQueryAdapterInfo(&query); err != nil && !errors.Is(err, windows.ERROR_FILE_NOT_FOUND) {
+		return gpuDevice, fmt.Errorf("D3DKMTQueryAdapterInfo (info) failed: %w", err)
+	}
+
+	gpuDevice.AdapterString = windows.UTF16ToString(info.AdapterString[:])
+
+	return gpuDevice, nil
+}
+
+func GetGPUDevices() ([]GPUDevice, error) {
+	gpuDevices := make([]GPUDevice, 0, 2)
+
+	// First call: Get the number of adapters
+	enumAdapters := D3DKMT_ENUMADAPTERS2{
+		NumAdapters: 0,
+		PAdapters:   nil,
+	}
+
+	if err := D3DKMTEnumAdapters2(&enumAdapters); err != nil {
+		return gpuDevices, fmt.Errorf("D3DKMTEnumAdapters2 (get count) failed: %w", err)
+	}
+
+	if enumAdapters.NumAdapters == 0 {
+		return gpuDevices, ErrNoGPUDevices
+	}
+
+	// Second call: Get the actual adapter information
+	pAdapters := make([]D3DKMT_ADAPTERINFO, enumAdapters.NumAdapters)
+	enumAdapters.PAdapters = &pAdapters[0]
+
+	if err := D3DKMTEnumAdapters2(&enumAdapters); err != nil {
+		return gpuDevices, fmt.Errorf("D3DKMTEnumAdapters2 (get adapters) failed: %w", err)
+	}
+
+	var errs []error
+
+	// Process each adapter
+	for i := range enumAdapters.NumAdapters {
+		adapter := pAdapters[i]
+		// Validate handle before using it
+		if adapter.HAdapter == 0 {
+			errs = append(errs, fmt.Errorf("adapter %d has null handle", i))
+
+			continue
+		}
+
+		func() {
+			defer func() {
+				if closeErr := D3DKMTCloseAdapter(&D3DKMT_CLOSEADAPTER{
+					HAdapter: adapter.HAdapter,
+				}); closeErr != nil {
+					errs = append(errs, fmt.Errorf("failed to close adapter %v: %w", adapter.AdapterLUID, closeErr))
+				}
+			}()
+
+			gpuDevice, err := GetGPUDevice(adapter.HAdapter)
+			if err != nil {
+				errs = append(errs, fmt.Errorf("failed to get GPU device for adapter %v: %w", adapter.AdapterLUID, err))
+
+				return
+			}
+
+			gpuDevice.LUID = adapter.AdapterLUID
+
+			gpuDevices = append(gpuDevices, gpuDevice)
+		}()
+	}
+
+	if len(errs) > 0 {
+		return gpuDevices, errors.Join(errs...)
+	}
+
+	if len(gpuDevices) == 0 {
+		return gpuDevices, ErrNoGPUDevices
+	}
+
+	return gpuDevices, nil
+}

internal/headers/gdi32/gdi32_test.go

@@ -13,19 +13,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build windows
-
-package setupapi_test
+package gdi32_test
 
 import (
 	"testing"
 
-	"github.com/prometheus-community/windows_exporter/internal/headers/setupapi"
+	"github.com/prometheus-community/windows_exporter/internal/headers/gdi32"
 	"github.com/stretchr/testify/require"
 )
 
 func TestGetGPUDevices(t *testing.T) {
-	devices, err := setupapi.GetGPUDevices()
+	devices, err := gdi32.GetGPUDevices()
 	require.NoError(t, err, "Failed to get GPU devices")
 
 	require.NotNil(t, devices)

internal/headers/gdi32/syscall.go

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gdi32
+
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/prometheus-community/windows_exporter/internal/headers/ntdll"
+	"golang.org/x/sys/windows"
+)
+
+//nolint:gochecknoglobals
+var (
+	modGdi32                      = windows.NewLazySystemDLL("gdi32.dll")
+	procD3DKMTOpenAdapterFromLuid = modGdi32.NewProc("D3DKMTOpenAdapterFromLuid")
+	procD3DKMTQueryAdapterInfo    = modGdi32.NewProc("D3DKMTQueryAdapterInfo")
+	procD3DKMTCloseAdapter        = modGdi32.NewProc("D3DKMTCloseAdapter")
+	procD3DKMTEnumAdapters2       = modGdi32.NewProc("D3DKMTEnumAdapters2")
+)
+
+func D3DKMTOpenAdapterFromLuid(ptr *D3DKMT_OPENADAPTERFROMLUID) error {
+	ret, _, _ := procD3DKMTOpenAdapterFromLuid.Call(
+		uintptr(unsafe.Pointer(ptr)),
+	)
+	if ret != 0 {
+		return fmt.Errorf("D3DKMTOpenAdapterFromLuid failed: 0x%X: %w", ret, ntdll.RtlNtStatusToDosError(ret))
+	}
+
+	return nil
+}
+
+func D3DKMTEnumAdapters2(ptr *D3DKMT_ENUMADAPTERS2) error {
+	ret, _, _ := procD3DKMTEnumAdapters2.Call(
+		uintptr(unsafe.Pointer(ptr)),
+	)
+	if ret != 0 {
+		return fmt.Errorf("D3DKMTEnumAdapters2 failed: 0x%X: %w", ret, ntdll.RtlNtStatusToDosError(ret))
+	}
+
+	return nil
+}
+
+func D3DKMTQueryAdapterInfo(query *D3DKMT_QUERYADAPTERINFO) error {
+	ret, _, _ := procD3DKMTQueryAdapterInfo.Call(
+		uintptr(unsafe.Pointer(query)),
+	)
+	if ret != 0 {
+		return fmt.Errorf("D3DKMTQueryAdapterInfo failed: 0x%X: %w", ret, ntdll.RtlNtStatusToDosError(ret))
+	}
+
+	return nil
+}
+
+func D3DKMTCloseAdapter(ptr *D3DKMT_CLOSEADAPTER) error {
+	ret, _, _ := procD3DKMTCloseAdapter.Call(
+		uintptr(unsafe.Pointer(ptr)),
+	)
+	if ret != 0 {
+		return fmt.Errorf("D3DKMTCloseAdapter failed: 0x%X: %w", ret, ntdll.RtlNtStatusToDosError(ret))
+	}
+
+	return nil
+}

internal/headers/gdi32/types.go

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+
+package gdi32
+
+import (
+	"unsafe"
+
+	"github.com/prometheus-community/windows_exporter/internal/headers/win32"
+	"golang.org/x/sys/windows"
+)
+
+type D3DKMT_HANDLE = win32.UINT
+
+type D3DKMT_OPENADAPTERFROMLUID struct {
+	AdapterLUID windows.LUID
+	HAdapter    D3DKMT_HANDLE
+}
+
+type D3DKMT_CLOSEADAPTER struct {
+	HAdapter D3DKMT_HANDLE
+}
+
+type D3DKMT_QUERYADAPTERINFO struct {
+	hAdapter              D3DKMT_HANDLE
+	queryType             int32
+	pPrivateDriverData    unsafe.Pointer
+	privateDriverDataSize uint32
+}
+
+type D3DKMT_ENUMADAPTERS2 struct {
+	NumAdapters uint32
+	PAdapters   *D3DKMT_ADAPTERINFO
+}
+
+type D3DKMT_ADAPTERINFO struct {
+	HAdapter     D3DKMT_HANDLE
+	AdapterLUID  windows.LUID
+	NumOfSources win32.ULONG
+	Present      win32.BOOL
+}
+
+type D3DKMT_ADAPTERREGISTRYINFO struct {
+	AdapterString [win32.MAX_PATH]uint16
+	BiosString    [win32.MAX_PATH]uint16
+	DacType       [win32.MAX_PATH]uint16
+	ChipType      [win32.MAX_PATH]uint16
+}
+
+type D3DKMT_SEGMENTSIZEINFO struct {
+	DedicatedVideoMemorySize  uint64
+	DedicatedSystemMemorySize uint64
+	SharedSystemMemorySize    uint64
+}
+
+type D3DKMT_ADAPTERADDRESS struct {
+	BusNumber      win32.UINT
+	DeviceNumber   win32.UINT
+	FunctionNumber win32.UINT
+}
+
+type GPUDevice struct {
+	AdapterString             string
+	LUID                      windows.LUID
+	DedicatedVideoMemorySize  uint64
+	DedicatedSystemMemorySize uint64
+	SharedSystemMemorySize    uint64
+	BusNumber                 win32.UINT
+	DeviceNumber              win32.UINT
+	FunctionNumber            win32.UINT
+}

internal/headers/ntdll/ntdll.go

@@ -15,7 +15,7 @@
 
 //go:build windows
 
-package setupapi
+package ntdll
 
 import (
 	"golang.org/x/sys/windows"
@@ -23,9 +23,15 @@ import (
 
 //nolint:gochecknoglobals
 var (
-	modSetupAPI                           = windows.NewLazySystemDLL("setupapi.dll")
-	procSetupDiGetClassDevsW              = modSetupAPI.NewProc("SetupDiGetClassDevsW")
-	procSetupDiEnumDeviceInfo             = modSetupAPI.NewProc("SetupDiEnumDeviceInfo")
-	procSetupDiGetDeviceRegistryPropertyW = modSetupAPI.NewProc("SetupDiGetDeviceRegistryPropertyW")
-	procSetupDiDestroyDeviceInfoList      = modSetupAPI.NewProc("SetupDiDestroyDeviceInfoList")
+	modNtdll                  = windows.NewLazySystemDLL("ntdll.dll")
+	procRtlNtStatusToDosError = modNtdll.NewProc("RtlNtStatusToDosError")
 )
+
+func RtlNtStatusToDosError(status uintptr) error {
+	ret, _, _ := procRtlNtStatusToDosError.Call(status)
+	if ret == 0 {
+		return nil
+	}
+
+	return windows.Errno(ret)
+}

internal/headers/setupapi/gpu.go

@@ -1,135 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-//
-// Copyright The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package setupapi
-
-import (
-	"sync"
-	"unsafe"
-
-	"golang.org/x/sys/windows"
-)
-
-//nolint:gochecknoglobals
-var GUID_DISPLAY_ADAPTER = sync.OnceValue(func() *windows.GUID {
-	return &windows.GUID{
-		Data1: 0x4d36e968,
-		Data2: 0xe325,
-		Data3: 0x11ce,
-		Data4: [8]byte{0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18},
-	}
-})
-
-func GetGPUDevices() ([]GPUDevice, error) {
-	hDevInfo, _, err := procSetupDiGetClassDevsW.Call(
-		uintptr(unsafe.Pointer(GUID_DISPLAY_ADAPTER())),
-		0,
-		0,
-		DIGCF_PRESENT,
-	)
-
-	if windows.Handle(hDevInfo) == windows.InvalidHandle {
-		return nil, err
-	}
-
-	var (
-		devices        []GPUDevice
-		deviceData     SP_DEVINFO_DATA
-		propertyBuffer [256]uint16
-	)
-
-	deviceData.CbSize = uint32(unsafe.Sizeof(deviceData))
-
-	for i := 0; ; i++ {
-		ret, _, _ := procSetupDiEnumDeviceInfo.Call(hDevInfo, uintptr(i), uintptr(unsafe.Pointer(&deviceData)))
-		if ret == 0 {
-			break // No more devices
-		}
-
-		ret, _, _ = procSetupDiGetDeviceRegistryPropertyW.Call(
-			hDevInfo,
-			uintptr(unsafe.Pointer(&deviceData)),
-			uintptr(SPDRP_DEVICEDESC),
-			0,
-			uintptr(unsafe.Pointer(&propertyBuffer[0])),
-			uintptr(len(propertyBuffer)*2),
-			0,
-		)
-
-		gpuDevice := GPUDevice{}
-
-		if ret == 0 {
-			gpuDevice.DeviceDesc = ""
-		} else {
-			gpuDevice.DeviceDesc = windows.UTF16ToString(propertyBuffer[:])
-		}
-
-		ret, _, _ = procSetupDiGetDeviceRegistryPropertyW.Call(
-			hDevInfo,
-			uintptr(unsafe.Pointer(&deviceData)),
-			uintptr(SPDRP_FRIENDLYNAME),
-			0,
-			uintptr(unsafe.Pointer(&propertyBuffer[0])),
-			uintptr(len(propertyBuffer)*2),
-			0,
-		)
-
-		if ret == 0 {
-			gpuDevice.FriendlyName = ""
-		} else {
-			gpuDevice.FriendlyName = windows.UTF16ToString(propertyBuffer[:])
-		}
-
-		ret, _, _ = procSetupDiGetDeviceRegistryPropertyW.Call(
-			hDevInfo,
-			uintptr(unsafe.Pointer(&deviceData)),
-			uintptr(SPDRP_HARDWAREID),
-			0,
-			uintptr(unsafe.Pointer(&propertyBuffer[0])),
-			uintptr(len(propertyBuffer)*2),
-			0,
-		)
-
-		if ret == 0 {
-			gpuDevice.HardwareID = "unknown"
-		} else {
-			gpuDevice.HardwareID = windows.UTF16ToString(propertyBuffer[:])
-		}
-
-		ret, _, _ = procSetupDiGetDeviceRegistryPropertyW.Call(
-			hDevInfo,
-			uintptr(unsafe.Pointer(&deviceData)),
-			uintptr(SPDRP_PHYSICAL_DEVICE_OBJECT_NAME),
-			0,
-			uintptr(unsafe.Pointer(&propertyBuffer[0])),
-			uintptr(len(propertyBuffer)*2),
-			0,
-		)
-
-		if ret == 0 {
-			gpuDevice.PhysicalDeviceObjectName = "unknown"
-		} else {
-			gpuDevice.PhysicalDeviceObjectName = windows.UTF16ToString(propertyBuffer[:])
-		}
-
-		devices = append(devices, gpuDevice)
-	}
-
-	_, _, _ = procSetupDiDestroyDeviceInfoList.Call(hDevInfo)
-
-	return devices, nil
-}

internal/headers/setupapi/types.go

@@ -1,42 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-//
-// Copyright The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package setupapi
-
-import "golang.org/x/sys/windows"
-
-const (
-	DIGCF_PRESENT                     = 0x00000002
-	SPDRP_DEVICEDESC                  = 0x00000000
-	SPDRP_FRIENDLYNAME                = 0x0000000C
-	SPDRP_HARDWAREID                  = 0x00000001
-	SPDRP_PHYSICAL_DEVICE_OBJECT_NAME = 0x0000000E
-)
-
-type SP_DEVINFO_DATA struct {
-	CbSize    uint32
-	ClassGuid windows.GUID
-	DevInst   uint32
-	_         uintptr // Reserved
-}
-
-type GPUDevice struct {
-	DeviceDesc               string
-	FriendlyName             string
-	HardwareID               string
-	PhysicalDeviceObjectName string
-}

internal/headers/win32/types.go

@@ -23,12 +23,17 @@ import (
 	"golang.org/x/sys/windows"
 )
 
+const MAX_PATH = 260
+
 type (
+	BOOL      = int32 // BOOL is a 32-bit signed int in Win32
 	DATE_TIME = windows.Filetime
 	DWORD     = uint32
 	LPWSTR    struct {
 		*uint16
 	}
+	ULONG = uint32 // ULONG is a 32-bit unsigned int in Win32
+	UINT  = uint32 // UINT is a 32-bit unsigned int in Win32
 )
 
 // NewLPWSTR creates a new LPWSTR from a string.