From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from firstgate.proxmox.com (firstgate.proxmox.com [212.224.123.68]) by lore.proxmox.com (Postfix) with ESMTPS id 583B01FF146 for ; Tue, 20 Jan 2026 14:56:35 +0100 (CET) Received: from firstgate.proxmox.com (localhost [127.0.0.1]) by firstgate.proxmox.com (Proxmox) with ESMTP id C74B110BEC; Tue, 20 Jan 2026 14:56:42 +0100 (CET) From: Christoph Heiss To: pve-devel@lists.proxmox.com Date: Tue, 20 Jan 2026 14:13:09 +0100 Message-ID: <20260120131319.949986-2-c.heiss@proxmox.com> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260120131319.949986-1-c.heiss@proxmox.com> References: <20260120131319.949986-1-c.heiss@proxmox.com> MIME-Version: 1.0 X-Bm-Milter-Handled: 55990f41-d878-4baa-be0a-ee34c49e34d2 X-Bm-Transport-Timestamp: 1768914756721 X-SPAM-LEVEL: Spam detection results: 0 AWL 0.051 Adjusted score from AWL reputation of From: address BAYES_00 -1.9 Bayes spam probability is 0 to 1% DMARC_MISSING 0.1 Missing DMARC policy KAM_DMARC_STATUS 0.01 Test Rule for DKIM or SPF Failure with Strict Alignment KAM_SHORT 0.001 Use of a URL Shortener for very short URL SPF_HELO_NONE 0.001 SPF: HELO does not publish an SPF Record SPF_PASS -0.001 SPF: sender matches SPF record X-Mailman-Approved-At: Tue, 20 Jan 2026 14:56:41 +0100 Subject: [pve-devel] [PATCH proxmox-ve-rs 1/4] vfio: add crate for interacting with vfio host devices X-BeenThere: pve-devel@lists.proxmox.com X-Mailman-Version: 2.1.29 Precedence: list List-Id: Proxmox VE development discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: Proxmox VE development discussion Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: pve-devel-bounces@lists.proxmox.com Sender: "pve-devel" Adds (native library) bindings for NVML [0], generated using bindgen. This will allow in the future to support anything related to Nvidia cards/devices in a stable manner over different driver version, as NVML provides a proper, independent abstraction. E.g. the sysfs interface exposed by the driver may change (as it did recently for kernels 6.8+) and might contain more or less information. [0] https://developer.nvidia.com/management-library-nvml Signed-off-by: Christoph Heiss --- Cargo.toml | 2 + proxmox-ve-vfio/Cargo.toml | 18 + proxmox-ve-vfio/README.md | 25 + proxmox-ve-vfio/debian/changelog | 5 + proxmox-ve-vfio/debian/control | 38 + proxmox-ve-vfio/debian/copyright | 18 + proxmox-ve-vfio/debian/debcargo.toml | 3 + proxmox-ve-vfio/generate-nvml-bindings.sh | 27 + proxmox-ve-vfio/src/lib.rs | 6 + proxmox-ve-vfio/src/nvidia/mod.rs | 3 + proxmox-ve-vfio/src/nvidia/nvml/bindings.rs | 2290 +++++++++++++++++++ proxmox-ve-vfio/src/nvidia/nvml/mod.rs | 13 + 12 files changed, 2448 insertions(+) create mode 100644 proxmox-ve-vfio/Cargo.toml create mode 100644 proxmox-ve-vfio/README.md create mode 100644 proxmox-ve-vfio/debian/changelog create mode 100644 proxmox-ve-vfio/debian/control create mode 100644 proxmox-ve-vfio/debian/copyright create mode 100644 proxmox-ve-vfio/debian/debcargo.toml create mode 100755 proxmox-ve-vfio/generate-nvml-bindings.sh create mode 100644 proxmox-ve-vfio/src/lib.rs create mode 100644 proxmox-ve-vfio/src/nvidia/mod.rs create mode 100644 proxmox-ve-vfio/src/nvidia/nvml/bindings.rs create mode 100644 proxmox-ve-vfio/src/nvidia/nvml/mod.rs diff --git a/Cargo.toml b/Cargo.toml index 99bd54a..6d3c523 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,6 +3,7 @@ members = [ "proxmox-ve-config", "proxmox-frr", "proxmox-sdn-types", + "proxmox-ve-vfio", ] exclude = [ "build", @@ -15,6 +16,7 @@ edition = "2021" license = "AGPL-3" homepage = "https://proxmox.com" exclude = [ "debian" ] +repository = "https://git.proxmox.com/?p=proxmox-ve-rs.git" rust-version = "1.82" [workspace.dependencies] diff --git a/proxmox-ve-vfio/Cargo.toml b/proxmox-ve-vfio/Cargo.toml new file mode 100644 index 0000000..d5d7fc3 --- /dev/null +++ b/proxmox-ve-vfio/Cargo.toml @@ -0,0 +1,18 @@ +[package] +name = "proxmox-ve-vfio" +version = "0.1.0" +description = "Library for handling VFIO host devices such as (v)GPUs" +authors = [ + "Christoph Heiss ", + "Proxmox Support Team " +] +edition.workspace = true +exclude.workspace = true +homepage.workspace = true +license.workspace = true + +[dependencies] +anyhow.workspace = true +serde = { workspace = true, features = [ "derive" ] } + +libloading = "0.8" diff --git a/proxmox-ve-vfio/README.md b/proxmox-ve-vfio/README.md new file mode 100644 index 0000000..306f377 --- /dev/null +++ b/proxmox-ve-vfio/README.md @@ -0,0 +1,25 @@ +# proxmox-ve-vfio + +A rust crate for handling host devices such as (v)GPUs. Currently only minimal +support for Nvidia vGPU information retrieval is implemented. + +## NVML bindings + +This create uses the [NVML](https://developer.nvidia.com/management-library-nvml) for communicating +with Nvidia GPUs. The bindings are pre-generated as `src/bindings.rs` from the `nvml.h` header file, +which is contained within the CUDA Toolkit. + +When the CUDA toolkit is installed, the header can be found at +`/usr/local/cuda-/targets/x86_64-linux/include/nvml.h`. + +It can also be found online in o https://github.com/NVIDIA/nvidia-settings/blob/main/src/nvml.h + +Current bindings are generated from the **13.1 CUDA Toolkit** release. + +### Re-generate bindings + +[`bindgen`](https://github.com/rust-lang/rust-bindgen) is required. + +```sh +./generate-nvml-bindings.sh +``` diff --git a/proxmox-ve-vfio/debian/changelog b/proxmox-ve-vfio/debian/changelog new file mode 100644 index 0000000..b483baf --- /dev/null +++ b/proxmox-ve-vfio/debian/changelog @@ -0,0 +1,5 @@ +rust-proxmox-ve-vfio (0.1.0-1) UNRELEASED; urgency=medium + + * Initial package. + + -- Proxmox Support Team Mon, 19 Jan 2026 10:45:17 +0100 diff --git a/proxmox-ve-vfio/debian/control b/proxmox-ve-vfio/debian/control new file mode 100644 index 0000000..529d19e --- /dev/null +++ b/proxmox-ve-vfio/debian/control @@ -0,0 +1,38 @@ +Source: rust-proxmox-ve-vfio +Section: rust +Priority: optional +Build-Depends: debhelper-compat (= 13), + dh-sequence-cargo +Build-Depends-Arch: cargo:native , + rustc:native , + libstd-rust-dev , + librust-anyhow-1+default-dev , + librust-libloading-0.8+default-dev , + librust-serde-1+default-dev , + librust-serde-1+derive-dev +Maintainer: Proxmox Support Team +Standards-Version: 4.7.2 +Vcs-Git: https://salsa.debian.org/rust-team/debcargo-conf.git [src/proxmox-ve-vfio] +Vcs-Browser: https://salsa.debian.org/rust-team/debcargo-conf/tree/master/src/proxmox-ve-vfio +Homepage: https://proxmox.com +X-Cargo-Crate: proxmox-ve-vfio + +Package: librust-proxmox-ve-vfio-dev +Architecture: any +Multi-Arch: same +Depends: + ${misc:Depends}, + librust-anyhow-1+default-dev, + librust-libloading-0.8+default-dev, + librust-serde-1+default-dev, + librust-serde-1+derive-dev +Provides: + librust-proxmox-ve-vfio+default-dev (= ${binary:Version}), + librust-proxmox-ve-vfio-0-dev (= ${binary:Version}), + librust-proxmox-ve-vfio-0+default-dev (= ${binary:Version}), + librust-proxmox-ve-vfio-0.1-dev (= ${binary:Version}), + librust-proxmox-ve-vfio-0.1+default-dev (= ${binary:Version}), + librust-proxmox-ve-vfio-0.1.0-dev (= ${binary:Version}), + librust-proxmox-ve-vfio-0.1.0+default-dev (= ${binary:Version}) +Description: Handling VFIO host devices such as (v)GPUs - Rust source code + Source code for Debianized Rust crate "proxmox-ve-vfio" diff --git a/proxmox-ve-vfio/debian/copyright b/proxmox-ve-vfio/debian/copyright new file mode 100644 index 0000000..01138fa --- /dev/null +++ b/proxmox-ve-vfio/debian/copyright @@ -0,0 +1,18 @@ +Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ + +Files: + * +Copyright: 2026 Proxmox Server Solutions GmbH +License: AGPL-3.0-or-later + This program is free software: you can redistribute it and/or modify it under + the terms of the GNU Affero General Public License as published by the Free + Software Foundation, either version 3 of the License, or (at your option) any + later version. + . + This program is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more + details. + . + You should have received a copy of the GNU Affero General Public License along + with this program. If not, see . diff --git a/proxmox-ve-vfio/debian/debcargo.toml b/proxmox-ve-vfio/debian/debcargo.toml new file mode 100644 index 0000000..db431df --- /dev/null +++ b/proxmox-ve-vfio/debian/debcargo.toml @@ -0,0 +1,3 @@ +overlay = "." +crate_src_path = ".." +maintainer = "Proxmox Support Team " diff --git a/proxmox-ve-vfio/generate-nvml-bindings.sh b/proxmox-ve-vfio/generate-nvml-bindings.sh new file mode 100755 index 0000000..5ea61f7 --- /dev/null +++ b/proxmox-ve-vfio/generate-nvml-bindings.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash + +set -e +set -u +set -o pipefail + +cd "$(dirname "${BASH_SOURCE[0]}")" || exit 1 + +HEADER="${1:-}" +if [ -z "$HEADER" ]; then + echo "Path to nvml.h missing" >&2 + exit 1 +fi + +# We only need a handful of functions, so the bindings can be kept small. +ALLOWLIST_FN='^nvmlInit_v2|nvmlErrorString|nvmlShutdown|nvmlDeviceGetHandle.*|.*Vgpu.*$' +ALLOWLIST_VAR='^NVML_.*_BUFFER_SIZE$' + +bindgen \ + --no-doc-comments \ + --formatter rustfmt \ + --no-layout-tests \ + --allowlist-function "$ALLOWLIST_FN" \ + --allowlist-var "$ALLOWLIST_VAR" \ + --dynamic-loading NvmlLib \ + --output src/nvidia/nvml/bindings.rs \ + "$HEADER" diff --git a/proxmox-ve-vfio/src/lib.rs b/proxmox-ve-vfio/src/lib.rs new file mode 100644 index 0000000..a5ef43c --- /dev/null +++ b/proxmox-ve-vfio/src/lib.rs @@ -0,0 +1,6 @@ +//! Exposes an interface for accessing and handling host devices such as NVIDIA vGPU devices, to +//! e.g. show information about them and prepare them for passthrough. + +#![warn(missing_docs)] + +pub mod nvidia; diff --git a/proxmox-ve-vfio/src/nvidia/mod.rs b/proxmox-ve-vfio/src/nvidia/mod.rs new file mode 100644 index 0000000..08a414c --- /dev/null +++ b/proxmox-ve-vfio/src/nvidia/mod.rs @@ -0,0 +1,3 @@ +//! Provides access to the state of NVIDIA (v)GPU devices connected to the system. + +mod nvml; diff --git a/proxmox-ve-vfio/src/nvidia/nvml/bindings.rs b/proxmox-ve-vfio/src/nvidia/nvml/bindings.rs new file mode 100644 index 0000000..66617e0 --- /dev/null +++ b/proxmox-ve-vfio/src/nvidia/nvml/bindings.rs @@ -0,0 +1,2290 @@ +/* automatically generated by rust-bindgen 0.71.1 */ + +pub const NVML_DEVICE_PCI_BUS_ID_BUFFER_SIZE: u32 = 32; +pub const NVML_PERF_MODES_BUFFER_SIZE: u32 = 2048; +pub const NVML_DEVICE_HOSTNAME_BUFFER_SIZE: u32 = 64; +pub const NVML_GRID_LICENSE_BUFFER_SIZE: u32 = 128; +pub const NVML_VGPU_NAME_BUFFER_SIZE: u32 = 64; +pub const NVML_DEVICE_INFOROM_VERSION_BUFFER_SIZE: u32 = 16; +pub const NVML_DEVICE_UUID_BUFFER_SIZE: u32 = 80; +pub const NVML_DEVICE_UUID_V2_BUFFER_SIZE: u32 = 96; +pub const NVML_DEVICE_PART_NUMBER_BUFFER_SIZE: u32 = 80; +pub const NVML_SYSTEM_DRIVER_VERSION_BUFFER_SIZE: u32 = 80; +pub const NVML_SYSTEM_NVML_VERSION_BUFFER_SIZE: u32 = 80; +pub const NVML_DEVICE_NAME_BUFFER_SIZE: u32 = 64; +pub const NVML_DEVICE_NAME_V2_BUFFER_SIZE: u32 = 96; +pub const NVML_DEVICE_SERIAL_BUFFER_SIZE: u32 = 30; +pub const NVML_DEVICE_VBIOS_VERSION_BUFFER_SIZE: u32 = 32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlDevice_st { + _unused: [u8; 0], +} +pub type nvmlDevice_t = *mut nvmlDevice_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlGpuInstance_st { + _unused: [u8; 0], +} +pub type nvmlGpuInstance_t = *mut nvmlGpuInstance_st; +pub const nvmlValueType_enum_NVML_VALUE_TYPE_DOUBLE: nvmlValueType_enum = 0; +pub const nvmlValueType_enum_NVML_VALUE_TYPE_UNSIGNED_INT: nvmlValueType_enum = 1; +pub const nvmlValueType_enum_NVML_VALUE_TYPE_UNSIGNED_LONG: nvmlValueType_enum = 2; +pub const nvmlValueType_enum_NVML_VALUE_TYPE_UNSIGNED_LONG_LONG: nvmlValueType_enum = 3; +pub const nvmlValueType_enum_NVML_VALUE_TYPE_SIGNED_LONG_LONG: nvmlValueType_enum = 4; +pub const nvmlValueType_enum_NVML_VALUE_TYPE_SIGNED_INT: nvmlValueType_enum = 5; +pub const nvmlValueType_enum_NVML_VALUE_TYPE_UNSIGNED_SHORT: nvmlValueType_enum = 6; +pub const nvmlValueType_enum_NVML_VALUE_TYPE_COUNT: nvmlValueType_enum = 7; +pub type nvmlValueType_enum = ::std::os::raw::c_uint; +pub use self::nvmlValueType_enum as nvmlValueType_t; +#[repr(C)] +#[derive(Copy, Clone)] +pub union nvmlValue_st { + pub dVal: f64, + pub siVal: ::std::os::raw::c_int, + pub uiVal: ::std::os::raw::c_uint, + pub ulVal: ::std::os::raw::c_ulong, + pub ullVal: ::std::os::raw::c_ulonglong, + pub sllVal: ::std::os::raw::c_longlong, + pub usVal: ::std::os::raw::c_ushort, +} +pub type nvmlValue_t = nvmlValue_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub union nvmlUUIDValue_t { + pub str_: [::std::os::raw::c_char; 41usize], + pub bytes: [::std::os::raw::c_uchar; 16usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct nvmlUUID_v1_t { + pub version: ::std::os::raw::c_uint, + pub type_: ::std::os::raw::c_uint, + pub value: nvmlUUIDValue_t, +} +pub type nvmlUUID_t = nvmlUUID_v1_t; +pub const nvmlEnableState_enum_NVML_FEATURE_DISABLED: nvmlEnableState_enum = 0; +pub const nvmlEnableState_enum_NVML_FEATURE_ENABLED: nvmlEnableState_enum = 1; +pub type nvmlEnableState_enum = ::std::os::raw::c_uint; +pub use self::nvmlEnableState_enum as nvmlEnableState_t; +pub const nvmlReturn_enum_NVML_SUCCESS: nvmlReturn_enum = 0; +pub const nvmlReturn_enum_NVML_ERROR_UNINITIALIZED: nvmlReturn_enum = 1; +pub const nvmlReturn_enum_NVML_ERROR_INVALID_ARGUMENT: nvmlReturn_enum = 2; +pub const nvmlReturn_enum_NVML_ERROR_NOT_SUPPORTED: nvmlReturn_enum = 3; +pub const nvmlReturn_enum_NVML_ERROR_NO_PERMISSION: nvmlReturn_enum = 4; +pub const nvmlReturn_enum_NVML_ERROR_ALREADY_INITIALIZED: nvmlReturn_enum = 5; +pub const nvmlReturn_enum_NVML_ERROR_NOT_FOUND: nvmlReturn_enum = 6; +pub const nvmlReturn_enum_NVML_ERROR_INSUFFICIENT_SIZE: nvmlReturn_enum = 7; +pub const nvmlReturn_enum_NVML_ERROR_INSUFFICIENT_POWER: nvmlReturn_enum = 8; +pub const nvmlReturn_enum_NVML_ERROR_DRIVER_NOT_LOADED: nvmlReturn_enum = 9; +pub const nvmlReturn_enum_NVML_ERROR_TIMEOUT: nvmlReturn_enum = 10; +pub const nvmlReturn_enum_NVML_ERROR_IRQ_ISSUE: nvmlReturn_enum = 11; +pub const nvmlReturn_enum_NVML_ERROR_LIBRARY_NOT_FOUND: nvmlReturn_enum = 12; +pub const nvmlReturn_enum_NVML_ERROR_FUNCTION_NOT_FOUND: nvmlReturn_enum = 13; +pub const nvmlReturn_enum_NVML_ERROR_CORRUPTED_INFOROM: nvmlReturn_enum = 14; +pub const nvmlReturn_enum_NVML_ERROR_GPU_IS_LOST: nvmlReturn_enum = 15; +pub const nvmlReturn_enum_NVML_ERROR_RESET_REQUIRED: nvmlReturn_enum = 16; +pub const nvmlReturn_enum_NVML_ERROR_OPERATING_SYSTEM: nvmlReturn_enum = 17; +pub const nvmlReturn_enum_NVML_ERROR_LIB_RM_VERSION_MISMATCH: nvmlReturn_enum = 18; +pub const nvmlReturn_enum_NVML_ERROR_IN_USE: nvmlReturn_enum = 19; +pub const nvmlReturn_enum_NVML_ERROR_MEMORY: nvmlReturn_enum = 20; +pub const nvmlReturn_enum_NVML_ERROR_NO_DATA: nvmlReturn_enum = 21; +pub const nvmlReturn_enum_NVML_ERROR_VGPU_ECC_NOT_SUPPORTED: nvmlReturn_enum = 22; +pub const nvmlReturn_enum_NVML_ERROR_INSUFFICIENT_RESOURCES: nvmlReturn_enum = 23; +pub const nvmlReturn_enum_NVML_ERROR_FREQ_NOT_SUPPORTED: nvmlReturn_enum = 24; +pub const nvmlReturn_enum_NVML_ERROR_ARGUMENT_VERSION_MISMATCH: nvmlReturn_enum = 25; +pub const nvmlReturn_enum_NVML_ERROR_DEPRECATED: nvmlReturn_enum = 26; +pub const nvmlReturn_enum_NVML_ERROR_NOT_READY: nvmlReturn_enum = 27; +pub const nvmlReturn_enum_NVML_ERROR_GPU_NOT_FOUND: nvmlReturn_enum = 28; +pub const nvmlReturn_enum_NVML_ERROR_INVALID_STATE: nvmlReturn_enum = 29; +pub const nvmlReturn_enum_NVML_ERROR_RESET_TYPE_NOT_SUPPORTED: nvmlReturn_enum = 30; +pub const nvmlReturn_enum_NVML_ERROR_UNKNOWN: nvmlReturn_enum = 999; +pub type nvmlReturn_enum = ::std::os::raw::c_uint; +pub use self::nvmlReturn_enum as nvmlReturn_t; +pub const nvmlHostVgpuMode_enum_NVML_HOST_VGPU_MODE_NON_SRIOV: nvmlHostVgpuMode_enum = 0; +pub const nvmlHostVgpuMode_enum_NVML_HOST_VGPU_MODE_SRIOV: nvmlHostVgpuMode_enum = 1; +pub type nvmlHostVgpuMode_enum = ::std::os::raw::c_uint; +pub use self::nvmlHostVgpuMode_enum as nvmlHostVgpuMode_t; +pub const nvmlVgpuVmIdType_NVML_VGPU_VM_ID_DOMAIN_ID: nvmlVgpuVmIdType = 0; +pub const nvmlVgpuVmIdType_NVML_VGPU_VM_ID_UUID: nvmlVgpuVmIdType = 1; +pub type nvmlVgpuVmIdType = ::std::os::raw::c_uint; +pub use self::nvmlVgpuVmIdType as nvmlVgpuVmIdType_t; +pub const nvmlVgpuGuestInfoState_enum_NVML_VGPU_INSTANCE_GUEST_INFO_STATE_UNINITIALIZED: + nvmlVgpuGuestInfoState_enum = 0; +pub const nvmlVgpuGuestInfoState_enum_NVML_VGPU_INSTANCE_GUEST_INFO_STATE_INITIALIZED: + nvmlVgpuGuestInfoState_enum = 1; +pub type nvmlVgpuGuestInfoState_enum = ::std::os::raw::c_uint; +pub use self::nvmlVgpuGuestInfoState_enum as nvmlVgpuGuestInfoState_t; +pub const nvmlVgpuCapability_enum_NVML_VGPU_CAP_NVLINK_P2P: nvmlVgpuCapability_enum = 0; +pub const nvmlVgpuCapability_enum_NVML_VGPU_CAP_GPUDIRECT: nvmlVgpuCapability_enum = 1; +pub const nvmlVgpuCapability_enum_NVML_VGPU_CAP_MULTI_VGPU_EXCLUSIVE: nvmlVgpuCapability_enum = 2; +pub const nvmlVgpuCapability_enum_NVML_VGPU_CAP_EXCLUSIVE_TYPE: nvmlVgpuCapability_enum = 3; +pub const nvmlVgpuCapability_enum_NVML_VGPU_CAP_EXCLUSIVE_SIZE: nvmlVgpuCapability_enum = 4; +pub const nvmlVgpuCapability_enum_NVML_VGPU_CAP_COUNT: nvmlVgpuCapability_enum = 5; +pub type nvmlVgpuCapability_enum = ::std::os::raw::c_uint; +pub use self::nvmlVgpuCapability_enum as nvmlVgpuCapability_t; +pub const nvmlVgpuDriverCapability_enum_NVML_VGPU_DRIVER_CAP_HETEROGENEOUS_MULTI_VGPU: + nvmlVgpuDriverCapability_enum = 0; +pub const nvmlVgpuDriverCapability_enum_NVML_VGPU_DRIVER_CAP_WARM_UPDATE: + nvmlVgpuDriverCapability_enum = 1; +pub const nvmlVgpuDriverCapability_enum_NVML_VGPU_DRIVER_CAP_COUNT: nvmlVgpuDriverCapability_enum = + 2; +pub type nvmlVgpuDriverCapability_enum = ::std::os::raw::c_uint; +pub use self::nvmlVgpuDriverCapability_enum as nvmlVgpuDriverCapability_t; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_FRACTIONAL_MULTI_VGPU: + nvmlDeviceVgpuCapability_enum = 0; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_HETEROGENEOUS_TIMESLICE_PROFILES: + nvmlDeviceVgpuCapability_enum = 1; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_HETEROGENEOUS_TIMESLICE_SIZES: + nvmlDeviceVgpuCapability_enum = 2; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_READ_DEVICE_BUFFER_BW: + nvmlDeviceVgpuCapability_enum = 3; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_WRITE_DEVICE_BUFFER_BW: + nvmlDeviceVgpuCapability_enum = 4; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_DEVICE_STREAMING: + nvmlDeviceVgpuCapability_enum = 5; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_MINI_QUARTER_GPU: + nvmlDeviceVgpuCapability_enum = 6; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_COMPUTE_MEDIA_ENGINE_GPU: + nvmlDeviceVgpuCapability_enum = 7; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_WARM_UPDATE: + nvmlDeviceVgpuCapability_enum = 8; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_HOMOGENEOUS_PLACEMENTS: + nvmlDeviceVgpuCapability_enum = 9; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_MIG_TIMESLICING_SUPPORTED: + nvmlDeviceVgpuCapability_enum = 10; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_MIG_TIMESLICING_ENABLED: + nvmlDeviceVgpuCapability_enum = 11; +pub const nvmlDeviceVgpuCapability_enum_NVML_DEVICE_VGPU_CAP_COUNT: nvmlDeviceVgpuCapability_enum = + 12; +pub type nvmlDeviceVgpuCapability_enum = ::std::os::raw::c_uint; +pub use self::nvmlDeviceVgpuCapability_enum as nvmlDeviceVgpuCapability_t; +pub type nvmlVgpuTypeId_t = ::std::os::raw::c_uint; +pub type nvmlVgpuInstance_t = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuHeterogeneousMode_v1_t { + pub version: ::std::os::raw::c_uint, + pub mode: ::std::os::raw::c_uint, +} +pub type nvmlVgpuHeterogeneousMode_t = nvmlVgpuHeterogeneousMode_v1_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuPlacementId_v1_t { + pub version: ::std::os::raw::c_uint, + pub placementId: ::std::os::raw::c_uint, +} +pub type nvmlVgpuPlacementId_t = nvmlVgpuPlacementId_v1_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuPlacementList_v2_t { + pub version: ::std::os::raw::c_uint, + pub placementSize: ::std::os::raw::c_uint, + pub count: ::std::os::raw::c_uint, + pub placementIds: *mut ::std::os::raw::c_uint, + pub mode: ::std::os::raw::c_uint, +} +pub type nvmlVgpuPlacementList_t = nvmlVgpuPlacementList_v2_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuTypeBar1Info_v1_t { + pub version: ::std::os::raw::c_uint, + pub bar1Size: ::std::os::raw::c_ulonglong, +} +pub type nvmlVgpuTypeBar1Info_t = nvmlVgpuTypeBar1Info_v1_t; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct nvmlVgpuInstanceUtilizationSample_st { + pub vgpuInstance: nvmlVgpuInstance_t, + pub timeStamp: ::std::os::raw::c_ulonglong, + pub smUtil: nvmlValue_t, + pub memUtil: nvmlValue_t, + pub encUtil: nvmlValue_t, + pub decUtil: nvmlValue_t, +} +pub type nvmlVgpuInstanceUtilizationSample_t = nvmlVgpuInstanceUtilizationSample_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct nvmlVgpuInstanceUtilizationInfo_v1_t { + pub timeStamp: ::std::os::raw::c_ulonglong, + pub vgpuInstance: nvmlVgpuInstance_t, + pub smUtil: nvmlValue_t, + pub memUtil: nvmlValue_t, + pub encUtil: nvmlValue_t, + pub decUtil: nvmlValue_t, + pub jpgUtil: nvmlValue_t, + pub ofaUtil: nvmlValue_t, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuInstancesUtilizationInfo_v1_t { + pub version: ::std::os::raw::c_uint, + pub sampleValType: nvmlValueType_t, + pub vgpuInstanceCount: ::std::os::raw::c_uint, + pub lastSeenTimeStamp: ::std::os::raw::c_ulonglong, + pub vgpuUtilArray: *mut nvmlVgpuInstanceUtilizationInfo_v1_t, +} +pub type nvmlVgpuInstancesUtilizationInfo_t = nvmlVgpuInstancesUtilizationInfo_v1_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuProcessUtilizationSample_st { + pub vgpuInstance: nvmlVgpuInstance_t, + pub pid: ::std::os::raw::c_uint, + pub processName: [::std::os::raw::c_char; 64usize], + pub timeStamp: ::std::os::raw::c_ulonglong, + pub smUtil: ::std::os::raw::c_uint, + pub memUtil: ::std::os::raw::c_uint, + pub encUtil: ::std::os::raw::c_uint, + pub decUtil: ::std::os::raw::c_uint, +} +pub type nvmlVgpuProcessUtilizationSample_t = nvmlVgpuProcessUtilizationSample_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuProcessUtilizationInfo_v1_t { + pub processName: [::std::os::raw::c_char; 64usize], + pub timeStamp: ::std::os::raw::c_ulonglong, + pub vgpuInstance: nvmlVgpuInstance_t, + pub pid: ::std::os::raw::c_uint, + pub smUtil: ::std::os::raw::c_uint, + pub memUtil: ::std::os::raw::c_uint, + pub encUtil: ::std::os::raw::c_uint, + pub decUtil: ::std::os::raw::c_uint, + pub jpgUtil: ::std::os::raw::c_uint, + pub ofaUtil: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuProcessesUtilizationInfo_v1_t { + pub version: ::std::os::raw::c_uint, + pub vgpuProcessCount: ::std::os::raw::c_uint, + pub lastSeenTimeStamp: ::std::os::raw::c_ulonglong, + pub vgpuProcUtilArray: *mut nvmlVgpuProcessUtilizationInfo_v1_t, +} +pub type nvmlVgpuProcessesUtilizationInfo_t = nvmlVgpuProcessesUtilizationInfo_v1_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuRuntimeState_v1_t { + pub version: ::std::os::raw::c_uint, + pub size: ::std::os::raw::c_ulonglong, +} +pub type nvmlVgpuRuntimeState_t = nvmlVgpuRuntimeState_v1_t; +#[repr(C)] +#[derive(Copy, Clone)] +pub union nvmlVgpuSchedulerParams_t { + pub vgpuSchedDataWithARR: nvmlVgpuSchedulerParams_t__bindgen_ty_1, + pub vgpuSchedData: nvmlVgpuSchedulerParams_t__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuSchedulerParams_t__bindgen_ty_1 { + pub avgFactor: ::std::os::raw::c_uint, + pub timeslice: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuSchedulerParams_t__bindgen_ty_2 { + pub timeslice: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuSchedulerLogEntries_st { + pub timestamp: ::std::os::raw::c_ulonglong, + pub timeRunTotal: ::std::os::raw::c_ulonglong, + pub timeRun: ::std::os::raw::c_ulonglong, + pub swRunlistId: ::std::os::raw::c_uint, + pub targetTimeSlice: ::std::os::raw::c_ulonglong, + pub cumulativePreemptionTime: ::std::os::raw::c_ulonglong, +} +pub type nvmlVgpuSchedulerLogEntry_t = nvmlVgpuSchedulerLogEntries_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct nvmlVgpuSchedulerLog_st { + pub engineId: ::std::os::raw::c_uint, + pub schedulerPolicy: ::std::os::raw::c_uint, + pub arrMode: ::std::os::raw::c_uint, + pub schedulerParams: nvmlVgpuSchedulerParams_t, + pub entriesCount: ::std::os::raw::c_uint, + pub logEntries: [nvmlVgpuSchedulerLogEntry_t; 200usize], +} +pub type nvmlVgpuSchedulerLog_t = nvmlVgpuSchedulerLog_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct nvmlVgpuSchedulerGetState_st { + pub schedulerPolicy: ::std::os::raw::c_uint, + pub arrMode: ::std::os::raw::c_uint, + pub schedulerParams: nvmlVgpuSchedulerParams_t, +} +pub type nvmlVgpuSchedulerGetState_t = nvmlVgpuSchedulerGetState_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub union nvmlVgpuSchedulerSetParams_t { + pub vgpuSchedDataWithARR: nvmlVgpuSchedulerSetParams_t__bindgen_ty_1, + pub vgpuSchedData: nvmlVgpuSchedulerSetParams_t__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuSchedulerSetParams_t__bindgen_ty_1 { + pub avgFactor: ::std::os::raw::c_uint, + pub frequency: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuSchedulerSetParams_t__bindgen_ty_2 { + pub timeslice: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct nvmlVgpuSchedulerSetState_st { + pub schedulerPolicy: ::std::os::raw::c_uint, + pub enableARRMode: ::std::os::raw::c_uint, + pub schedulerParams: nvmlVgpuSchedulerSetParams_t, +} +pub type nvmlVgpuSchedulerSetState_t = nvmlVgpuSchedulerSetState_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuSchedulerCapabilities_st { + pub supportedSchedulers: [::std::os::raw::c_uint; 3usize], + pub maxTimeslice: ::std::os::raw::c_uint, + pub minTimeslice: ::std::os::raw::c_uint, + pub isArrModeSupported: ::std::os::raw::c_uint, + pub maxFrequencyForARR: ::std::os::raw::c_uint, + pub minFrequencyForARR: ::std::os::raw::c_uint, + pub maxAvgFactorForARR: ::std::os::raw::c_uint, + pub minAvgFactorForARR: ::std::os::raw::c_uint, +} +pub type nvmlVgpuSchedulerCapabilities_t = nvmlVgpuSchedulerCapabilities_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuLicenseExpiry_st { + pub year: ::std::os::raw::c_uint, + pub month: ::std::os::raw::c_ushort, + pub day: ::std::os::raw::c_ushort, + pub hour: ::std::os::raw::c_ushort, + pub min: ::std::os::raw::c_ushort, + pub sec: ::std::os::raw::c_ushort, + pub status: ::std::os::raw::c_uchar, +} +pub type nvmlVgpuLicenseExpiry_t = nvmlVgpuLicenseExpiry_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuLicenseInfo_st { + pub isLicensed: ::std::os::raw::c_uchar, + pub licenseExpiry: nvmlVgpuLicenseExpiry_t, + pub currentState: ::std::os::raw::c_uint, +} +pub type nvmlVgpuLicenseInfo_t = nvmlVgpuLicenseInfo_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuTypeIdInfo_v1_t { + pub version: ::std::os::raw::c_uint, + pub vgpuCount: ::std::os::raw::c_uint, + pub vgpuTypeIds: *mut nvmlVgpuTypeId_t, +} +pub type nvmlVgpuTypeIdInfo_t = nvmlVgpuTypeIdInfo_v1_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuTypeMaxInstance_v1_t { + pub version: ::std::os::raw::c_uint, + pub vgpuTypeId: nvmlVgpuTypeId_t, + pub maxInstancePerGI: ::std::os::raw::c_uint, +} +pub type nvmlVgpuTypeMaxInstance_t = nvmlVgpuTypeMaxInstance_v1_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlActiveVgpuInstanceInfo_v1_t { + pub version: ::std::os::raw::c_uint, + pub vgpuCount: ::std::os::raw::c_uint, + pub vgpuInstances: *mut nvmlVgpuInstance_t, +} +pub type nvmlActiveVgpuInstanceInfo_t = nvmlActiveVgpuInstanceInfo_v1_t; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct nvmlVgpuSchedulerState_v1_t { + pub version: ::std::os::raw::c_uint, + pub engineId: ::std::os::raw::c_uint, + pub schedulerPolicy: ::std::os::raw::c_uint, + pub enableARRMode: ::std::os::raw::c_uint, + pub schedulerParams: nvmlVgpuSchedulerSetParams_t, +} +pub type nvmlVgpuSchedulerState_t = nvmlVgpuSchedulerState_v1_t; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct nvmlVgpuSchedulerStateInfo_v1_t { + pub version: ::std::os::raw::c_uint, + pub engineId: ::std::os::raw::c_uint, + pub schedulerPolicy: ::std::os::raw::c_uint, + pub arrMode: ::std::os::raw::c_uint, + pub schedulerParams: nvmlVgpuSchedulerParams_t, +} +pub type nvmlVgpuSchedulerStateInfo_t = nvmlVgpuSchedulerStateInfo_v1_t; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct nvmlVgpuSchedulerLogInfo_v1_t { + pub version: ::std::os::raw::c_uint, + pub engineId: ::std::os::raw::c_uint, + pub schedulerPolicy: ::std::os::raw::c_uint, + pub arrMode: ::std::os::raw::c_uint, + pub schedulerParams: nvmlVgpuSchedulerParams_t, + pub entriesCount: ::std::os::raw::c_uint, + pub logEntries: [nvmlVgpuSchedulerLogEntry_t; 200usize], +} +pub type nvmlVgpuSchedulerLogInfo_t = nvmlVgpuSchedulerLogInfo_v1_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuCreatablePlacementInfo_v1_t { + pub version: ::std::os::raw::c_uint, + pub vgpuTypeId: nvmlVgpuTypeId_t, + pub count: ::std::os::raw::c_uint, + pub placementIds: *mut ::std::os::raw::c_uint, + pub placementSize: ::std::os::raw::c_uint, +} +pub type nvmlVgpuCreatablePlacementInfo_t = nvmlVgpuCreatablePlacementInfo_v1_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlAccountingStats_st { + pub gpuUtilization: ::std::os::raw::c_uint, + pub memoryUtilization: ::std::os::raw::c_uint, + pub maxMemoryUsage: ::std::os::raw::c_ulonglong, + pub time: ::std::os::raw::c_ulonglong, + pub startTime: ::std::os::raw::c_ulonglong, + pub isRunning: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 5usize], +} +pub type nvmlAccountingStats_t = nvmlAccountingStats_st; +pub const nvmlEncoderQueryType_enum_NVML_ENCODER_QUERY_H264: nvmlEncoderQueryType_enum = 0; +pub const nvmlEncoderQueryType_enum_NVML_ENCODER_QUERY_HEVC: nvmlEncoderQueryType_enum = 1; +pub const nvmlEncoderQueryType_enum_NVML_ENCODER_QUERY_AV1: nvmlEncoderQueryType_enum = 2; +pub const nvmlEncoderQueryType_enum_NVML_ENCODER_QUERY_UNKNOWN: nvmlEncoderQueryType_enum = 255; +pub type nvmlEncoderQueryType_enum = ::std::os::raw::c_uint; +pub use self::nvmlEncoderQueryType_enum as nvmlEncoderType_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlEncoderSessionInfo_st { + pub sessionId: ::std::os::raw::c_uint, + pub pid: ::std::os::raw::c_uint, + pub vgpuInstance: nvmlVgpuInstance_t, + pub codecType: nvmlEncoderType_t, + pub hResolution: ::std::os::raw::c_uint, + pub vResolution: ::std::os::raw::c_uint, + pub averageFps: ::std::os::raw::c_uint, + pub averageLatency: ::std::os::raw::c_uint, +} +pub type nvmlEncoderSessionInfo_t = nvmlEncoderSessionInfo_st; +pub const nvmlFBCSessionType_enum_NVML_FBC_SESSION_TYPE_UNKNOWN: nvmlFBCSessionType_enum = 0; +pub const nvmlFBCSessionType_enum_NVML_FBC_SESSION_TYPE_TOSYS: nvmlFBCSessionType_enum = 1; +pub const nvmlFBCSessionType_enum_NVML_FBC_SESSION_TYPE_CUDA: nvmlFBCSessionType_enum = 2; +pub const nvmlFBCSessionType_enum_NVML_FBC_SESSION_TYPE_VID: nvmlFBCSessionType_enum = 3; +pub const nvmlFBCSessionType_enum_NVML_FBC_SESSION_TYPE_HWENC: nvmlFBCSessionType_enum = 4; +pub type nvmlFBCSessionType_enum = ::std::os::raw::c_uint; +pub use self::nvmlFBCSessionType_enum as nvmlFBCSessionType_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlFBCStats_st { + pub sessionsCount: ::std::os::raw::c_uint, + pub averageFPS: ::std::os::raw::c_uint, + pub averageLatency: ::std::os::raw::c_uint, +} +pub type nvmlFBCStats_t = nvmlFBCStats_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlFBCSessionInfo_st { + pub sessionId: ::std::os::raw::c_uint, + pub pid: ::std::os::raw::c_uint, + pub vgpuInstance: nvmlVgpuInstance_t, + pub displayOrdinal: ::std::os::raw::c_uint, + pub sessionType: nvmlFBCSessionType_t, + pub sessionFlags: ::std::os::raw::c_uint, + pub hMaxResolution: ::std::os::raw::c_uint, + pub vMaxResolution: ::std::os::raw::c_uint, + pub hResolution: ::std::os::raw::c_uint, + pub vResolution: ::std::os::raw::c_uint, + pub averageFPS: ::std::os::raw::c_uint, + pub averageLatency: ::std::os::raw::c_uint, +} +pub type nvmlFBCSessionInfo_t = nvmlFBCSessionInfo_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuVersion_st { + pub minVersion: ::std::os::raw::c_uint, + pub maxVersion: ::std::os::raw::c_uint, +} +pub type nvmlVgpuVersion_t = nvmlVgpuVersion_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuMetadata_st { + pub version: ::std::os::raw::c_uint, + pub revision: ::std::os::raw::c_uint, + pub guestInfoState: nvmlVgpuGuestInfoState_t, + pub guestDriverVersion: [::std::os::raw::c_char; 80usize], + pub hostDriverVersion: [::std::os::raw::c_char; 80usize], + pub reserved: [::std::os::raw::c_uint; 6usize], + pub vgpuVirtualizationCaps: ::std::os::raw::c_uint, + pub guestVgpuVersion: ::std::os::raw::c_uint, + pub opaqueDataSize: ::std::os::raw::c_uint, + pub opaqueData: [::std::os::raw::c_char; 4usize], +} +pub type nvmlVgpuMetadata_t = nvmlVgpuMetadata_st; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuPgpuMetadata_st { + pub version: ::std::os::raw::c_uint, + pub revision: ::std::os::raw::c_uint, + pub hostDriverVersion: [::std::os::raw::c_char; 80usize], + pub pgpuVirtualizationCaps: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 5usize], + pub hostSupportedVgpuRange: nvmlVgpuVersion_t, + pub opaqueDataSize: ::std::os::raw::c_uint, + pub opaqueData: [::std::os::raw::c_char; 4usize], +} +pub type nvmlVgpuPgpuMetadata_t = nvmlVgpuPgpuMetadata_st; +pub const nvmlVgpuVmCompatibility_enum_NVML_VGPU_VM_COMPATIBILITY_NONE: + nvmlVgpuVmCompatibility_enum = 0; +pub const nvmlVgpuVmCompatibility_enum_NVML_VGPU_VM_COMPATIBILITY_COLD: + nvmlVgpuVmCompatibility_enum = 1; +pub const nvmlVgpuVmCompatibility_enum_NVML_VGPU_VM_COMPATIBILITY_HIBERNATE: + nvmlVgpuVmCompatibility_enum = 2; +pub const nvmlVgpuVmCompatibility_enum_NVML_VGPU_VM_COMPATIBILITY_SLEEP: + nvmlVgpuVmCompatibility_enum = 4; +pub const nvmlVgpuVmCompatibility_enum_NVML_VGPU_VM_COMPATIBILITY_LIVE: + nvmlVgpuVmCompatibility_enum = 8; +pub type nvmlVgpuVmCompatibility_enum = ::std::os::raw::c_uint; +pub use self::nvmlVgpuVmCompatibility_enum as nvmlVgpuVmCompatibility_t; +pub const nvmlVgpuPgpuCompatibilityLimitCode_enum_NVML_VGPU_COMPATIBILITY_LIMIT_NONE: + nvmlVgpuPgpuCompatibilityLimitCode_enum = 0; +pub const nvmlVgpuPgpuCompatibilityLimitCode_enum_NVML_VGPU_COMPATIBILITY_LIMIT_HOST_DRIVER: + nvmlVgpuPgpuCompatibilityLimitCode_enum = 1; +pub const nvmlVgpuPgpuCompatibilityLimitCode_enum_NVML_VGPU_COMPATIBILITY_LIMIT_GUEST_DRIVER: + nvmlVgpuPgpuCompatibilityLimitCode_enum = 2; +pub const nvmlVgpuPgpuCompatibilityLimitCode_enum_NVML_VGPU_COMPATIBILITY_LIMIT_GPU: + nvmlVgpuPgpuCompatibilityLimitCode_enum = 4; +pub const nvmlVgpuPgpuCompatibilityLimitCode_enum_NVML_VGPU_COMPATIBILITY_LIMIT_OTHER: + nvmlVgpuPgpuCompatibilityLimitCode_enum = 2147483648; +pub type nvmlVgpuPgpuCompatibilityLimitCode_enum = ::std::os::raw::c_uint; +pub use self::nvmlVgpuPgpuCompatibilityLimitCode_enum as nvmlVgpuPgpuCompatibilityLimitCode_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct nvmlVgpuPgpuCompatibility_st { + pub vgpuVmCompatibility: nvmlVgpuVmCompatibility_t, + pub compatibilityLimitCode: nvmlVgpuPgpuCompatibilityLimitCode_t, +} +pub type nvmlVgpuPgpuCompatibility_t = nvmlVgpuPgpuCompatibility_st; +pub struct NvmlLib { + __library: ::libloading::Library, + pub nvmlInit_v2: Result nvmlReturn_t, ::libloading::Error>, + pub nvmlShutdown: Result nvmlReturn_t, ::libloading::Error>, + pub nvmlErrorString: Result< + unsafe extern "C" fn(result: nvmlReturn_t) -> *const ::std::os::raw::c_char, + ::libloading::Error, + >, + pub nvmlDeviceGetHandleByIndex_v2: Result< + unsafe extern "C" fn( + index: ::std::os::raw::c_uint, + device: *mut nvmlDevice_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetHandleBySerial: Result< + unsafe extern "C" fn( + serial: *const ::std::os::raw::c_char, + device: *mut nvmlDevice_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetHandleByUUID: Result< + unsafe extern "C" fn( + uuid: *const ::std::os::raw::c_char, + device: *mut nvmlDevice_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetHandleByUUIDV: Result< + unsafe extern "C" fn(uuid: *const nvmlUUID_t, device: *mut nvmlDevice_t) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetHandleByPciBusId_v2: Result< + unsafe extern "C" fn( + pciBusId: *const ::std::os::raw::c_char, + device: *mut nvmlDevice_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetHostVgpuMode: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + pHostVgpuMode: *mut nvmlHostVgpuMode_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuHeterogeneousMode: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + pHeterogeneousMode: *mut nvmlVgpuHeterogeneousMode_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceSetVgpuHeterogeneousMode: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + pHeterogeneousMode: *const nvmlVgpuHeterogeneousMode_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetPlacementId: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + pPlacement: *mut nvmlVgpuPlacementId_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuTypeSupportedPlacements: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + vgpuTypeId: nvmlVgpuTypeId_t, + pPlacementList: *mut nvmlVgpuPlacementList_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuTypeCreatablePlacements: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + vgpuTypeId: nvmlVgpuTypeId_t, + pPlacementList: *mut nvmlVgpuPlacementList_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetGspHeapSize: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + gspHeapSize: *mut ::std::os::raw::c_ulonglong, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetFbReservation: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + fbReservation: *mut ::std::os::raw::c_ulonglong, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetRuntimeStateSize: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + pState: *mut nvmlVgpuRuntimeState_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceSetVgpuCapabilities: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + capability: nvmlDeviceVgpuCapability_t, + state: nvmlEnableState_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGetVgpuDriverCapabilities: Result< + unsafe extern "C" fn( + capability: nvmlVgpuDriverCapability_t, + capResult: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuCapabilities: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + capability: nvmlDeviceVgpuCapability_t, + capResult: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetSupportedVgpus: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + vgpuCount: *mut ::std::os::raw::c_uint, + vgpuTypeIds: *mut nvmlVgpuTypeId_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetCreatableVgpus: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + vgpuCount: *mut ::std::os::raw::c_uint, + vgpuTypeIds: *mut nvmlVgpuTypeId_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetClass: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + vgpuTypeClass: *mut ::std::os::raw::c_char, + size: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetName: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + vgpuTypeName: *mut ::std::os::raw::c_char, + size: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetGpuInstanceProfileId: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + gpuInstanceProfileId: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetDeviceID: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + deviceID: *mut ::std::os::raw::c_ulonglong, + subsystemID: *mut ::std::os::raw::c_ulonglong, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetFramebufferSize: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + fbSize: *mut ::std::os::raw::c_ulonglong, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetNumDisplayHeads: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + numDisplayHeads: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetResolution: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + displayIndex: ::std::os::raw::c_uint, + xdim: *mut ::std::os::raw::c_uint, + ydim: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetLicense: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + vgpuTypeLicenseString: *mut ::std::os::raw::c_char, + size: ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetFrameRateLimit: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + frameRateLimit: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetMaxInstances: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + vgpuTypeId: nvmlVgpuTypeId_t, + vgpuInstanceCount: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetMaxInstancesPerVm: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + vgpuInstanceCountPerVm: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetBAR1Info: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + bar1Info: *mut nvmlVgpuTypeBar1Info_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetActiveVgpus: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + vgpuCount: *mut ::std::os::raw::c_uint, + vgpuInstances: *mut nvmlVgpuInstance_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetVmID: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + vmId: *mut ::std::os::raw::c_char, + size: ::std::os::raw::c_uint, + vmIdType: *mut nvmlVgpuVmIdType_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetUUID: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + uuid: *mut ::std::os::raw::c_char, + size: ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetVmDriverVersion: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + version: *mut ::std::os::raw::c_char, + length: ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetFbUsage: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + fbUsage: *mut ::std::os::raw::c_ulonglong, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetLicenseStatus: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + licensed: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetType: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + vgpuTypeId: *mut nvmlVgpuTypeId_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetFrameRateLimit: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + frameRateLimit: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetEccMode: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + eccMode: *mut nvmlEnableState_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetEncoderCapacity: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + encoderCapacity: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceSetEncoderCapacity: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + encoderCapacity: ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetEncoderStats: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + sessionCount: *mut ::std::os::raw::c_uint, + averageFps: *mut ::std::os::raw::c_uint, + averageLatency: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetEncoderSessions: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + sessionCount: *mut ::std::os::raw::c_uint, + sessionInfo: *mut nvmlEncoderSessionInfo_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetFBCStats: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + fbcStats: *mut nvmlFBCStats_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetFBCSessions: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + sessionCount: *mut ::std::os::raw::c_uint, + sessionInfo: *mut nvmlFBCSessionInfo_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetGpuInstanceId: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + gpuInstanceId: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetGpuPciId: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + vgpuPciId: *mut ::std::os::raw::c_char, + length: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetCapabilities: Result< + unsafe extern "C" fn( + vgpuTypeId: nvmlVgpuTypeId_t, + capability: nvmlVgpuCapability_t, + capResult: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetMdevUUID: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + mdevUuid: *mut ::std::os::raw::c_char, + size: ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGpuInstanceGetCreatableVgpus: Result< + unsafe extern "C" fn( + gpuInstance: nvmlGpuInstance_t, + pVgpus: *mut nvmlVgpuTypeIdInfo_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuTypeGetMaxInstancesPerGpuInstance: Result< + unsafe extern "C" fn(pMaxInstance: *mut nvmlVgpuTypeMaxInstance_t) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGpuInstanceGetActiveVgpus: Result< + unsafe extern "C" fn( + gpuInstance: nvmlGpuInstance_t, + pVgpuInstanceInfo: *mut nvmlActiveVgpuInstanceInfo_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGpuInstanceSetVgpuSchedulerState: Result< + unsafe extern "C" fn( + gpuInstance: nvmlGpuInstance_t, + pScheduler: *mut nvmlVgpuSchedulerState_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGpuInstanceGetVgpuSchedulerState: Result< + unsafe extern "C" fn( + gpuInstance: nvmlGpuInstance_t, + pSchedulerStateInfo: *mut nvmlVgpuSchedulerStateInfo_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGpuInstanceGetVgpuSchedulerLog: Result< + unsafe extern "C" fn( + gpuInstance: nvmlGpuInstance_t, + pSchedulerLogInfo: *mut nvmlVgpuSchedulerLogInfo_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGpuInstanceGetVgpuTypeCreatablePlacements: Result< + unsafe extern "C" fn( + gpuInstance: nvmlGpuInstance_t, + pCreatablePlacementInfo: *mut nvmlVgpuCreatablePlacementInfo_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGpuInstanceGetVgpuHeterogeneousMode: Result< + unsafe extern "C" fn( + gpuInstance: nvmlGpuInstance_t, + pHeterogeneousMode: *mut nvmlVgpuHeterogeneousMode_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGpuInstanceSetVgpuHeterogeneousMode: Result< + unsafe extern "C" fn( + gpuInstance: nvmlGpuInstance_t, + pHeterogeneousMode: *const nvmlVgpuHeterogeneousMode_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetMetadata: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + vgpuMetadata: *mut nvmlVgpuMetadata_t, + bufferSize: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuMetadata: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t, + bufferSize: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGetVgpuCompatibility: Result< + unsafe extern "C" fn( + vgpuMetadata: *mut nvmlVgpuMetadata_t, + pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t, + compatibilityInfo: *mut nvmlVgpuPgpuCompatibility_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuSchedulerLog: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + pSchedulerLog: *mut nvmlVgpuSchedulerLog_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuSchedulerState: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + pSchedulerState: *mut nvmlVgpuSchedulerGetState_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuSchedulerCapabilities: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + pCapabilities: *mut nvmlVgpuSchedulerCapabilities_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceSetVgpuSchedulerState: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + pSchedulerState: *mut nvmlVgpuSchedulerSetState_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlGetVgpuVersion: Result< + unsafe extern "C" fn( + supported: *mut nvmlVgpuVersion_t, + current: *mut nvmlVgpuVersion_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlSetVgpuVersion: Result< + unsafe extern "C" fn(vgpuVersion: *mut nvmlVgpuVersion_t) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuUtilization: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + lastSeenTimeStamp: ::std::os::raw::c_ulonglong, + sampleValType: *mut nvmlValueType_t, + vgpuInstanceSamplesCount: *mut ::std::os::raw::c_uint, + utilizationSamples: *mut nvmlVgpuInstanceUtilizationSample_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuInstancesUtilizationInfo: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + vgpuUtilInfo: *mut nvmlVgpuInstancesUtilizationInfo_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuProcessUtilization: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + lastSeenTimeStamp: ::std::os::raw::c_ulonglong, + vgpuProcessSamplesCount: *mut ::std::os::raw::c_uint, + utilizationSamples: *mut nvmlVgpuProcessUtilizationSample_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlDeviceGetVgpuProcessesUtilizationInfo: Result< + unsafe extern "C" fn( + device: nvmlDevice_t, + vgpuProcUtilInfo: *mut nvmlVgpuProcessesUtilizationInfo_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetAccountingMode: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + mode: *mut nvmlEnableState_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetAccountingPids: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + count: *mut ::std::os::raw::c_uint, + pids: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetAccountingStats: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + pid: ::std::os::raw::c_uint, + stats: *mut nvmlAccountingStats_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceClearAccountingPids: Result< + unsafe extern "C" fn(vgpuInstance: nvmlVgpuInstance_t) -> nvmlReturn_t, + ::libloading::Error, + >, + pub nvmlVgpuInstanceGetLicenseInfo_v2: Result< + unsafe extern "C" fn( + vgpuInstance: nvmlVgpuInstance_t, + licenseInfo: *mut nvmlVgpuLicenseInfo_t, + ) -> nvmlReturn_t, + ::libloading::Error, + >, +} +impl NvmlLib { + pub unsafe fn new

