Skip to content

Windows shell replacement in Rust: taskbar, file manager, NTFS search, task manager, disk cleaner. One installer exe.

Rust
9.5 KB
Raw Blame
//! Видеоадаптеры независимо от производителя: список через DXGI, температура через D3DKMT (так же, как у диспетчера Windows),
//! версия DirectX через D3D12 и физическое расположение через SetupAPI.
use std::ffi::c_void;
use std::ptr::{null, null_mut};
use winapi::um::libloaderapi::{GetProcAddress, LoadLibraryW};

fn wide(s: &str) -> Vec<u16> {
    s.encode_utf16().chain(Some(0)).collect()
}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct Adapter {
    pub name: String,
    pub vendor: u32,
    pub luid: (u32, i32), // (младшая часть, старшая часть)
    pub dedicated: u64,   // байт
    pub shared: u64,
    pub dx: String,       // «DirectX 12 (FL 12.1)»
    pub location: String, // «PCI-шина 1, устройство 0, функция 0»
}

#[repr(C)]
struct Guid(u32, u16, u16, [u8; 8]);

const IID_IDXGIFACTORY1: Guid = Guid(0x770aae78, 0xf26f, 0x4dba, [0xa8, 0x29, 0x25, 0x3c, 0x83, 0xd1, 0xb3, 0x87]);
const IID_ID3D12DEVICE: Guid = Guid(0x189819f1, 0x1db6, 0x4b57, [0xbe, 0x54, 0x18, 0x21, 0x33, 0x9b, 0x85, 0xf7]);

#[link(name = "dxgi")]
unsafe extern "system" {
    fn CreateDXGIFactory1(riid: *const Guid, out: *mut *mut c_void) -> i32;
}

#[link(name = "gdi32")]
unsafe extern "system" {
    fn D3DKMTOpenAdapterFromLuid(p: *mut OpenFromLuid) -> i32;
    fn D3DKMTQueryAdapterInfo(p: *mut QueryInfo) -> i32;
    fn D3DKMTCloseAdapter(p: *mut u32) -> i32;
}

#[repr(C)]
struct OpenFromLuid {
    low: u32,
    high: i32,
    handle: u32,
}

#[repr(C)]
struct QueryInfo {
    handle: u32,
    ty: u32,
    data: *mut c_void,
    size: u32,
}

/// Вызов метода COM-объекта по номеру в таблице виртуальных методов.
unsafe fn vtbl<T: Copy>(obj: *mut c_void, idx: usize) -> T {
    unsafe {
        let table = *(obj as *const *const usize);
        std::mem::transmute_copy(&*table.add(idx))
    }
}

unsafe fn release(obj: *mut c_void) {
    unsafe {
        let f: unsafe extern "system" fn(*mut c_void) -> u32 = vtbl(obj, 2);
        f(obj);
    }
}

/// Наивысший поддерживаемый уровень возможностей Direct3D для адаптера.
fn directx_level(adapter: *mut c_void) -> String {
    unsafe {
        let lib = LoadLibraryW(wide("d3d12.dll").as_ptr());
        if lib.is_null() {
            return "DirectX 11".into();
        }
        let f = GetProcAddress(lib, c"D3D12CreateDevice".as_ptr());
        if f.is_null() {
            return "DirectX 11".into();
        }
        let create: unsafe extern "system" fn(*mut c_void, i32, *const Guid, *mut *mut c_void) -> i32 = std::mem::transmute(f);
        for (fl, name) in [(0xC200, "12_2"), (0xC100, "12_1"), (0xC000, "12_0"), (0xB100, "11_1"), (0xB000, "11_0")] {
            // ppDevice = NULL: функция только проверяет, можно ли создать устройство (0 или 1 — можно)
            let hr = create(adapter, fl, &IID_ID3D12DEVICE, null_mut());
            if hr == 0 || hr == 1 {
                return format!("DirectX {} (FL {name})", if fl >= 0xC000 { "12" } else { "11" });
            }
        }
        "DirectX 11".into()
    }
}

/// Температура ядра GPU, °C — через D3DKMT_ADAPTER_PERFDATA (работает у NVIDIA, AMD и Intel, если драйвер её отдаёт).
pub fn temperature(luid: (u32, i32)) -> Option<f32> {
    unsafe {
        let mut open = OpenFromLuid { low: luid.0, high: luid.1, handle: 0 };
        if D3DKMTOpenAdapterFromLuid(&mut open) != 0 {
            return None;
        }
        // D3DKMT_ADAPTER_PERFDATA: PhysicalAdapterIndex(4)+выравн.(4), 5×u64, затем FanRPM, Power, Temperature (в 0,1 °C), PowerStateOverride
        let mut perf = [0u8; 64];
        let mut q = QueryInfo { handle: open.handle, ty: 62 /*KMTQAITYPE_ADAPTERPERFDATA*/, data: perf.as_mut_ptr() as *mut c_void, size: perf.len() as u32 };
        let ok = D3DKMTQueryAdapterInfo(&mut q) == 0;
        let mut h = open.handle;
        D3DKMTCloseAdapter(&mut h);
        if !ok {
            return None;
        }
        let t = u32::from_le_bytes([perf[56], perf[57], perf[58], perf[59]]);
        (t > 0 && t < 1500).then_some(t as f32 / 10.0)
    }
}