(path: P) -> Result + where + P: AsRef<::std::ffi::OsStr>, + { + let library = ::libloading::Library::new(path)?; + Self::from_library(library) + } + pub unsafe fn from_library(library: L) -> Result + where + L: Into<::libloading::Library>, + { + let __library = library.into(); + let nvmlInit_v2 = __library.get(b"nvmlInit_v2\0").map(|sym| *sym); + let nvmlShutdown = __library.get(b"nvmlShutdown\0").map(|sym| *sym); + let nvmlErrorString = __library.get(b"nvmlErrorString\0").map(|sym| *sym); + let nvmlDeviceGetHandleByIndex_v2 = __library + .get(b"nvmlDeviceGetHandleByIndex_v2\0") + .map(|sym| *sym); + let nvmlDeviceGetHandleBySerial = __library + .get(b"nvmlDeviceGetHandleBySerial\0") + .map(|sym| *sym); + let nvmlDeviceGetHandleByUUID = __library + .get(b"nvmlDeviceGetHandleByUUID\0") + .map(|sym| *sym); + let nvmlDeviceGetHandleByUUIDV = __library + .get(b"nvmlDeviceGetHandleByUUIDV\0") + .map(|sym| *sym); + let nvmlDeviceGetHandleByPciBusId_v2 = __library + .get(b"nvmlDeviceGetHandleByPciBusId_v2\0") + .map(|sym| *sym); + let nvmlDeviceGetHostVgpuMode = __library + .get(b"nvmlDeviceGetHostVgpuMode\0") + .map(|sym| *sym); + let nvmlDeviceGetVgpuHeterogeneousMode = __library + .get(b"nvmlDeviceGetVgpuHeterogeneousMode\0") + .map(|sym| *sym); + let nvmlDeviceSetVgpuHeterogeneousMode = __library + .get(b"nvmlDeviceSetVgpuHeterogeneousMode\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetPlacementId = __library + .get(b"nvmlVgpuInstanceGetPlacementId\0") + .map(|sym| *sym); + let nvmlDeviceGetVgpuTypeSupportedPlacements = __library + .get(b"nvmlDeviceGetVgpuTypeSupportedPlacements\0") + .map(|sym| *sym); + let nvmlDeviceGetVgpuTypeCreatablePlacements = __library + .get(b"nvmlDeviceGetVgpuTypeCreatablePlacements\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetGspHeapSize = __library + .get(b"nvmlVgpuTypeGetGspHeapSize\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetFbReservation = __library + .get(b"nvmlVgpuTypeGetFbReservation\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetRuntimeStateSize = __library + .get(b"nvmlVgpuInstanceGetRuntimeStateSize\0") + .map(|sym| *sym); + let nvmlDeviceSetVgpuCapabilities = __library + .get(b"nvmlDeviceSetVgpuCapabilities\0") + .map(|sym| *sym); + let nvmlGetVgpuDriverCapabilities = __library + .get(b"nvmlGetVgpuDriverCapabilities\0") + .map(|sym| *sym); + let nvmlDeviceGetVgpuCapabilities = __library + .get(b"nvmlDeviceGetVgpuCapabilities\0") + .map(|sym| *sym); + let nvmlDeviceGetSupportedVgpus = __library + .get(b"nvmlDeviceGetSupportedVgpus\0") + .map(|sym| *sym); + let nvmlDeviceGetCreatableVgpus = __library + .get(b"nvmlDeviceGetCreatableVgpus\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetClass = __library.get(b"nvmlVgpuTypeGetClass\0").map(|sym| *sym); + let nvmlVgpuTypeGetName = __library.get(b"nvmlVgpuTypeGetName\0").map(|sym| *sym); + let nvmlVgpuTypeGetGpuInstanceProfileId = __library + .get(b"nvmlVgpuTypeGetGpuInstanceProfileId\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetDeviceID = __library.get(b"nvmlVgpuTypeGetDeviceID\0").map(|sym| *sym); + let nvmlVgpuTypeGetFramebufferSize = __library + .get(b"nvmlVgpuTypeGetFramebufferSize\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetNumDisplayHeads = __library + .get(b"nvmlVgpuTypeGetNumDisplayHeads\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetResolution = __library + .get(b"nvmlVgpuTypeGetResolution\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetLicense = __library.get(b"nvmlVgpuTypeGetLicense\0").map(|sym| *sym); + let nvmlVgpuTypeGetFrameRateLimit = __library + .get(b"nvmlVgpuTypeGetFrameRateLimit\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetMaxInstances = __library + .get(b"nvmlVgpuTypeGetMaxInstances\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetMaxInstancesPerVm = __library + .get(b"nvmlVgpuTypeGetMaxInstancesPerVm\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetBAR1Info = __library.get(b"nvmlVgpuTypeGetBAR1Info\0").map(|sym| *sym); + let nvmlDeviceGetActiveVgpus = __library.get(b"nvmlDeviceGetActiveVgpus\0").map(|sym| *sym); + let nvmlVgpuInstanceGetVmID = __library.get(b"nvmlVgpuInstanceGetVmID\0").map(|sym| *sym); + let nvmlVgpuInstanceGetUUID = __library.get(b"nvmlVgpuInstanceGetUUID\0").map(|sym| *sym); + let nvmlVgpuInstanceGetVmDriverVersion = __library + .get(b"nvmlVgpuInstanceGetVmDriverVersion\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetFbUsage = __library + .get(b"nvmlVgpuInstanceGetFbUsage\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetLicenseStatus = __library + .get(b"nvmlVgpuInstanceGetLicenseStatus\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetType = __library.get(b"nvmlVgpuInstanceGetType\0").map(|sym| *sym); + let nvmlVgpuInstanceGetFrameRateLimit = __library + .get(b"nvmlVgpuInstanceGetFrameRateLimit\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetEccMode = __library + .get(b"nvmlVgpuInstanceGetEccMode\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetEncoderCapacity = __library + .get(b"nvmlVgpuInstanceGetEncoderCapacity\0") + .map(|sym| *sym); + let nvmlVgpuInstanceSetEncoderCapacity = __library + .get(b"nvmlVgpuInstanceSetEncoderCapacity\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetEncoderStats = __library + .get(b"nvmlVgpuInstanceGetEncoderStats\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetEncoderSessions = __library + .get(b"nvmlVgpuInstanceGetEncoderSessions\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetFBCStats = __library + .get(b"nvmlVgpuInstanceGetFBCStats\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetFBCSessions = __library + .get(b"nvmlVgpuInstanceGetFBCSessions\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetGpuInstanceId = __library + .get(b"nvmlVgpuInstanceGetGpuInstanceId\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetGpuPciId = __library + .get(b"nvmlVgpuInstanceGetGpuPciId\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetCapabilities = __library + .get(b"nvmlVgpuTypeGetCapabilities\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetMdevUUID = __library + .get(b"nvmlVgpuInstanceGetMdevUUID\0") + .map(|sym| *sym); + let nvmlGpuInstanceGetCreatableVgpus = __library + .get(b"nvmlGpuInstanceGetCreatableVgpus\0") + .map(|sym| *sym); + let nvmlVgpuTypeGetMaxInstancesPerGpuInstance = __library + .get(b"nvmlVgpuTypeGetMaxInstancesPerGpuInstance\0") + .map(|sym| *sym); + let nvmlGpuInstanceGetActiveVgpus = __library + .get(b"nvmlGpuInstanceGetActiveVgpus\0") + .map(|sym| *sym); + let nvmlGpuInstanceSetVgpuSchedulerState = __library + .get(b"nvmlGpuInstanceSetVgpuSchedulerState\0") + .map(|sym| *sym); + let nvmlGpuInstanceGetVgpuSchedulerState = __library + .get(b"nvmlGpuInstanceGetVgpuSchedulerState\0") + .map(|sym| *sym); + let nvmlGpuInstanceGetVgpuSchedulerLog = __library + .get(b"nvmlGpuInstanceGetVgpuSchedulerLog\0") + .map(|sym| *sym); + let nvmlGpuInstanceGetVgpuTypeCreatablePlacements = __library + .get(b"nvmlGpuInstanceGetVgpuTypeCreatablePlacements\0") + .map(|sym| *sym); + let nvmlGpuInstanceGetVgpuHeterogeneousMode = __library + .get(b"nvmlGpuInstanceGetVgpuHeterogeneousMode\0") + .map(|sym| *sym); + let nvmlGpuInstanceSetVgpuHeterogeneousMode = __library + .get(b"nvmlGpuInstanceSetVgpuHeterogeneousMode\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetMetadata = __library + .get(b"nvmlVgpuInstanceGetMetadata\0") + .map(|sym| *sym); + let nvmlDeviceGetVgpuMetadata = __library + .get(b"nvmlDeviceGetVgpuMetadata\0") + .map(|sym| *sym); + let nvmlGetVgpuCompatibility = __library.get(b"nvmlGetVgpuCompatibility\0").map(|sym| *sym); + let nvmlDeviceGetVgpuSchedulerLog = __library + .get(b"nvmlDeviceGetVgpuSchedulerLog\0") + .map(|sym| *sym); + let nvmlDeviceGetVgpuSchedulerState = __library + .get(b"nvmlDeviceGetVgpuSchedulerState\0") + .map(|sym| *sym); + let nvmlDeviceGetVgpuSchedulerCapabilities = __library + .get(b"nvmlDeviceGetVgpuSchedulerCapabilities\0") + .map(|sym| *sym); + let nvmlDeviceSetVgpuSchedulerState = __library + .get(b"nvmlDeviceSetVgpuSchedulerState\0") + .map(|sym| *sym); + let nvmlGetVgpuVersion = __library.get(b"nvmlGetVgpuVersion\0").map(|sym| *sym); + let nvmlSetVgpuVersion = __library.get(b"nvmlSetVgpuVersion\0").map(|sym| *sym); + let nvmlDeviceGetVgpuUtilization = __library + .get(b"nvmlDeviceGetVgpuUtilization\0") + .map(|sym| *sym); + let nvmlDeviceGetVgpuInstancesUtilizationInfo = __library + .get(b"nvmlDeviceGetVgpuInstancesUtilizationInfo\0") + .map(|sym| *sym); + let nvmlDeviceGetVgpuProcessUtilization = __library + .get(b"nvmlDeviceGetVgpuProcessUtilization\0") + .map(|sym| *sym); + let nvmlDeviceGetVgpuProcessesUtilizationInfo = __library + .get(b"nvmlDeviceGetVgpuProcessesUtilizationInfo\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetAccountingMode = __library + .get(b"nvmlVgpuInstanceGetAccountingMode\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetAccountingPids = __library + .get(b"nvmlVgpuInstanceGetAccountingPids\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetAccountingStats = __library + .get(b"nvmlVgpuInstanceGetAccountingStats\0") + .map(|sym| *sym); + let nvmlVgpuInstanceClearAccountingPids = __library + .get(b"nvmlVgpuInstanceClearAccountingPids\0") + .map(|sym| *sym); + let nvmlVgpuInstanceGetLicenseInfo_v2 = __library + .get(b"nvmlVgpuInstanceGetLicenseInfo_v2\0") + .map(|sym| *sym); + Ok(NvmlLib { + __library, + nvmlInit_v2, + nvmlShutdown, + nvmlErrorString, + nvmlDeviceGetHandleByIndex_v2, + nvmlDeviceGetHandleBySerial, + nvmlDeviceGetHandleByUUID, + nvmlDeviceGetHandleByUUIDV, + nvmlDeviceGetHandleByPciBusId_v2, + nvmlDeviceGetHostVgpuMode, + nvmlDeviceGetVgpuHeterogeneousMode, + nvmlDeviceSetVgpuHeterogeneousMode, + nvmlVgpuInstanceGetPlacementId, + nvmlDeviceGetVgpuTypeSupportedPlacements, + nvmlDeviceGetVgpuTypeCreatablePlacements, + nvmlVgpuTypeGetGspHeapSize, + nvmlVgpuTypeGetFbReservation, + nvmlVgpuInstanceGetRuntimeStateSize, + nvmlDeviceSetVgpuCapabilities, + nvmlGetVgpuDriverCapabilities, + nvmlDeviceGetVgpuCapabilities, + nvmlDeviceGetSupportedVgpus, + nvmlDeviceGetCreatableVgpus, + nvmlVgpuTypeGetClass, + nvmlVgpuTypeGetName, + nvmlVgpuTypeGetGpuInstanceProfileId, + nvmlVgpuTypeGetDeviceID, + nvmlVgpuTypeGetFramebufferSize, + nvmlVgpuTypeGetNumDisplayHeads, + nvmlVgpuTypeGetResolution, + nvmlVgpuTypeGetLicense, + nvmlVgpuTypeGetFrameRateLimit, + nvmlVgpuTypeGetMaxInstances, + nvmlVgpuTypeGetMaxInstancesPerVm, + nvmlVgpuTypeGetBAR1Info, + nvmlDeviceGetActiveVgpus, + nvmlVgpuInstanceGetVmID, + nvmlVgpuInstanceGetUUID, + nvmlVgpuInstanceGetVmDriverVersion, + nvmlVgpuInstanceGetFbUsage, + nvmlVgpuInstanceGetLicenseStatus, + nvmlVgpuInstanceGetType, + nvmlVgpuInstanceGetFrameRateLimit, + nvmlVgpuInstanceGetEccMode, + nvmlVgpuInstanceGetEncoderCapacity, + nvmlVgpuInstanceSetEncoderCapacity, + nvmlVgpuInstanceGetEncoderStats, + nvmlVgpuInstanceGetEncoderSessions, + nvmlVgpuInstanceGetFBCStats, + nvmlVgpuInstanceGetFBCSessions, + nvmlVgpuInstanceGetGpuInstanceId, + nvmlVgpuInstanceGetGpuPciId, + nvmlVgpuTypeGetCapabilities, + nvmlVgpuInstanceGetMdevUUID, + nvmlGpuInstanceGetCreatableVgpus, + nvmlVgpuTypeGetMaxInstancesPerGpuInstance, + nvmlGpuInstanceGetActiveVgpus, + nvmlGpuInstanceSetVgpuSchedulerState, + nvmlGpuInstanceGetVgpuSchedulerState, + nvmlGpuInstanceGetVgpuSchedulerLog, + nvmlGpuInstanceGetVgpuTypeCreatablePlacements, + nvmlGpuInstanceGetVgpuHeterogeneousMode, + nvmlGpuInstanceSetVgpuHeterogeneousMode, + nvmlVgpuInstanceGetMetadata, + nvmlDeviceGetVgpuMetadata, + nvmlGetVgpuCompatibility, + nvmlDeviceGetVgpuSchedulerLog, + nvmlDeviceGetVgpuSchedulerState, + nvmlDeviceGetVgpuSchedulerCapabilities, + nvmlDeviceSetVgpuSchedulerState, + nvmlGetVgpuVersion, + nvmlSetVgpuVersion, + nvmlDeviceGetVgpuUtilization, + nvmlDeviceGetVgpuInstancesUtilizationInfo, + nvmlDeviceGetVgpuProcessUtilization, + nvmlDeviceGetVgpuProcessesUtilizationInfo, + nvmlVgpuInstanceGetAccountingMode, + nvmlVgpuInstanceGetAccountingPids, + nvmlVgpuInstanceGetAccountingStats, + nvmlVgpuInstanceClearAccountingPids, + nvmlVgpuInstanceGetLicenseInfo_v2, + }) + } + pub unsafe fn nvmlInit_v2(&self) -> nvmlReturn_t { + (self + .nvmlInit_v2 + .as_ref() + .expect("Expected function, got error."))() + } + pub unsafe fn nvmlShutdown(&self) -> nvmlReturn_t { + (self + .nvmlShutdown + .as_ref() + .expect("Expected function, got error."))() + } + pub unsafe fn nvmlErrorString(&self, result: nvmlReturn_t) -> *const ::std::os::raw::c_char { + (self + .nvmlErrorString + .as_ref() + .expect("Expected function, got error."))(result) + } + pub unsafe fn nvmlDeviceGetHandleByIndex_v2( + &self, + index: ::std::os::raw::c_uint, + device: *mut nvmlDevice_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetHandleByIndex_v2 + .as_ref() + .expect("Expected function, got error."))(index, device) + } + pub unsafe fn nvmlDeviceGetHandleBySerial( + &self, + serial: *const ::std::os::raw::c_char, + device: *mut nvmlDevice_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetHandleBySerial + .as_ref() + .expect("Expected function, got error."))(serial, device) + } + pub unsafe fn nvmlDeviceGetHandleByUUID( + &self, + uuid: *const ::std::os::raw::c_char, + device: *mut nvmlDevice_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetHandleByUUID + .as_ref() + .expect("Expected function, got error."))(uuid, device) + } + pub unsafe fn nvmlDeviceGetHandleByUUIDV( + &self, + uuid: *const nvmlUUID_t, + device: *mut nvmlDevice_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetHandleByUUIDV + .as_ref() + .expect("Expected function, got error."))(uuid, device) + } + pub unsafe fn nvmlDeviceGetHandleByPciBusId_v2( + &self, + pciBusId: *const ::std::os::raw::c_char, + device: *mut nvmlDevice_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetHandleByPciBusId_v2 + .as_ref() + .expect("Expected function, got error."))(pciBusId, device) + } + pub unsafe fn nvmlDeviceGetHostVgpuMode( + &self, + device: nvmlDevice_t, + pHostVgpuMode: *mut nvmlHostVgpuMode_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetHostVgpuMode + .as_ref() + .expect("Expected function, got error."))(device, pHostVgpuMode) + } + pub unsafe fn nvmlDeviceGetVgpuHeterogeneousMode( + &self, + device: nvmlDevice_t, + pHeterogeneousMode: *mut nvmlVgpuHeterogeneousMode_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuHeterogeneousMode + .as_ref() + .expect("Expected function, got error."))(device, pHeterogeneousMode) + } + pub unsafe fn nvmlDeviceSetVgpuHeterogeneousMode( + &self, + device: nvmlDevice_t, + pHeterogeneousMode: *const nvmlVgpuHeterogeneousMode_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceSetVgpuHeterogeneousMode + .as_ref() + .expect("Expected function, got error."))(device, pHeterogeneousMode) + } + pub unsafe fn nvmlVgpuInstanceGetPlacementId( + &self, + vgpuInstance: nvmlVgpuInstance_t, + pPlacement: *mut nvmlVgpuPlacementId_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetPlacementId + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, pPlacement) + } + pub unsafe fn nvmlDeviceGetVgpuTypeSupportedPlacements( + &self, + device: nvmlDevice_t, + vgpuTypeId: nvmlVgpuTypeId_t, + pPlacementList: *mut nvmlVgpuPlacementList_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuTypeSupportedPlacements + .as_ref() + .expect("Expected function, got error."))(device, vgpuTypeId, pPlacementList) + } + pub unsafe fn nvmlDeviceGetVgpuTypeCreatablePlacements( + &self, + device: nvmlDevice_t, + vgpuTypeId: nvmlVgpuTypeId_t, + pPlacementList: *mut nvmlVgpuPlacementList_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuTypeCreatablePlacements + .as_ref() + .expect("Expected function, got error."))(device, vgpuTypeId, pPlacementList) + } + pub unsafe fn nvmlVgpuTypeGetGspHeapSize( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + gspHeapSize: *mut ::std::os::raw::c_ulonglong, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetGspHeapSize + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, gspHeapSize) + } + pub unsafe fn nvmlVgpuTypeGetFbReservation( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + fbReservation: *mut ::std::os::raw::c_ulonglong, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetFbReservation + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, fbReservation) + } + pub unsafe fn nvmlVgpuInstanceGetRuntimeStateSize( + &self, + vgpuInstance: nvmlVgpuInstance_t, + pState: *mut nvmlVgpuRuntimeState_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetRuntimeStateSize + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, pState) + } + pub unsafe fn nvmlDeviceSetVgpuCapabilities( + &self, + device: nvmlDevice_t, + capability: nvmlDeviceVgpuCapability_t, + state: nvmlEnableState_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceSetVgpuCapabilities + .as_ref() + .expect("Expected function, got error."))(device, capability, state) + } + pub unsafe fn nvmlGetVgpuDriverCapabilities( + &self, + capability: nvmlVgpuDriverCapability_t, + capResult: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlGetVgpuDriverCapabilities + .as_ref() + .expect("Expected function, got error."))(capability, capResult) + } + pub unsafe fn nvmlDeviceGetVgpuCapabilities( + &self, + device: nvmlDevice_t, + capability: nvmlDeviceVgpuCapability_t, + capResult: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuCapabilities + .as_ref() + .expect("Expected function, got error."))(device, capability, capResult) + } + pub unsafe fn nvmlDeviceGetSupportedVgpus( + &self, + device: nvmlDevice_t, + vgpuCount: *mut ::std::os::raw::c_uint, + vgpuTypeIds: *mut nvmlVgpuTypeId_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetSupportedVgpus + .as_ref() + .expect("Expected function, got error."))(device, vgpuCount, vgpuTypeIds) + } + pub unsafe fn nvmlDeviceGetCreatableVgpus( + &self, + device: nvmlDevice_t, + vgpuCount: *mut ::std::os::raw::c_uint, + vgpuTypeIds: *mut nvmlVgpuTypeId_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetCreatableVgpus + .as_ref() + .expect("Expected function, got error."))(device, vgpuCount, vgpuTypeIds) + } + pub unsafe fn nvmlVgpuTypeGetClass( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + vgpuTypeClass: *mut ::std::os::raw::c_char, + size: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetClass + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, vgpuTypeClass, size) + } + pub unsafe fn nvmlVgpuTypeGetName( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + vgpuTypeName: *mut ::std::os::raw::c_char, + size: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetName + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, vgpuTypeName, size) + } + pub unsafe fn nvmlVgpuTypeGetGpuInstanceProfileId( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + gpuInstanceProfileId: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetGpuInstanceProfileId + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, gpuInstanceProfileId) + } + pub unsafe fn nvmlVgpuTypeGetDeviceID( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + deviceID: *mut ::std::os::raw::c_ulonglong, + subsystemID: *mut ::std::os::raw::c_ulonglong, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetDeviceID + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, deviceID, subsystemID) + } + pub unsafe fn nvmlVgpuTypeGetFramebufferSize( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + fbSize: *mut ::std::os::raw::c_ulonglong, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetFramebufferSize + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, fbSize) + } + pub unsafe fn nvmlVgpuTypeGetNumDisplayHeads( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + numDisplayHeads: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetNumDisplayHeads + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, numDisplayHeads) + } + pub unsafe fn nvmlVgpuTypeGetResolution( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + displayIndex: ::std::os::raw::c_uint, + xdim: *mut ::std::os::raw::c_uint, + ydim: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetResolution + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, displayIndex, xdim, ydim) + } + pub unsafe fn nvmlVgpuTypeGetLicense( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + vgpuTypeLicenseString: *mut ::std::os::raw::c_char, + size: ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetLicense + .as_ref() + .expect("Expected function, got error."))( + vgpuTypeId, vgpuTypeLicenseString, size + ) + } + pub unsafe fn nvmlVgpuTypeGetFrameRateLimit( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + frameRateLimit: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetFrameRateLimit + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, frameRateLimit) + } + pub unsafe fn nvmlVgpuTypeGetMaxInstances( + &self, + device: nvmlDevice_t, + vgpuTypeId: nvmlVgpuTypeId_t, + vgpuInstanceCount: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetMaxInstances + .as_ref() + .expect("Expected function, got error."))(device, vgpuTypeId, vgpuInstanceCount) + } + pub unsafe fn nvmlVgpuTypeGetMaxInstancesPerVm( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + vgpuInstanceCountPerVm: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetMaxInstancesPerVm + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, vgpuInstanceCountPerVm) + } + pub unsafe fn nvmlVgpuTypeGetBAR1Info( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + bar1Info: *mut nvmlVgpuTypeBar1Info_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetBAR1Info + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, bar1Info) + } + pub unsafe fn nvmlDeviceGetActiveVgpus( + &self, + device: nvmlDevice_t, + vgpuCount: *mut ::std::os::raw::c_uint, + vgpuInstances: *mut nvmlVgpuInstance_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetActiveVgpus + .as_ref() + .expect("Expected function, got error."))(device, vgpuCount, vgpuInstances) + } + pub unsafe fn nvmlVgpuInstanceGetVmID( + &self, + vgpuInstance: nvmlVgpuInstance_t, + vmId: *mut ::std::os::raw::c_char, + size: ::std::os::raw::c_uint, + vmIdType: *mut nvmlVgpuVmIdType_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetVmID + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, vmId, size, vmIdType) + } + pub unsafe fn nvmlVgpuInstanceGetUUID( + &self, + vgpuInstance: nvmlVgpuInstance_t, + uuid: *mut ::std::os::raw::c_char, + size: ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetUUID + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, uuid, size) + } + pub unsafe fn nvmlVgpuInstanceGetVmDriverVersion( + &self, + vgpuInstance: nvmlVgpuInstance_t, + version: *mut ::std::os::raw::c_char, + length: ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetVmDriverVersion + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, version, length) + } + pub unsafe fn nvmlVgpuInstanceGetFbUsage( + &self, + vgpuInstance: nvmlVgpuInstance_t, + fbUsage: *mut ::std::os::raw::c_ulonglong, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetFbUsage + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, fbUsage) + } + pub unsafe fn nvmlVgpuInstanceGetLicenseStatus( + &self, + vgpuInstance: nvmlVgpuInstance_t, + licensed: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetLicenseStatus + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, licensed) + } + pub unsafe fn nvmlVgpuInstanceGetType( + &self, + vgpuInstance: nvmlVgpuInstance_t, + vgpuTypeId: *mut nvmlVgpuTypeId_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetType + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, vgpuTypeId) + } + pub unsafe fn nvmlVgpuInstanceGetFrameRateLimit( + &self, + vgpuInstance: nvmlVgpuInstance_t, + frameRateLimit: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetFrameRateLimit + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, frameRateLimit) + } + pub unsafe fn nvmlVgpuInstanceGetEccMode( + &self, + vgpuInstance: nvmlVgpuInstance_t, + eccMode: *mut nvmlEnableState_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetEccMode + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, eccMode) + } + pub unsafe fn nvmlVgpuInstanceGetEncoderCapacity( + &self, + vgpuInstance: nvmlVgpuInstance_t, + encoderCapacity: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetEncoderCapacity + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, encoderCapacity) + } + pub unsafe fn nvmlVgpuInstanceSetEncoderCapacity( + &self, + vgpuInstance: nvmlVgpuInstance_t, + encoderCapacity: ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceSetEncoderCapacity + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, encoderCapacity) + } + pub unsafe fn nvmlVgpuInstanceGetEncoderStats( + &self, + vgpuInstance: nvmlVgpuInstance_t, + sessionCount: *mut ::std::os::raw::c_uint, + averageFps: *mut ::std::os::raw::c_uint, + averageLatency: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetEncoderStats + .as_ref() + .expect("Expected function, got error."))( + vgpuInstance, + sessionCount, + averageFps, + averageLatency, + ) + } + pub unsafe fn nvmlVgpuInstanceGetEncoderSessions( + &self, + vgpuInstance: nvmlVgpuInstance_t, + sessionCount: *mut ::std::os::raw::c_uint, + sessionInfo: *mut nvmlEncoderSessionInfo_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetEncoderSessions + .as_ref() + .expect("Expected function, got error."))( + vgpuInstance, sessionCount, sessionInfo + ) + } + pub unsafe fn nvmlVgpuInstanceGetFBCStats( + &self, + vgpuInstance: nvmlVgpuInstance_t, + fbcStats: *mut nvmlFBCStats_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetFBCStats + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, fbcStats) + } + pub unsafe fn nvmlVgpuInstanceGetFBCSessions( + &self, + vgpuInstance: nvmlVgpuInstance_t, + sessionCount: *mut ::std::os::raw::c_uint, + sessionInfo: *mut nvmlFBCSessionInfo_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetFBCSessions + .as_ref() + .expect("Expected function, got error."))( + vgpuInstance, sessionCount, sessionInfo + ) + } + pub unsafe fn nvmlVgpuInstanceGetGpuInstanceId( + &self, + vgpuInstance: nvmlVgpuInstance_t, + gpuInstanceId: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetGpuInstanceId + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, gpuInstanceId) + } + pub unsafe fn nvmlVgpuInstanceGetGpuPciId( + &self, + vgpuInstance: nvmlVgpuInstance_t, + vgpuPciId: *mut ::std::os::raw::c_char, + length: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetGpuPciId + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, vgpuPciId, length) + } + pub unsafe fn nvmlVgpuTypeGetCapabilities( + &self, + vgpuTypeId: nvmlVgpuTypeId_t, + capability: nvmlVgpuCapability_t, + capResult: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetCapabilities + .as_ref() + .expect("Expected function, got error."))(vgpuTypeId, capability, capResult) + } + pub unsafe fn nvmlVgpuInstanceGetMdevUUID( + &self, + vgpuInstance: nvmlVgpuInstance_t, + mdevUuid: *mut ::std::os::raw::c_char, + size: ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetMdevUUID + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, mdevUuid, size) + } + pub unsafe fn nvmlGpuInstanceGetCreatableVgpus( + &self, + gpuInstance: nvmlGpuInstance_t, + pVgpus: *mut nvmlVgpuTypeIdInfo_t, + ) -> nvmlReturn_t { + (self + .nvmlGpuInstanceGetCreatableVgpus + .as_ref() + .expect("Expected function, got error."))(gpuInstance, pVgpus) + } + pub unsafe fn nvmlVgpuTypeGetMaxInstancesPerGpuInstance( + &self, + pMaxInstance: *mut nvmlVgpuTypeMaxInstance_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuTypeGetMaxInstancesPerGpuInstance + .as_ref() + .expect("Expected function, got error."))(pMaxInstance) + } + pub unsafe fn nvmlGpuInstanceGetActiveVgpus( + &self, + gpuInstance: nvmlGpuInstance_t, + pVgpuInstanceInfo: *mut nvmlActiveVgpuInstanceInfo_t, + ) -> nvmlReturn_t { + (self + .nvmlGpuInstanceGetActiveVgpus + .as_ref() + .expect("Expected function, got error."))(gpuInstance, pVgpuInstanceInfo) + } + pub unsafe fn nvmlGpuInstanceSetVgpuSchedulerState( + &self, + gpuInstance: nvmlGpuInstance_t, + pScheduler: *mut nvmlVgpuSchedulerState_t, + ) -> nvmlReturn_t { + (self + .nvmlGpuInstanceSetVgpuSchedulerState + .as_ref() + .expect("Expected function, got error."))(gpuInstance, pScheduler) + } + pub unsafe fn nvmlGpuInstanceGetVgpuSchedulerState( + &self, + gpuInstance: nvmlGpuInstance_t, + pSchedulerStateInfo: *mut nvmlVgpuSchedulerStateInfo_t, + ) -> nvmlReturn_t { + (self + .nvmlGpuInstanceGetVgpuSchedulerState + .as_ref() + .expect("Expected function, got error."))(gpuInstance, pSchedulerStateInfo) + } + pub unsafe fn nvmlGpuInstanceGetVgpuSchedulerLog( + &self, + gpuInstance: nvmlGpuInstance_t, + pSchedulerLogInfo: *mut nvmlVgpuSchedulerLogInfo_t, + ) -> nvmlReturn_t { + (self + .nvmlGpuInstanceGetVgpuSchedulerLog + .as_ref() + .expect("Expected function, got error."))(gpuInstance, pSchedulerLogInfo) + } + pub unsafe fn nvmlGpuInstanceGetVgpuTypeCreatablePlacements( + &self, + gpuInstance: nvmlGpuInstance_t, + pCreatablePlacementInfo: *mut nvmlVgpuCreatablePlacementInfo_t, + ) -> nvmlReturn_t { + (self + .nvmlGpuInstanceGetVgpuTypeCreatablePlacements + .as_ref() + .expect("Expected function, got error."))(gpuInstance, pCreatablePlacementInfo) + } + pub unsafe fn nvmlGpuInstanceGetVgpuHeterogeneousMode( + &self, + gpuInstance: nvmlGpuInstance_t, + pHeterogeneousMode: *mut nvmlVgpuHeterogeneousMode_t, + ) -> nvmlReturn_t { + (self + .nvmlGpuInstanceGetVgpuHeterogeneousMode + .as_ref() + .expect("Expected function, got error."))(gpuInstance, pHeterogeneousMode) + } + pub unsafe fn nvmlGpuInstanceSetVgpuHeterogeneousMode( + &self, + gpuInstance: nvmlGpuInstance_t, + pHeterogeneousMode: *const nvmlVgpuHeterogeneousMode_t, + ) -> nvmlReturn_t { + (self + .nvmlGpuInstanceSetVgpuHeterogeneousMode + .as_ref() + .expect("Expected function, got error."))(gpuInstance, pHeterogeneousMode) + } + pub unsafe fn nvmlVgpuInstanceGetMetadata( + &self, + vgpuInstance: nvmlVgpuInstance_t, + vgpuMetadata: *mut nvmlVgpuMetadata_t, + bufferSize: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetMetadata + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, vgpuMetadata, bufferSize) + } + pub unsafe fn nvmlDeviceGetVgpuMetadata( + &self, + device: nvmlDevice_t, + pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t, + bufferSize: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuMetadata + .as_ref() + .expect("Expected function, got error."))(device, pgpuMetadata, bufferSize) + } + pub unsafe fn nvmlGetVgpuCompatibility( + &self, + vgpuMetadata: *mut nvmlVgpuMetadata_t, + pgpuMetadata: *mut nvmlVgpuPgpuMetadata_t, + compatibilityInfo: *mut nvmlVgpuPgpuCompatibility_t, + ) -> nvmlReturn_t { + (self + .nvmlGetVgpuCompatibility + .as_ref() + .expect("Expected function, got error."))( + vgpuMetadata, pgpuMetadata, compatibilityInfo + ) + } + pub unsafe fn nvmlDeviceGetVgpuSchedulerLog( + &self, + device: nvmlDevice_t, + pSchedulerLog: *mut nvmlVgpuSchedulerLog_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuSchedulerLog + .as_ref() + .expect("Expected function, got error."))(device, pSchedulerLog) + } + pub unsafe fn nvmlDeviceGetVgpuSchedulerState( + &self, + device: nvmlDevice_t, + pSchedulerState: *mut nvmlVgpuSchedulerGetState_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuSchedulerState + .as_ref() + .expect("Expected function, got error."))(device, pSchedulerState) + } + pub unsafe fn nvmlDeviceGetVgpuSchedulerCapabilities( + &self, + device: nvmlDevice_t, + pCapabilities: *mut nvmlVgpuSchedulerCapabilities_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuSchedulerCapabilities + .as_ref() + .expect("Expected function, got error."))(device, pCapabilities) + } + pub unsafe fn nvmlDeviceSetVgpuSchedulerState( + &self, + device: nvmlDevice_t, + pSchedulerState: *mut nvmlVgpuSchedulerSetState_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceSetVgpuSchedulerState + .as_ref() + .expect("Expected function, got error."))(device, pSchedulerState) + } + pub unsafe fn nvmlGetVgpuVersion( + &self, + supported: *mut nvmlVgpuVersion_t, + current: *mut nvmlVgpuVersion_t, + ) -> nvmlReturn_t { + (self + .nvmlGetVgpuVersion + .as_ref() + .expect("Expected function, got error."))(supported, current) + } + pub unsafe fn nvmlSetVgpuVersion(&self, vgpuVersion: *mut nvmlVgpuVersion_t) -> nvmlReturn_t { + (self + .nvmlSetVgpuVersion + .as_ref() + .expect("Expected function, got error."))(vgpuVersion) + } + pub unsafe fn nvmlDeviceGetVgpuUtilization( + &self, + device: nvmlDevice_t, + lastSeenTimeStamp: ::std::os::raw::c_ulonglong, + sampleValType: *mut nvmlValueType_t, + vgpuInstanceSamplesCount: *mut ::std::os::raw::c_uint, + utilizationSamples: *mut nvmlVgpuInstanceUtilizationSample_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuUtilization + .as_ref() + .expect("Expected function, got error."))( + device, + lastSeenTimeStamp, + sampleValType, + vgpuInstanceSamplesCount, + utilizationSamples, + ) + } + pub unsafe fn nvmlDeviceGetVgpuInstancesUtilizationInfo( + &self, + device: nvmlDevice_t, + vgpuUtilInfo: *mut nvmlVgpuInstancesUtilizationInfo_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuInstancesUtilizationInfo + .as_ref() + .expect("Expected function, got error."))(device, vgpuUtilInfo) + } + pub unsafe fn nvmlDeviceGetVgpuProcessUtilization( + &self, + device: nvmlDevice_t, + lastSeenTimeStamp: ::std::os::raw::c_ulonglong, + vgpuProcessSamplesCount: *mut ::std::os::raw::c_uint, + utilizationSamples: *mut nvmlVgpuProcessUtilizationSample_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuProcessUtilization + .as_ref() + .expect("Expected function, got error."))( + device, + lastSeenTimeStamp, + vgpuProcessSamplesCount, + utilizationSamples, + ) + } + pub unsafe fn nvmlDeviceGetVgpuProcessesUtilizationInfo( + &self, + device: nvmlDevice_t, + vgpuProcUtilInfo: *mut nvmlVgpuProcessesUtilizationInfo_t, + ) -> nvmlReturn_t { + (self + .nvmlDeviceGetVgpuProcessesUtilizationInfo + .as_ref() + .expect("Expected function, got error."))(device, vgpuProcUtilInfo) + } + pub unsafe fn nvmlVgpuInstanceGetAccountingMode( + &self, + vgpuInstance: nvmlVgpuInstance_t, + mode: *mut nvmlEnableState_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetAccountingMode + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, mode) + } + pub unsafe fn nvmlVgpuInstanceGetAccountingPids( + &self, + vgpuInstance: nvmlVgpuInstance_t, + count: *mut ::std::os::raw::c_uint, + pids: *mut ::std::os::raw::c_uint, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetAccountingPids + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, count, pids) + } + pub unsafe fn nvmlVgpuInstanceGetAccountingStats( + &self, + vgpuInstance: nvmlVgpuInstance_t, + pid: ::std::os::raw::c_uint, + stats: *mut nvmlAccountingStats_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetAccountingStats + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, pid, stats) + } + pub unsafe fn nvmlVgpuInstanceClearAccountingPids( + &self, + vgpuInstance: nvmlVgpuInstance_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceClearAccountingPids + .as_ref() + .expect("Expected function, got error."))(vgpuInstance) + } + pub unsafe fn nvmlVgpuInstanceGetLicenseInfo_v2( + &self, + vgpuInstance: nvmlVgpuInstance_t, + licenseInfo: *mut nvmlVgpuLicenseInfo_t, + ) -> nvmlReturn_t { + (self + .nvmlVgpuInstanceGetLicenseInfo_v2 + .as_ref() + .expect("Expected function, got error."))(vgpuInstance, licenseInfo) + } +} diff --git a/proxmox-ve-vfio/src/nvidia/nvml/mod.rs b/proxmox-ve-vfio/src/nvidia/nvml/mod.rs new file mode 100644 index 0000000..10ad3c9 --- /dev/null +++ b/proxmox-ve-vfio/src/nvidia/nvml/mod.rs @@ -0,0 +1,13 @@ +//! Provides a safe interface to the [NVML], a native library for accessing and +//! managing the state of NVIDIA GPUs. +//! +//! [NVML]: + +#[allow( + dead_code, + non_camel_case_types, + non_snake_case, + non_upper_case_globals, + unused_imports +)] +pub mod bindings; -- 2.52.0 _______________________________________________ pve-devel mailing list pve-devel@lists.proxmox.com https://lists.proxmox.com/cgi-bin/mailman/listinfo/pve-devel