/// Расположение устройства по описанию: «PCI-шина N, устройство D, функция F».
fn locations() -> Vec<(String, String)> {
    use winapi::shared::guiddef::GUID;
    use winapi::um::setupapi::*;
    let class = GUID { Data1: 0x4d36e968, Data2: 0xe325, Data3: 0x11ce, Data4: [0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18] };
    let mut out = vec![];
    unsafe {
        let set = SetupDiGetClassDevsW(&class, null(), null_mut(), DIGCF_PRESENT);
        if set as isize == -1 {
            return out;
        }
        let mut i = 0;
        loop {
            let mut dev: SP_DEVINFO_DATA = std::mem::zeroed();
            dev.cbSize = std::mem::size_of::<SP_DEVINFO_DATA>() as u32;
            if SetupDiEnumDeviceInfo(set, i, &mut dev) == 0 {
                break;
            }
            i += 1;
            let mut prop = |code: u32, buf: &mut [u8]| -> bool {
                let (mut ty, mut need) = (0u32, 0u32);
                SetupDiGetDeviceRegistryPropertyW(set, &mut dev, code, &mut ty, buf.as_mut_ptr(), buf.len() as u32, &mut need) != 0
            };
            let mut desc = [0u8; 512];
            let (mut bus, mut addr) = ([0u8; 4], [0u8; 4]);
            if prop(0 /*SPDRP_DEVICEDESC*/, &mut desc) && prop(0x10 /*SPDRP_BUSNUMBER*/, &mut bus) && prop(0x1C /*SPDRP_ADDRESS*/, &mut addr) {
                let w: Vec<u16> = desc.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes([c[0], c[1]])).take_while(|&c| c != 0).collect();
                let (b, a) = (u32::from_le_bytes(bus), u32::from_le_bytes(addr));
                out.push((String::from_utf16_lossy(&w), tf!("PCI-шина {b}, устройство {}, функция {}", "PCI bus {b}, device {}, function {}", (a >> 16) & 0xFFFF, a & 0xFFFF)));
            }
        }
        SetupDiDestroyDeviceInfoList(set);
    }
    out
}

/// Видеоадаптеры (кроме программного Microsoft Basic Render Driver) в порядке DXGI.
pub fn adapters() -> Vec<Adapter> {
    let mut out = vec![];
    let locs = locations();
    unsafe {
        let mut factory: *mut c_void = null_mut();
        if CreateDXGIFactory1(&IID_IDXGIFACTORY1, &mut factory) != 0 || factory.is_null() {
            return out;
        }
        let enum1: unsafe extern "system" fn(*mut c_void, u32, *mut *mut c_void) -> i32 = vtbl(factory, 12);
        let mut i = 0;
        loop {
            let mut ad: *mut c_void = null_mut();
            if enum1(factory, i, &mut ad) != 0 || ad.is_null() {
                break;
            }
            i += 1;
            // DXGI_ADAPTER_DESC1 (x64): Description[128] u16 @0, VendorId @256, DedicatedVideoMemory @272, SharedSystemMemory @288, LUID @296, Flags @304
            let mut d = [0u8; 312];
            let get_desc1: unsafe extern "system" fn(*mut c_void, *mut u8) -> i32 = vtbl(ad, 10);
            if get_desc1(ad, d.as_mut_ptr()) == 0 {
                let w: Vec<u16> = d[..256].as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes([c[0], c[1]])).take_while(|&c| c != 0).collect();
                let name = String::from_utf16_lossy(&w);
                let u64_at = |o: usize| u64::from_le_bytes(d[o..o + 8].try_into().unwrap());
                let flags = u32::from_le_bytes([d[304], d[305], d[306], d[307]]);
                // shortcut: one card can show up under several LUIDs (virtual displays); identical twin cards get merged too
                let dup = out.iter().any(|a: &Adapter| a.name == name && a.dedicated == u64_at(272) && a.shared == u64_at(288));
                if flags & 2 == 0 && !dup && !name.to_lowercase().contains("basic render") {
                    out.push(Adapter {
                        location: locs.iter().find(|l| l.0.eq_ignore_ascii_case(&name)).map(|l| l.1.clone()).unwrap_or_default(),
                        dx: directx_level(ad),
                        vendor: u32::from_le_bytes([d[256], d[257], d[258], d[259]]),
                        luid: (u32::from_le_bytes([d[296], d[297], d[298], d[299]]), i32::from_le_bytes([d[300], d[301], d[302], d[303]])),
                        dedicated: u64_at(272),
                        shared: u64_at(288),
                        name,
                    });
                }
            }
            release(ad);
        }
        release(factory);
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn real_adapters_have_memory_directx_location_and_temperature() {
        if std::env::var_os("CI").is_some() {
            return; // GitHub's VMs have no GPU (DXGI lists no adapter)
        }
        let a = adapters();
        assert!(!a.is_empty(), "DXGI должен вернуть хотя бы один адаптер");
        for g in &a {
            eprintln!("{g:?} temp={:?}", temperature(g.luid));
            assert!(!g.name.is_empty() && g.dx.starts_with("DirectX"), "{g:?}");
        }
        let nv = a.iter().find(|g| g.vendor == 0x10DE).expect("есть NVIDIA");
        assert!(nv.dedicated > 4 << 30, "выделенная память: {}", nv.dedicated);
        assert!(nv.location.contains("PCI"), "расположение: {:?}", nv.location);
        let t = temperature(nv.luid).expect("температура через D3DKMT");
        assert!((15.0..=110.0).contains(&t), "t={t}");
    }
}