diff --git a/.gitattributes b/.gitattributes index 24db350c..b96c97eb 100644 --- a/.gitattributes +++ b/.gitattributes @@ -3,4 +3,4 @@ *.rs text diff=rust *.toml text diff=toml -Cargo.lock text +Cargo.lock text diff=toml diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml index 439d4045..92ca05c4 100644 --- a/.github/workflows/build.yaml +++ b/.github/workflows/build.yaml @@ -18,7 +18,7 @@ jobs: rust_toolchain: - stable - beta - - nightly + # - nightly cargo_profile: - dev diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml index f19f9779..2626aae0 100644 --- a/.github/workflows/lint.yaml +++ b/.github/workflows/lint.yaml @@ -20,7 +20,7 @@ jobs: rust_toolchain: - stable - beta - - nightly + # - nightly cargo_profile: - dev @@ -45,27 +45,14 @@ jobs: uses: dtolnay/rust-toolchain@master with: toolchain: ${{ matrix.rust_toolchain }} + components: clippy - name: Run Cargo Clippy - uses: giraffate/clippy-action@v1 - with: - tool_name: Clippy - clippy_flags: --locked --profile ${{ matrix.cargo_profile }} --all-targets -- -D warnings - reporter: ${{ github.event_name == 'pull_request' && 'github-pr-review' || 'github-check' }} - github_token: ${{ secrets.GITHUB_TOKEN }} - filter_mode: nofilter - fail_on_error: true + run: cargo clippy --locked --profile ${{ matrix.cargo_profile }} --all-targets -- -D warnings - name: Run Cargo Clippy (--features nightly) if: matrix.rust_toolchain == 'nightly' - uses: giraffate/clippy-action@v1 - with: - tool_name: Clippy (--features nightly) - clippy_flags: --locked --profile ${{ matrix.cargo_profile }} --all-targets --features nightly -- -D warnings - reporter: ${{ github.event_name == 'pull_request' && 'github-pr-review' || 'github-check' }} - github_token: ${{ secrets.GITHUB_TOKEN }} - filter_mode: nofilter - fail_on_error: true + run: cargo clippy --locked --profile ${{ matrix.cargo_profile }} --all-targets --features nightly -- -D warnings udeps: name: Detect Unused Cargo Dependencies diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index eed155f7..8d505cc2 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -18,7 +18,7 @@ jobs: rust_toolchain: - stable - beta - - nightly + # - nightly cargo_profile: - dev diff --git a/Cargo.lock b/Cargo.lock index ecdd27cd..ad1731e4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -11,6 +11,12 @@ dependencies = [ "memchr", ] +[[package]] +name = "anyhow" +version = "1.0.79" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "080e9890a082662b09c1ad45f567faeeb47f22b5fb23895fbe1e651e718e25ca" + [[package]] name = "basic-toml" version = "0.1.4" @@ -223,6 +229,15 @@ dependencies = [ "syn", ] +[[package]] +name = "matchers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" +dependencies = [ + "regex-automata 0.1.10", +] + [[package]] name = "memchr" version = "2.6.3" @@ -279,6 +294,12 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099" +[[package]] +name = "pin-project-lite" +version = "0.2.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" + [[package]] name = "prettyplease" version = "0.2.15" @@ -315,8 +336,17 @@ checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47" dependencies = [ "aho-corasick", "memchr", - "regex-automata", - "regex-syntax", + "regex-automata 0.3.8", + "regex-syntax 0.7.5", +] + +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" +dependencies = [ + "regex-syntax 0.6.29", ] [[package]] @@ -327,9 +357,15 @@ checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795" dependencies = [ "aho-corasick", "memchr", - "regex-syntax", + "regex-syntax 0.7.5", ] +[[package]] +name = "regex-syntax" +version = "0.6.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" + [[package]] name = "regex-syntax" version = "0.7.5" @@ -495,6 +531,17 @@ dependencies = [ "once_cell", ] +[[package]] +name = "tracing" +version = "0.1.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8" +dependencies = [ + "cfg-if", + "pin-project-lite", + "tracing-core", +] + [[package]] name = "tracing-core" version = "0.1.31" @@ -522,10 +569,14 @@ version = "0.3.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "30a651bc37f915e81f087d86e62a18eec5f79550c7faff886f7090b4ea757c77" dependencies = [ + "matchers", "nu-ansi-term", + "once_cell", + "regex", "sharded-slab", "smallvec", "thread_local", + "tracing", "tracing-core", "tracing-log", ] @@ -608,6 +659,7 @@ version = "0.1.0" name = "wdk-sys" version = "0.1.0" dependencies = [ + "anyhow", "bindgen", "lazy_static", "rustversion", diff --git a/crates/wdk-macros/src/lib.rs b/crates/wdk-macros/src/lib.rs index 84dc769e..fb884126 100644 --- a/crates/wdk-macros/src/lib.rs +++ b/crates/wdk-macros/src/lib.rs @@ -84,33 +84,33 @@ pub fn call_unsafe_wdf_function_binding(input_tokens: TokenStream) -> TokenStrea } struct CallUnsafeWDFFunctionInput { - function_pointer_type: Ident, - function_table_index: Ident, - function_arguments: syn::punctuated::Punctuated, + pointer_type: Ident, + table_index: Ident, + arguments: syn::punctuated::Punctuated, } impl Parse for CallUnsafeWDFFunctionInput { fn parse(input: ParseStream) -> Result { let c_function_name: String = input.parse::()?.to_string(); input.parse::()?; - let function_arguments = input.parse_terminated(Expr::parse, Token![,])?; + let arguments = input.parse_terminated(Expr::parse, Token![,])?; Ok(Self { - function_pointer_type: format_ident!( + pointer_type: format_ident!( "PFN_{uppercase_c_function_name}", uppercase_c_function_name = c_function_name.to_uppercase() ), - function_table_index: format_ident!("{c_function_name}TableIndex"), - function_arguments, + table_index: format_ident!("{c_function_name}TableIndex"), + arguments, }) } } fn call_unsafe_wdf_function_binding_impl(input_tokens: TokenStream2) -> TokenStream2 { let CallUnsafeWDFFunctionInput { - function_pointer_type, - function_table_index, - function_arguments, + pointer_type, + table_index, + arguments, } = match parse2::(input_tokens) { Ok(syntax_tree) => syntax_tree, Err(err) => return err.to_compile_error(), @@ -129,7 +129,7 @@ fn call_unsafe_wdf_function_binding_impl(input_tokens: TokenStream2) -> TokenStr force_unsafe(); // Get handle to WDF function from the function table - let wdf_function: wdk_sys::#function_pointer_type = Some( + let wdf_function: wdk_sys::#pointer_type = Some( // SAFETY: This `transmute` from a no-argument function pointer to a function pointer with the correct // arguments for the WDF function is safe befause WDF maintains the strict mapping between the // function table index and the correct function pointer type. @@ -138,7 +138,7 @@ fn call_unsafe_wdf_function_binding_impl(input_tokens: TokenStream2) -> TokenStr unsafe { core::mem::transmute( // FIXME: investigate why _WDFFUNCENUM does not have a generated type alias without the underscore prefix - wdk_sys::WDF_FUNCTION_TABLE[wdk_sys::_WDFFUNCENUM::#function_table_index as usize], + wdk_sys::WDF_FUNCTION_TABLE[wdk_sys::_WDFFUNCENUM::#table_index as usize], ) } ); @@ -147,15 +147,15 @@ fn call_unsafe_wdf_function_binding_impl(input_tokens: TokenStream2) -> TokenStr // the various wdf headers(ex. wdfdriver.h) if let Some(wdf_function) = wdf_function { // SAFETY: The WDF function pointer is always valid because its an entry in - // `wdk_sys::WDF_FUNCTION_TABLE` indexed by `function_table_index` and guarded by the type-safety of - // `function_pointer_type`. The passed arguments are also guaranteed to be of a compatible type due to - // `function_pointer_type`. + // `wdk_sys::WDF_FUNCTION_TABLE` indexed by `table_index` and guarded by the type-safety of + // `pointer_type`. The passed arguments are also guaranteed to be of a compatible type due to + // `pointer_type`. #[allow(unused_unsafe)] #[allow(clippy::multiple_unsafe_ops_per_block)] unsafe { (wdf_function)( wdk_sys::WdfDriverGlobals, - #function_arguments + #arguments ) } } else { diff --git a/crates/wdk-sys/Cargo.toml b/crates/wdk-sys/Cargo.toml index 7af1b7b7..b70453a2 100644 --- a/crates/wdk-sys/Cargo.toml +++ b/crates/wdk-sys/Cargo.toml @@ -20,7 +20,8 @@ categories = [ bindgen.workspace = true wdk-build.workspace = true thiserror = "1.0.55" -tracing-subscriber = "0.3.17" +tracing-subscriber = { version = "0.3.17", features = ["env-filter"] } +anyhow = "1.0.79" [dependencies] wdk-macros.workspace = true diff --git a/crates/wdk-sys/build.rs b/crates/wdk-sys/build.rs index 97b3a4aa..74f17074 100644 --- a/crates/wdk-sys/build.rs +++ b/crates/wdk-sys/build.rs @@ -7,6 +7,7 @@ use std::{ }; use bindgen::CodegenConfig; +use tracing_subscriber::{filter::LevelFilter, EnvFilter}; use wdk_build::{BuilderExt, Config, ConfigError, DriverConfig, KMDFConfig}; // FIXME: feature gate the WDF version @@ -64,8 +65,53 @@ fn generate_wdf(out_path: &Path, config: Config) -> Result<(), ConfigError> { ) } -fn main() -> Result<(), ConfigError> { - tracing_subscriber::fmt::init(); +fn main() -> anyhow::Result<()> { + let tracing_filter = EnvFilter::default() + // Show errors and warnings by default + .add_directive(LevelFilter::WARN.into()) + // Silence various warnings originating from bindgen that are not currently actionable + // FIXME: this currently sets the minimum log level to error for the listed modules. It should actually be turning off logging (level=off) for specific warnings in these modules, but a bug in the tracing crate's filtering is preventing this from working as expected. See https://github.com/tokio-rs/tracing/issues/2843. + .add_directive("bindgen::codegen::helpers[{message}]=error".parse()?) + .add_directive("bindgen::codegen::struct_layout[{message}]=error".parse()?) + .add_directive("bindgen::ir::comp[{message}]=error".parse()?) + .add_directive("bindgen::ir::context[{message}]=error".parse()?) + .add_directive("bindgen::ir::ty[{message}]=error".parse()?) + .add_directive("bindgen::ir::var[{message}]=error".parse()?); + + // Allow overriding tracing behaviour via `EnvFilter::DEFAULT_ENV` env var + let tracing_filter = + if let Ok(filter_directives_from_env_var) = env::var(EnvFilter::DEFAULT_ENV) { + // Append each directive from the env var to the filter + filter_directives_from_env_var.split(',').fold( + tracing_filter, + |tracing_filter, filter_directive| { + match filter_directive.parse() { + Ok(parsed_filter_directive) => { + tracing_filter.add_directive(parsed_filter_directive) + } + Err(parsing_error) => { + // Must use eprintln!() here as tracing is not yet initialized + eprintln!( + "Skipping filter directive, {}, which failed to be parsed from {} \ + obtained from {} with the following error: {}", + filter_directive, + filter_directives_from_env_var, + EnvFilter::DEFAULT_ENV, + parsing_error + ); + tracing_filter + } + } + }, + ) + } else { + tracing_filter + }; + + tracing_subscriber::fmt() + .pretty() + .with_env_filter(tracing_filter) + .init(); let config = Config { // FIXME: this should be based off of Cargo feature version diff --git a/crates/wdk-sys/generated_bindings/constants.rs b/crates/wdk-sys/generated_bindings/constants.rs index beffc822..eb64e3f4 100644 --- a/crates/wdk-sys/generated_bindings/constants.rs +++ b/crates/wdk-sys/generated_bindings/constants.rs @@ -1958,6 +1958,7 @@ pub const PF_AVX512F_INSTRUCTIONS_AVAILABLE: u32 = 41; pub const PF_ERMS_AVAILABLE: u32 = 42; pub const PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE: u32 = 43; pub const PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE: u32 = 44; +pub const PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE: u32 = 45; pub const IsNEC_98: u32 = 0; pub const IsNotNEC_98: u32 = 1; pub const PROCESSOR_FEATURE_MAX: u32 = 64; @@ -2457,8 +2458,9 @@ pub const DMA_IOMMU_INTERFACE_VERSION: u32 = 1; pub const DMA_IOMMU_INTERFACE_EX_VERSION_1: u32 = 1; pub const DMA_IOMMU_INTERFACE_EX_VERSION_2: u32 = 2; pub const DMA_IOMMU_INTERFACE_EX_VERSION_MIN: u32 = 1; -pub const DMA_IOMMU_INTERFACE_EX_VERSION_MAX: u32 = 2; -pub const DMA_IOMMU_INTERFACE_EX_VERSION: u32 = 1; +pub const DMA_IOMMU_INTERFACE_EX_VERSION_3: u32 = 3; +pub const DMA_IOMMU_INTERFACE_EX_VERSION_MAX: u32 = 3; +pub const DMA_IOMMU_INTERFACE_EX_VERSION: u32 = 3; pub const PO_MEM_PRESERVE: u32 = 1; pub const PO_MEM_CLONE: u32 = 2; pub const PO_MEM_CL_OR_NCHK: u32 = 4; @@ -3685,6 +3687,7 @@ pub const TOKEN_READ: u32 = 131080; pub const TOKEN_WRITE: u32 = 131296; pub const TOKEN_EXECUTE: u32 = 131072; pub const TOKEN_TRUST_CONSTRAINT_MASK: u32 = 131096; +pub const TOKEN_TRUST_ALLOWED_MASK: u32 = 131102; pub const TOKEN_ACCESS_PSEUDO_HANDLE_WIN8: u32 = 24; pub const TOKEN_ACCESS_PSEUDO_HANDLE: u32 = 24; pub const TOKEN_MANDATORY_POLICY_OFF: u32 = 0; @@ -4229,6 +4232,8 @@ pub const PERSISTENT_VOLUME_STATE_REALLOCATE_ALL_DATA_WRITES: u32 = 512; pub const PERSISTENT_VOLUME_STATE_CHKDSK_RAN_ONCE: u32 = 1024; pub const PERSISTENT_VOLUME_STATE_MODIFIED_BY_CHKDSK: u32 = 2048; pub const PERSISTENT_VOLUME_STATE_DAX_FORMATTED: u32 = 4096; +pub const PERSISTENT_VOLUME_STATE_DEV_VOLUME: u32 = 8192; +pub const PERSISTENT_VOLUME_STATE_TRUSTED_VOLUME: u32 = 16384; pub const OPLOCK_LEVEL_CACHE_READ: u32 = 1; pub const OPLOCK_LEVEL_CACHE_HANDLE: u32 = 2; pub const OPLOCK_LEVEL_CACHE_WRITE: u32 = 4; @@ -4238,6 +4243,7 @@ pub const REQUEST_OPLOCK_INPUT_FLAG_COMPLETE_ACK_ON_CLOSE: u32 = 4; pub const REQUEST_OPLOCK_CURRENT_VERSION: u32 = 1; pub const REQUEST_OPLOCK_OUTPUT_FLAG_ACK_REQUIRED: u32 = 1; pub const REQUEST_OPLOCK_OUTPUT_FLAG_MODES_PROVIDED: u32 = 2; +pub const REQUEST_OPLOCK_OUTPUT_FLAG_WRITABLE_SECTION_PRESENT: u32 = 4; pub const QUERY_DEPENDENT_VOLUME_REQUEST_FLAG_HOST_VOLUMES: u32 = 1; pub const QUERY_DEPENDENT_VOLUME_REQUEST_FLAG_GUEST_VOLUMES: u32 = 2; pub const SD_GLOBAL_CHANGE_TYPE_MACHINE_SID: u32 = 1; @@ -4285,12 +4291,12 @@ pub const STREAM_LAYOUT_ENTRY_NO_CLUSTERS_ALLOCATED: u32 = 8; pub const STREAM_LAYOUT_ENTRY_HAS_INFORMATION: u32 = 16; pub const STREAM_EXTENT_ENTRY_AS_RETRIEVAL_POINTERS: u32 = 1; pub const STREAM_EXTENT_ENTRY_ALL_EXTENTS: u32 = 2; -pub const CHECKSUM_TYPE_UNCHANGED: i32 = -1; pub const CHECKSUM_TYPE_NONE: u32 = 0; pub const CHECKSUM_TYPE_CRC32: u32 = 1; pub const CHECKSUM_TYPE_CRC64: u32 = 2; pub const CHECKSUM_TYPE_ECC: u32 = 3; -pub const CHECKSUM_TYPE_FIRST_UNUSED_TYPE: u32 = 4; +pub const CHECKSUM_TYPE_SHA256: u32 = 4; +pub const CHECKSUM_TYPE_FIRST_UNUSED_TYPE: u32 = 5; pub const FSCTL_INTEGRITY_FLAG_CHECKSUM_ENFORCEMENT_OFF: u32 = 1; pub const OFFLOAD_READ_FLAG_ALL_ZERO_BEYOND_CURRENT_RANGE: u32 = 1; pub const SET_PURGE_FAILURE_MODE_ENABLED: u32 = 1; @@ -4366,6 +4372,7 @@ pub const IO_REPARSE_TAG_RESERVED_ONE: u32 = 1; pub const IO_REPARSE_TAG_RESERVED_TWO: u32 = 2; pub const IO_REPARSE_TAG_RESERVED_RANGE: u32 = 2; pub const IO_REPARSE_TAG_VALID_VALUES: u32 = 4026597375; +pub const IO_REPARSE_TAG_RESERVED_INVALID: u32 = 3221258240; pub const IO_REPARSE_TAG_MOUNT_POINT: u32 = 2684354563; pub const IO_REPARSE_TAG_HSM: u32 = 3221225476; pub const IO_REPARSE_TAG_DRIVE_EXTENDER: u32 = 2147483653; @@ -4540,6 +4547,14 @@ pub const FILE_PIPE_SYMLINK_FLAG_RELATIVE: u32 = 2; pub const FILE_PIPE_SYMLINK_VALID_FLAGS: u32 = 3; pub const QUERY_DIRECT_ACCESS_IMAGE_EXTENTS: u32 = 1; pub const QUERY_DIRECT_ACCESS_DATA_EXTENTS: u32 = 2; +pub const REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER_VERSION: u32 = 1; +pub const REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER_VERSION: u32 = 1; +pub const REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER_VERSION: u32 = 1; +pub const REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER_VERSION: u32 = 1; +pub const REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER_VERSION: u32 = 1; +pub const REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER_VERSION: u32 = 1; +pub const REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER_VERSION: u32 = 1; +pub const REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER_VERSION: u32 = 1; pub const IO_QOS_MAX_RESERVATION: u32 = 1000000000; pub const SMB_CCF_APP_INSTANCE_EA_NAME: &[u8; 29] = b"ClusteredApplicationInstance\0"; pub const NETWORK_APP_INSTANCE_CSV_FLAGS_VALID_ONLY_IF_CSV_COORDINATOR: u32 = 1; @@ -4547,6 +4562,7 @@ pub const LX_FILE_METADATA_UID_EA_NAME: &[u8; 7] = b"$LXUID\0"; pub const LX_FILE_METADATA_GID_EA_NAME: &[u8; 7] = b"$LXGID\0"; pub const LX_FILE_METADATA_MODE_EA_NAME: &[u8; 7] = b"$LXMOD\0"; pub const LX_FILE_METADATA_DEVICE_ID_EA_NAME: &[u8; 7] = b"$LXDEV\0"; +pub const VALID_COPY_FILE_CHUNK_FLAGS: u32 = 0; pub const SYSTEM_PAGE_PRIORITY_BITS: u32 = 3; pub const SYSTEM_PAGE_PRIORITY_LEVELS: u32 = 8; pub const TOKEN_HAS_TRAVERSE_PRIVILEGE: u32 = 1; @@ -4576,6 +4592,7 @@ pub const TOKEN_AUDIT_REDIRECTION_TRUST: u32 = 8388608; pub const TOKEN_LEARNING_MODE_LOGGING: u32 = 16777216; pub const TOKEN_PERMISSIVE_LEARNING_MODE: u32 = 50331648; pub const TOKEN_INHERIT_SECURITY_FLAGS: u32 = 3670016; +pub const SECURITY_DESCRIPTOR_DO_NOT_FREE: u32 = 67108864; pub const IO_OPEN_PAGING_FILE: u32 = 2; pub const IO_OPEN_TARGET_DIRECTORY: u32 = 4; pub const IO_STOP_ON_SYMLINK: u32 = 8; @@ -4743,6 +4760,7 @@ pub const ECP_OPEN_PARAMETERS_FLAG_OPEN_FOR_WRITE: u32 = 2; pub const ECP_OPEN_PARAMETERS_FLAG_OPEN_FOR_DELETE: u32 = 4; pub const ECP_OPEN_PARAMETERS_FLAG_IGNORE_DIR_CASE_SENSITIVITY: u32 = 8; pub const ECP_OPEN_PARAMETERS_FLAG_FAIL_ON_CASE_SENSITIVE_DIR: u32 = 16; +pub const OPLOCK_FS_FILTER_FLAGS_MASK: u32 = 8; pub const QoCFileStatInformation: u32 = 1; pub const QoCFileLxInformation: u32 = 2; pub const QoCFileEaInformation: u32 = 4; @@ -4847,10 +4865,22 @@ pub const SECBUFFER_SUBSCRIBE_GENERIC_TLS_EXTENSION: u32 = 26; pub const SECBUFFER_FLAGS: u32 = 27; pub const SECBUFFER_TRAFFIC_SECRETS: u32 = 28; pub const SECBUFFER_CERTIFICATE_REQUEST_CONTEXT: u32 = 29; +pub const SECBUFFER_CHANNEL_BINDINGS_RESULT: u32 = 30; pub const SECBUFFER_ATTRMASK: u32 = 4026531840; pub const SECBUFFER_READONLY: u32 = 2147483648; pub const SECBUFFER_READONLY_WITH_CHECKSUM: u32 = 268435456; pub const SECBUFFER_RESERVED: u32 = 1610612736; +pub const SEC_CHANNEL_BINDINGS_AUDIT_BINDINGS: u32 = 1; +pub const SEC_CHANNEL_BINDINGS_VALID_FLAGS: u32 = 1; +pub const SEC_CHANNEL_BINDINGS_RESULT_CLIENT_SUPPORT: u32 = 1; +pub const SEC_CHANNEL_BINDINGS_RESULT_ABSENT: u32 = 2; +pub const SEC_CHANNEL_BINDINGS_RESULT_NOTVALID_MISMATCH: u32 = 4; +pub const SEC_CHANNEL_BINDINGS_RESULT_NOTVALID_MISSING: u32 = 8; +pub const SEC_CHANNEL_BINDINGS_RESULT_VALID_MATCHED: u32 = 16; +pub const SEC_CHANNEL_BINDINGS_RESULT_VALID_PROXY: u32 = 32; +pub const SEC_CHANNEL_BINDINGS_RESULT_VALID_MISSING: u32 = 64; +pub const SEC_CHANNEL_BINDINGS_RESULT_VALID: u32 = 112; +pub const SEC_CHANNEL_BINDINGS_RESULT_NOTVALID: u32 = 12; pub const SZ_ALG_MAX_SIZE: u32 = 64; pub const SECURITY_NATIVE_DREP: u32 = 16; pub const SECURITY_NETWORK_DREP: u32 = 0; @@ -5290,10 +5320,16 @@ extern "C" { pub static GUID_STANDBY_RESET_PERCENT: GUID; } extern "C" { - pub static GUID_HUPR_ADAPTIVE_DISPLAY_TIMEOUT: GUID; + pub static GUID_HUPR_ADAPTIVE_AWAY_DISPLAY_TIMEOUT: GUID; } extern "C" { - pub static GUID_HUPR_ADAPTIVE_DIM_TIMEOUT: GUID; + pub static GUID_HUPR_ADAPTIVE_INATTENTIVE_DIM_TIMEOUT: GUID; +} +extern "C" { + pub static GUID_HUPR_ADAPTIVE_INATTENTIVE_DISPLAY_TIMEOUT: GUID; +} +extern "C" { + pub static GUID_HUPR_ADAPTIVE_AWAY_DIM_TIMEOUT: GUID; } extern "C" { pub static GUID_ALLOW_STANDBY_STATES: GUID; diff --git a/crates/wdk-sys/generated_bindings/ntddk.rs b/crates/wdk-sys/generated_bindings/ntddk.rs index d0541a52..ced3f306 100644 --- a/crates/wdk-sys/generated_bindings/ntddk.rs +++ b/crates/wdk-sys/generated_bindings/ntddk.rs @@ -10512,6 +10512,21 @@ extern "C" { IoStatusBlock: PIO_STATUS_BLOCK, ) -> NTSTATUS; } +extern "C" { + #[must_use] + pub fn NtCopyFileChunk( + SourceHandle: HANDLE, + DestHandle: HANDLE, + Event: HANDLE, + IoStatusBlock: PIO_STATUS_BLOCK, + Length: ULONG, + SourceOffset: PLARGE_INTEGER, + DestOffset: PLARGE_INTEGER, + SourceKey: PULONG, + DestKey: PULONG, + Flags: ULONG, + ) -> NTSTATUS; +} extern "C" { #[must_use] pub fn NtQueryObject( @@ -12874,6 +12889,14 @@ extern "C" { NotifyRoutine: POPLOCK_NOTIFY_ROUTINE, ) -> NTSTATUS; } +extern "C" { + #[must_use] + pub fn FsRtlCheckOplockForFsFilterCallback( + Oplock: POPLOCK, + CallbackData: PVOID, + Flags: ULONG, + ) -> NTSTATUS; +} extern "C" { pub fn FsRtlGetCurrentProcessLoaderList() -> PLIST_ENTRY; } diff --git a/crates/wdk-sys/generated_bindings/types.rs b/crates/wdk-sys/generated_bindings/types.rs index a4b02408..e6ffa9bc 100644 --- a/crates/wdk-sys/generated_bindings/types.rs +++ b/crates/wdk-sys/generated_bindings/types.rs @@ -5429,7 +5429,12 @@ pub mod _FILE_INFORMATION_CLASS { pub const FileStorageReserveIdInformation: Type = 74; pub const FileCaseSensitiveInformationForceAccessCheck: Type = 75; pub const FileKnownFolderInformation: Type = 76; - pub const FileMaximumInformation: Type = 77; + pub const FileStatBasicInformation: Type = 77; + pub const FileId64ExtdDirectoryInformation: Type = 78; + pub const FileId64ExtdBothDirectoryInformation: Type = 79; + pub const FileIdAllExtdDirectoryInformation: Type = 80; + pub const FileIdAllExtdBothDirectoryInformation: Type = 81; + pub const FileMaximumInformation: Type = 82; } pub use self::_FILE_INFORMATION_CLASS::Type as FILE_INFORMATION_CLASS; pub type PFILE_INFORMATION_CLASS = *mut _FILE_INFORMATION_CLASS::Type; @@ -6576,7 +6581,8 @@ pub mod _FSINFOCLASS { pub const FileFsDataCopyInformation: Type = 12; pub const FileFsMetadataSizeInformation: Type = 13; pub const FileFsFullSizeInformationEx: Type = 14; - pub const FileFsMaximumInformation: Type = 15; + pub const FileFsGuidInformation: Type = 15; + pub const FileFsMaximumInformation: Type = 16; } pub use self::_FSINFOCLASS::Type as FS_INFORMATION_CLASS; pub type PFS_INFORMATION_CLASS = *mut _FSINFOCLASS::Type; @@ -37532,6 +37538,7 @@ impl Default for _IO_STACK_LOCATION__bindgen_ty_1__bindgen_ty_19 { pub struct _IO_STACK_LOCATION__bindgen_ty_1__bindgen_ty_20 { pub Vpb: PVPB, pub DeviceObject: PDEVICE_OBJECT, + pub OutputBufferLength: ULONG, } #[test] fn bindgen_test_layout__IO_STACK_LOCATION__bindgen_ty_1__bindgen_ty_20() { @@ -37541,7 +37548,7 @@ fn bindgen_test_layout__IO_STACK_LOCATION__bindgen_ty_1__bindgen_ty_20() { let ptr = UNINIT.as_ptr(); assert_eq!( ::core::mem::size_of::<_IO_STACK_LOCATION__bindgen_ty_1__bindgen_ty_20>(), - 16usize, + 24usize, concat!("Size of: ", stringify!(_IO_STACK_LOCATION__bindgen_ty_1__bindgen_ty_20)), ); assert_eq!( @@ -37572,6 +37579,18 @@ fn bindgen_test_layout__IO_STACK_LOCATION__bindgen_ty_1__bindgen_ty_20() { stringify!(DeviceObject), ), ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).OutputBufferLength) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_IO_STACK_LOCATION__bindgen_ty_1__bindgen_ty_20), + "::", + stringify!(OutputBufferLength), + ), + ); } impl Default for _IO_STACK_LOCATION__bindgen_ty_1__bindgen_ty_20 { fn default() -> Self { @@ -49930,6 +49949,13 @@ pub struct _IOMMU_DMA_DOMAIN { } pub type IOMMU_DMA_DOMAIN = _IOMMU_DMA_DOMAIN; pub type PIOMMU_DMA_DOMAIN = *mut _IOMMU_DMA_DOMAIN; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _IOMMU_DMA_PASID_DEVICE { + _unused: [u8; 0], +} +pub type IOMMU_DMA_PASID_DEVICE = _IOMMU_DMA_PASID_DEVICE; +pub type PIOMMU_DMA_PASID_DEVICE = *mut _IOMMU_DMA_PASID_DEVICE; pub mod _FAULT_INFORMATION_ARCH { pub type Type = ::core::ffi::c_int; pub const FaultInformationInvalid: Type = 0; @@ -50821,7 +50847,8 @@ pub mod _IOMMU_DMA_DOMAIN_TYPE { pub const DomainTypeTranslate: Type = 0; pub const DomainTypePassThrough: Type = 1; pub const DomainTypeUnmanaged: Type = 2; - pub const DomainTypeMax: Type = 3; + pub const DomainTypeTranslateS1: Type = 3; + pub const DomainTypeMax: Type = 4; } pub use self::_IOMMU_DMA_DOMAIN_TYPE::Type as IOMMU_DMA_DOMAIN_TYPE; pub type PIOMMU_DMA_DOMAIN_TYPE = *mut _IOMMU_DMA_DOMAIN_TYPE::Type; @@ -50922,7 +50949,8 @@ pub mod _IOMMU_DEVICE_CREATION_CONFIGURATION_TYPE { pub const IommuDeviceCreationConfigTypeNone: Type = 0; pub const IommuDeviceCreationConfigTypeAcpi: Type = 1; pub const IommuDeviceCreationConfigTypeDeviceId: Type = 2; - pub const IommuDeviceCreationConfigTypeMax: Type = 3; + pub const IommuDeviceCreationConfigTypePasid: Type = 3; + pub const IommuDeviceCreationConfigTypeMax: Type = 4; } pub use self::_IOMMU_DEVICE_CREATION_CONFIGURATION_TYPE::Type as IOMMU_DEVICE_CREATION_CONFIGURATION_TYPE; pub type PIOMMU_DEVICE_CREATION_CONFIGURATION_TYPE = *mut _IOMMU_DEVICE_CREATION_CONFIGURATION_TYPE::Type; @@ -50971,6 +50999,68 @@ fn bindgen_test_layout__IOMMU_DEVICE_CREATION_CONFIGURATION_ACPI() { } pub type IOMMU_DEVICE_CREATION_CONFIGURATION_ACPI = _IOMMU_DEVICE_CREATION_CONFIGURATION_ACPI; pub type PIOMMU_DEVICE_CREATION_CONFIGURATION_ACPI = *mut _IOMMU_DEVICE_CREATION_CONFIGURATION_ACPI; +pub mod _IOMMU_PASID_CONFIGURATION_TYPE { + pub type Type = ::core::ffi::c_int; + pub const PasidConfigTypeDefaultPasidOnly: Type = 0; + pub const PasidConfigTypePasidTaggedDma: Type = 1; + pub const PasidConfigTypeMax: Type = 2; +} +pub use self::_IOMMU_PASID_CONFIGURATION_TYPE::Type as IOMMU_PASID_CONFIGURATION_TYPE; +pub type PIOMMU_PASID_CONFIGURATION_TYPE = *mut _IOMMU_PASID_CONFIGURATION_TYPE::Type; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _IOMMU_DEVICE_CREATION_CONFIGURATION_PASID { + pub ConfigType: IOMMU_PASID_CONFIGURATION_TYPE, + pub SuppressPasidFaults: BOOLEAN, +} +#[test] +fn bindgen_test_layout__IOMMU_DEVICE_CREATION_CONFIGURATION_PASID() { + const UNINIT: ::core::mem::MaybeUninit<_IOMMU_DEVICE_CREATION_CONFIGURATION_PASID> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_IOMMU_DEVICE_CREATION_CONFIGURATION_PASID>(), + 8usize, + concat!("Size of: ", stringify!(_IOMMU_DEVICE_CREATION_CONFIGURATION_PASID)), + ); + assert_eq!( + ::core::mem::align_of::<_IOMMU_DEVICE_CREATION_CONFIGURATION_PASID>(), + 4usize, + concat!("Alignment of ", stringify!(_IOMMU_DEVICE_CREATION_CONFIGURATION_PASID)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ConfigType) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_IOMMU_DEVICE_CREATION_CONFIGURATION_PASID), + "::", + stringify!(ConfigType), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).SuppressPasidFaults) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_IOMMU_DEVICE_CREATION_CONFIGURATION_PASID), + "::", + stringify!(SuppressPasidFaults), + ), + ); +} +impl Default for _IOMMU_DEVICE_CREATION_CONFIGURATION_PASID { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type IOMMU_DEVICE_CREATION_CONFIGURATION_PASID = _IOMMU_DEVICE_CREATION_CONFIGURATION_PASID; +pub type PIOMMU_DEVICE_CREATION_CONFIGURATION_PASID = *mut _IOMMU_DEVICE_CREATION_CONFIGURATION_PASID; #[repr(C)] #[derive(Copy, Clone)] pub struct _IOMMU_DEVICE_CREATION_CONFIGURATION { @@ -50983,6 +51073,7 @@ pub struct _IOMMU_DEVICE_CREATION_CONFIGURATION { pub union _IOMMU_DEVICE_CREATION_CONFIGURATION__bindgen_ty_1 { pub Acpi: IOMMU_DEVICE_CREATION_CONFIGURATION_ACPI, pub DeviceId: PVOID, + pub Pasid: IOMMU_DEVICE_CREATION_CONFIGURATION_PASID, } #[test] fn bindgen_test_layout__IOMMU_DEVICE_CREATION_CONFIGURATION__bindgen_ty_1() { @@ -51026,6 +51117,16 @@ fn bindgen_test_layout__IOMMU_DEVICE_CREATION_CONFIGURATION__bindgen_ty_1() { stringify!(DeviceId), ), ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Pasid) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_IOMMU_DEVICE_CREATION_CONFIGURATION__bindgen_ty_1), + "::", + stringify!(Pasid), + ), + ); } impl Default for _IOMMU_DEVICE_CREATION_CONFIGURATION__bindgen_ty_1 { fn default() -> Self { @@ -51879,6 +51980,66 @@ pub type IOMMU_INTERFACE_STATE_CHANGE_CALLBACK = ::core::option::Option< unsafe extern "C" fn(StateChange: PIOMMU_INTERFACE_STATE_CHANGE, Context: PVOID), >; pub type PIOMMU_INTERFACE_STATE_CHANGE_CALLBACK = IOMMU_INTERFACE_STATE_CHANGE_CALLBACK; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _IOMMU_DMA_DEVICE_INFORMATION { + pub DefaultPasidEnabled: BOOLEAN, + pub PasidTaggedDmaEnabled: BOOLEAN, + pub PasidFaultsSuppressed: BOOLEAN, +} +#[test] +fn bindgen_test_layout__IOMMU_DMA_DEVICE_INFORMATION() { + const UNINIT: ::core::mem::MaybeUninit<_IOMMU_DMA_DEVICE_INFORMATION> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_IOMMU_DMA_DEVICE_INFORMATION>(), + 3usize, + concat!("Size of: ", stringify!(_IOMMU_DMA_DEVICE_INFORMATION)), + ); + assert_eq!( + ::core::mem::align_of::<_IOMMU_DMA_DEVICE_INFORMATION>(), + 1usize, + concat!("Alignment of ", stringify!(_IOMMU_DMA_DEVICE_INFORMATION)), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).DefaultPasidEnabled) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_IOMMU_DMA_DEVICE_INFORMATION), + "::", + stringify!(DefaultPasidEnabled), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).PasidTaggedDmaEnabled) as usize - ptr as usize + }, + 1usize, + concat!( + "Offset of field: ", + stringify!(_IOMMU_DMA_DEVICE_INFORMATION), + "::", + stringify!(PasidTaggedDmaEnabled), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).PasidFaultsSuppressed) as usize - ptr as usize + }, + 2usize, + concat!( + "Offset of field: ", + stringify!(_IOMMU_DMA_DEVICE_INFORMATION), + "::", + stringify!(PasidFaultsSuppressed), + ), + ); +} +pub type IOMMU_DMA_DEVICE_INFORMATION = _IOMMU_DMA_DEVICE_INFORMATION; +pub type PIOMMU_DMA_DEVICE_INFORMATION = *mut _IOMMU_DMA_DEVICE_INFORMATION; pub type IOMMU_DOMAIN_CREATE = ::core::option::Option< unsafe extern "C" fn( OsManagedPageTable: BOOLEAN, @@ -52128,6 +52289,38 @@ pub type IOMMU_SET_DEVICE_FAULT_REPORTING_EX = ::core::option::Option< ) -> NTSTATUS, >; pub type PIOMMU_SET_DEVICE_FAULT_REPORTING_EX = IOMMU_SET_DEVICE_FAULT_REPORTING_EX; +pub type IOMMU_PASID_DEVICE_CREATE = ::core::option::Option< + unsafe extern "C" fn( + DmaDevice: PIOMMU_DMA_DEVICE, + PasidDeviceOut: *mut PIOMMU_DMA_PASID_DEVICE, + AsidOut: PULONG, + ) -> NTSTATUS, +>; +pub type PIOMMU_PASID_DEVICE_CREATE = IOMMU_PASID_DEVICE_CREATE; +pub type IOMMU_PASID_DEVICE_DELETE = ::core::option::Option< + unsafe extern "C" fn(PasidDevice: PIOMMU_DMA_PASID_DEVICE) -> NTSTATUS, +>; +pub type PIOMMU_PASID_DEVICE_DELETE = IOMMU_PASID_DEVICE_DELETE; +pub type IOMMU_DOMAIN_ATTACH_PASID_DEVICE = ::core::option::Option< + unsafe extern "C" fn( + Domain: PIOMMU_DMA_DOMAIN, + PasidDevice: PIOMMU_DMA_PASID_DEVICE, + ) -> NTSTATUS, +>; +pub type PIOMMU_DOMAIN_ATTACH_PASID_DEVICE = IOMMU_DOMAIN_ATTACH_PASID_DEVICE; +pub type IOMMU_DOMAIN_DETACH_PASID_DEVICE = ::core::option::Option< + unsafe extern "C" fn(PasidDevice: PIOMMU_DMA_PASID_DEVICE) -> NTSTATUS, +>; +pub type PIOMMU_DOMAIN_DETACH_PASID_DEVICE = IOMMU_DOMAIN_DETACH_PASID_DEVICE; +pub type IOMMU_DEVICE_QUERY_INFORMATION = ::core::option::Option< + unsafe extern "C" fn( + DmaDevice: PIOMMU_DMA_DEVICE, + Size: ULONG, + BytesWritten: PULONG, + Buffer: PIOMMU_DMA_DEVICE_INFORMATION, + ) -> NTSTATUS, +>; +pub type PIOMMU_DEVICE_QUERY_INFORMATION = IOMMU_DEVICE_QUERY_INFORMATION; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _DMA_IOMMU_INTERFACE { @@ -52788,6 +52981,367 @@ fn bindgen_test_layout__DMA_IOMMU_INTERFACE_V2() { pub type DMA_IOMMU_INTERFACE_V2 = _DMA_IOMMU_INTERFACE_V2; pub type PDMA_IOMMU_INTERFACE_V2 = *mut _DMA_IOMMU_INTERFACE_V2; #[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _DMA_IOMMU_INTERFACE_V3 { + pub CreateDomainEx: PIOMMU_DOMAIN_CREATE_EX, + pub DeleteDomain: PIOMMU_DOMAIN_DELETE, + pub AttachDeviceEx: PIOMMU_DOMAIN_ATTACH_DEVICE_EX, + pub DetachDeviceEx: PIOMMU_DOMAIN_DETACH_DEVICE_EX, + pub FlushDomain: PIOMMU_FLUSH_DOMAIN, + pub FlushDomainByVaList: PIOMMU_FLUSH_DOMAIN_VA_LIST, + pub QueryInputMappings: PIOMMU_QUERY_INPUT_MAPPINGS, + pub MapLogicalRangeEx: PIOMMU_MAP_LOGICAL_RANGE_EX, + pub UnmapLogicalRange: PIOMMU_UNMAP_LOGICAL_RANGE, + pub MapIdentityRangeEx: PIOMMU_MAP_IDENTITY_RANGE_EX, + pub UnmapIdentityRangeEx: PIOMMU_UNMAP_IDENTITY_RANGE_EX, + pub SetDeviceFaultReportingEx: PIOMMU_SET_DEVICE_FAULT_REPORTING_EX, + pub ConfigureDomain: PIOMMU_DOMAIN_CONFIGURE, + pub QueryAvailableDomainTypes: PIOMMU_DEVICE_QUERY_DOMAIN_TYPES, + pub RegisterInterfaceStateChangeCallback: PIOMMU_REGISTER_INTERFACE_STATE_CHANGE_CALLBACK, + pub UnregisterInterfaceStateChangeCallback: PIOMMU_UNREGISTER_INTERFACE_STATE_CHANGE_CALLBACK, + pub ReserveLogicalAddressRange: PIOMMU_RESERVE_LOGICAL_ADDRESS_RANGE, + pub FreeReservedLogicalAddressRange: PIOMMU_FREE_RESERVED_LOGICAL_ADDRESS_RANGE, + pub MapReservedLogicalRange: PIOMMU_MAP_RESERVED_LOGICAL_RANGE, + pub UnmapReservedLogicalRange: PIOMMU_UNMAP_RESERVED_LOGICAL_RANGE, + pub CreateDevice: PIOMMU_DEVICE_CREATE, + pub DeleteDevice: PIOMMU_DEVICE_DELETE, + pub CreatePasidDevice: PIOMMU_PASID_DEVICE_CREATE, + pub DeletePasidDevice: PIOMMU_PASID_DEVICE_DELETE, + pub AttachPasidDevice: PIOMMU_DOMAIN_ATTACH_PASID_DEVICE, + pub DetachPasidDevice: PIOMMU_DOMAIN_DETACH_PASID_DEVICE, + pub QueryDeviceInfo: PIOMMU_DEVICE_QUERY_INFORMATION, +} +#[test] +fn bindgen_test_layout__DMA_IOMMU_INTERFACE_V3() { + const UNINIT: ::core::mem::MaybeUninit<_DMA_IOMMU_INTERFACE_V3> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_DMA_IOMMU_INTERFACE_V3>(), + 216usize, + concat!("Size of: ", stringify!(_DMA_IOMMU_INTERFACE_V3)), + ); + assert_eq!( + ::core::mem::align_of::<_DMA_IOMMU_INTERFACE_V3>(), + 8usize, + concat!("Alignment of ", stringify!(_DMA_IOMMU_INTERFACE_V3)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).CreateDomainEx) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(CreateDomainEx), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).DeleteDomain) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(DeleteDomain), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).AttachDeviceEx) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(AttachDeviceEx), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).DetachDeviceEx) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(DetachDeviceEx), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FlushDomain) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(FlushDomain), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).FlushDomainByVaList) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(FlushDomainByVaList), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).QueryInputMappings) as usize - ptr as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(QueryInputMappings), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MapLogicalRangeEx) as usize - ptr as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(MapLogicalRangeEx), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).UnmapLogicalRange) as usize - ptr as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(UnmapLogicalRange), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MapIdentityRangeEx) as usize - ptr as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(MapIdentityRangeEx), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).UnmapIdentityRangeEx) as usize - ptr as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(UnmapIdentityRangeEx), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).SetDeviceFaultReportingEx) as usize + - ptr as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(SetDeviceFaultReportingEx), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ConfigureDomain) as usize - ptr as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(ConfigureDomain), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).QueryAvailableDomainTypes) as usize + - ptr as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(QueryAvailableDomainTypes), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).RegisterInterfaceStateChangeCallback) as usize + - ptr as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(RegisterInterfaceStateChangeCallback), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).UnregisterInterfaceStateChangeCallback) as usize + - ptr as usize + }, + 120usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(UnregisterInterfaceStateChangeCallback), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).ReserveLogicalAddressRange) as usize + - ptr as usize + }, + 128usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(ReserveLogicalAddressRange), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).FreeReservedLogicalAddressRange) as usize + - ptr as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(FreeReservedLogicalAddressRange), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MapReservedLogicalRange) as usize - ptr as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(MapReservedLogicalRange), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).UnmapReservedLogicalRange) as usize + - ptr as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(UnmapReservedLogicalRange), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).CreateDevice) as usize - ptr as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(CreateDevice), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).DeleteDevice) as usize - ptr as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(DeleteDevice), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).CreatePasidDevice) as usize - ptr as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(CreatePasidDevice), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).DeletePasidDevice) as usize - ptr as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(DeletePasidDevice), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).AttachPasidDevice) as usize - ptr as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(AttachPasidDevice), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).DetachPasidDevice) as usize - ptr as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(DetachPasidDevice), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).QueryDeviceInfo) as usize - ptr as usize }, + 208usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_V3), + "::", + stringify!(QueryDeviceInfo), + ), + ); +} +pub type DMA_IOMMU_INTERFACE_V3 = _DMA_IOMMU_INTERFACE_V3; +pub type PDMA_IOMMU_INTERFACE_V3 = *mut _DMA_IOMMU_INTERFACE_V3; +#[repr(C)] #[derive(Copy, Clone)] pub struct _DMA_IOMMU_INTERFACE_EX { pub Size: SIZE_T, @@ -52799,6 +53353,7 @@ pub struct _DMA_IOMMU_INTERFACE_EX { pub union _DMA_IOMMU_INTERFACE_EX__bindgen_ty_1 { pub V1: DMA_IOMMU_INTERFACE_V1, pub V2: DMA_IOMMU_INTERFACE_V2, + pub V3: DMA_IOMMU_INTERFACE_V3, } #[test] fn bindgen_test_layout__DMA_IOMMU_INTERFACE_EX__bindgen_ty_1() { @@ -52806,7 +53361,7 @@ fn bindgen_test_layout__DMA_IOMMU_INTERFACE_EX__bindgen_ty_1() { let ptr = UNINIT.as_ptr(); assert_eq!( ::core::mem::size_of::<_DMA_IOMMU_INTERFACE_EX__bindgen_ty_1>(), - 176usize, + 216usize, concat!("Size of: ", stringify!(_DMA_IOMMU_INTERFACE_EX__bindgen_ty_1)), ); assert_eq!( @@ -52834,6 +53389,16 @@ fn bindgen_test_layout__DMA_IOMMU_INTERFACE_EX__bindgen_ty_1() { stringify!(V2), ), ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).V3) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_DMA_IOMMU_INTERFACE_EX__bindgen_ty_1), + "::", + stringify!(V3), + ), + ); } impl Default for _DMA_IOMMU_INTERFACE_EX__bindgen_ty_1 { fn default() -> Self { @@ -52850,7 +53415,7 @@ fn bindgen_test_layout__DMA_IOMMU_INTERFACE_EX() { let ptr = UNINIT.as_ptr(); assert_eq!( ::core::mem::size_of::<_DMA_IOMMU_INTERFACE_EX>(), - 192usize, + 232usize, concat!("Size of: ", stringify!(_DMA_IOMMU_INTERFACE_EX)), ); assert_eq!( @@ -79663,7 +80228,8 @@ pub mod _PROCESS_MITIGATION_POLICY { pub const ProcessRedirectionTrustPolicy: Type = 16; pub const ProcessUserPointerAuthPolicy: Type = 17; pub const ProcessSEHOPPolicy: Type = 18; - pub const MaxProcessMitigationPolicy: Type = 19; + pub const ProcessActivationContextTrustPolicy: Type = 19; + pub const MaxProcessMitigationPolicy: Type = 20; } pub use self::_PROCESS_MITIGATION_POLICY::Type as PROCESS_MITIGATION_POLICY; pub type PPROCESS_MITIGATION_POLICY = *mut _PROCESS_MITIGATION_POLICY::Type; @@ -80508,20 +81074,44 @@ impl _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 } } #[inline] + pub fn DisallowFsctlSystemCalls(&self) -> ULONG { + unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_DisallowFsctlSystemCalls(&mut self, val: ULONG) { + unsafe { + let val: u32 = ::core::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn AuditDisallowFsctlSystemCalls(&self) -> ULONG { + unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_AuditDisallowFsctlSystemCalls(&mut self, val: ULONG) { + unsafe { + let val: u32 = ::core::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] pub fn ReservedFlags(&self) -> ULONG { - unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) } + unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) } } #[inline] pub fn set_ReservedFlags(&mut self, val: ULONG) { unsafe { let val: u32 = ::core::mem::transmute(val); - self._bitfield_1.set(2usize, 30u8, val as u64) + self._bitfield_1.set(4usize, 28u8, val as u64) } } #[inline] pub fn new_bitfield_1( DisallowWin32kSystemCalls: ULONG, AuditDisallowWin32kSystemCalls: ULONG, + DisallowFsctlSystemCalls: ULONG, + AuditDisallowFsctlSystemCalls: ULONG, ReservedFlags: ULONG, ) -> __BindgenBitfieldUnit<[u8; 4usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); @@ -80550,7 +81140,29 @@ impl _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY__bindgen_ty_1__bindgen_ty_1 __bindgen_bitfield_unit .set( 2usize, - 30u8, + 1u8, + { + let DisallowFsctlSystemCalls: u32 = unsafe { + ::core::mem::transmute(DisallowFsctlSystemCalls) + }; + DisallowFsctlSystemCalls as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 3usize, + 1u8, + { + let AuditDisallowFsctlSystemCalls: u32 = unsafe { + ::core::mem::transmute(AuditDisallowFsctlSystemCalls) + }; + AuditDisallowFsctlSystemCalls as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 4usize, + 28u8, { let ReservedFlags: u32 = unsafe { ::core::mem::transmute(ReservedFlags) @@ -83827,6 +84439,183 @@ impl Default for _PROCESS_MITIGATION_REDIRECTION_TRUST_POLICY { pub type PROCESS_MITIGATION_REDIRECTION_TRUST_POLICY = _PROCESS_MITIGATION_REDIRECTION_TRUST_POLICY; pub type PPROCESS_MITIGATION_REDIRECTION_TRUST_POLICY = *mut _PROCESS_MITIGATION_REDIRECTION_TRUST_POLICY; #[repr(C)] +#[derive(Copy, Clone)] +pub struct _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY { + pub __bindgen_anon_1: _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1 { + pub Flags: ULONG, + pub __bindgen_anon_1: _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1__bindgen_ty_1, +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Default, Copy, Clone)] +pub struct _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1__bindgen_ty_1 { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[test] +fn bindgen_test_layout__PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1__bindgen_ty_1() { + assert_eq!( + ::core::mem::size_of::< + _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1__bindgen_ty_1, + >(), + 4usize, + concat!( + "Size of: ", + stringify!( + _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1__bindgen_ty_1 + ), + ), + ); + assert_eq!( + ::core::mem::align_of::< + _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1__bindgen_ty_1, + >(), + 4usize, + concat!( + "Alignment of ", + stringify!( + _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1__bindgen_ty_1 + ), + ), + ); +} +impl _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1__bindgen_ty_1 { + #[inline] + pub fn AssemblyManifestRedirectionTrust(&self) -> ULONG { + unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_AssemblyManifestRedirectionTrust(&mut self, val: ULONG) { + unsafe { + let val: u32 = ::core::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn ReservedFlags(&self) -> ULONG { + unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) } + } + #[inline] + pub fn set_ReservedFlags(&mut self, val: ULONG) { + unsafe { + let val: u32 = ::core::mem::transmute(val); + self._bitfield_1.set(1usize, 31u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + AssemblyManifestRedirectionTrust: ULONG, + ReservedFlags: ULONG, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit + .set( + 0usize, + 1u8, + { + let AssemblyManifestRedirectionTrust: u32 = unsafe { + ::core::mem::transmute(AssemblyManifestRedirectionTrust) + }; + AssemblyManifestRedirectionTrust as u64 + }, + ); + __bindgen_bitfield_unit + .set( + 1usize, + 31u8, + { + let ReservedFlags: u32 = unsafe { + ::core::mem::transmute(ReservedFlags) + }; + ReservedFlags as u64 + }, + ); + __bindgen_bitfield_unit + } +} +#[test] +fn bindgen_test_layout__PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1() { + const UNINIT: ::core::mem::MaybeUninit< + _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1, + > = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::< + _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1, + >(), + 4usize, + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1), + ), + ); + assert_eq!( + ::core::mem::align_of::< + _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1, + >(), + 4usize, + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!( + _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1 + ), + "::", + stringify!(Flags), + ), + ); +} +impl Default for _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[test] +fn bindgen_test_layout__PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY() { + assert_eq!( + ::core::mem::size_of::<_PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY>(), + 4usize, + concat!( + "Size of: ", + stringify!(_PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY), + ), + ); + assert_eq!( + ::core::mem::align_of::<_PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY), + ), + ); +} +impl Default for _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY = _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY; +pub type PPROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY = *mut _PROCESS_MITIGATION_ACTIVATION_CONTEXT_TRUST_POLICY; +#[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _PROCESS_KEEPALIVE_COUNT_INFORMATION { pub WakeCount: ULONG, @@ -156036,6 +156825,808 @@ pub type FILE_ID_EXTD_BOTH_DIR_INFORMATION = _FILE_ID_EXTD_BOTH_DIR_INFORMATION; pub type PFILE_ID_EXTD_BOTH_DIR_INFORMATION = *mut _FILE_ID_EXTD_BOTH_DIR_INFORMATION; #[repr(C)] #[derive(Copy, Clone)] +pub struct _FILE_ID_64_EXTD_DIR_INFORMATION { + pub NextEntryOffset: ULONG, + pub FileIndex: ULONG, + pub CreationTime: LARGE_INTEGER, + pub LastAccessTime: LARGE_INTEGER, + pub LastWriteTime: LARGE_INTEGER, + pub ChangeTime: LARGE_INTEGER, + pub EndOfFile: LARGE_INTEGER, + pub AllocationSize: LARGE_INTEGER, + pub FileAttributes: ULONG, + pub FileNameLength: ULONG, + pub EaSize: ULONG, + pub ReparsePointTag: ULONG, + pub FileId: LARGE_INTEGER, + pub FileName: [WCHAR; 1usize], +} +#[test] +fn bindgen_test_layout__FILE_ID_64_EXTD_DIR_INFORMATION() { + const UNINIT: ::core::mem::MaybeUninit<_FILE_ID_64_EXTD_DIR_INFORMATION> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_FILE_ID_64_EXTD_DIR_INFORMATION>(), + 88usize, + concat!("Size of: ", stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION)), + ); + assert_eq!( + ::core::mem::align_of::<_FILE_ID_64_EXTD_DIR_INFORMATION>(), + 8usize, + concat!("Alignment of ", stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).NextEntryOffset) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(NextEntryOffset), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileIndex) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(FileIndex), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).CreationTime) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(CreationTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).LastAccessTime) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(LastAccessTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).LastWriteTime) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(LastWriteTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ChangeTime) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(ChangeTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EndOfFile) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(EndOfFile), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).AllocationSize) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(AllocationSize), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileAttributes) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(FileAttributes), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileNameLength) as usize - ptr as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(FileNameLength), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EaSize) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(EaSize), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ReparsePointTag) as usize - ptr as usize }, + 68usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(ReparsePointTag), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileId) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(FileId), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileName) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_DIR_INFORMATION), + "::", + stringify!(FileName), + ), + ); +} +impl Default for _FILE_ID_64_EXTD_DIR_INFORMATION { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type FILE_ID_64_EXTD_DIR_INFORMATION = _FILE_ID_64_EXTD_DIR_INFORMATION; +pub type PFILE_ID_64_EXTD_DIR_INFORMATION = *mut _FILE_ID_64_EXTD_DIR_INFORMATION; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _FILE_ID_64_EXTD_BOTH_DIR_INFORMATION { + pub NextEntryOffset: ULONG, + pub FileIndex: ULONG, + pub CreationTime: LARGE_INTEGER, + pub LastAccessTime: LARGE_INTEGER, + pub LastWriteTime: LARGE_INTEGER, + pub ChangeTime: LARGE_INTEGER, + pub EndOfFile: LARGE_INTEGER, + pub AllocationSize: LARGE_INTEGER, + pub FileAttributes: ULONG, + pub FileNameLength: ULONG, + pub EaSize: ULONG, + pub ReparsePointTag: ULONG, + pub FileId: LARGE_INTEGER, + pub ShortNameLength: CCHAR, + pub ShortName: [WCHAR; 12usize], + pub FileName: [WCHAR; 1usize], +} +#[test] +fn bindgen_test_layout__FILE_ID_64_EXTD_BOTH_DIR_INFORMATION() { + const UNINIT: ::core::mem::MaybeUninit<_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION>(), + 112usize, + concat!("Size of: ", stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION)), + ); + assert_eq!( + ::core::mem::align_of::<_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION>(), + 8usize, + concat!("Alignment of ", stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).NextEntryOffset) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(NextEntryOffset), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileIndex) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileIndex), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).CreationTime) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(CreationTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).LastAccessTime) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(LastAccessTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).LastWriteTime) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(LastWriteTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ChangeTime) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(ChangeTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EndOfFile) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(EndOfFile), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).AllocationSize) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(AllocationSize), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileAttributes) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileAttributes), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileNameLength) as usize - ptr as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileNameLength), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EaSize) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(EaSize), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ReparsePointTag) as usize - ptr as usize }, + 68usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(ReparsePointTag), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileId) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileId), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ShortNameLength) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(ShortNameLength), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ShortName) as usize - ptr as usize }, + 82usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(ShortName), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileName) as usize - ptr as usize }, + 106usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_64_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileName), + ), + ); +} +impl Default for _FILE_ID_64_EXTD_BOTH_DIR_INFORMATION { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type FILE_ID_64_EXTD_BOTH_DIR_INFORMATION = _FILE_ID_64_EXTD_BOTH_DIR_INFORMATION; +pub type PFILE_ID_64_EXTD_BOTH_DIR_INFORMATION = *mut _FILE_ID_64_EXTD_BOTH_DIR_INFORMATION; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _FILE_ID_ALL_EXTD_DIR_INFORMATION { + pub NextEntryOffset: ULONG, + pub FileIndex: ULONG, + pub CreationTime: LARGE_INTEGER, + pub LastAccessTime: LARGE_INTEGER, + pub LastWriteTime: LARGE_INTEGER, + pub ChangeTime: LARGE_INTEGER, + pub EndOfFile: LARGE_INTEGER, + pub AllocationSize: LARGE_INTEGER, + pub FileAttributes: ULONG, + pub FileNameLength: ULONG, + pub EaSize: ULONG, + pub ReparsePointTag: ULONG, + pub FileId: LARGE_INTEGER, + pub FileId128: FILE_ID_128, + pub FileName: [WCHAR; 1usize], +} +#[test] +fn bindgen_test_layout__FILE_ID_ALL_EXTD_DIR_INFORMATION() { + const UNINIT: ::core::mem::MaybeUninit<_FILE_ID_ALL_EXTD_DIR_INFORMATION> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_FILE_ID_ALL_EXTD_DIR_INFORMATION>(), + 104usize, + concat!("Size of: ", stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION)), + ); + assert_eq!( + ::core::mem::align_of::<_FILE_ID_ALL_EXTD_DIR_INFORMATION>(), + 8usize, + concat!("Alignment of ", stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).NextEntryOffset) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(NextEntryOffset), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileIndex) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(FileIndex), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).CreationTime) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(CreationTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).LastAccessTime) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(LastAccessTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).LastWriteTime) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(LastWriteTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ChangeTime) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(ChangeTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EndOfFile) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(EndOfFile), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).AllocationSize) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(AllocationSize), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileAttributes) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(FileAttributes), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileNameLength) as usize - ptr as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(FileNameLength), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EaSize) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(EaSize), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ReparsePointTag) as usize - ptr as usize }, + 68usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(ReparsePointTag), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileId) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(FileId), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileId128) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(FileId128), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileName) as usize - ptr as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_DIR_INFORMATION), + "::", + stringify!(FileName), + ), + ); +} +impl Default for _FILE_ID_ALL_EXTD_DIR_INFORMATION { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type FILE_ID_ALL_EXTD_DIR_INFORMATION = _FILE_ID_ALL_EXTD_DIR_INFORMATION; +pub type PFILE_ID_ALL_EXTD_DIR_INFORMATION = *mut _FILE_ID_ALL_EXTD_DIR_INFORMATION; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION { + pub NextEntryOffset: ULONG, + pub FileIndex: ULONG, + pub CreationTime: LARGE_INTEGER, + pub LastAccessTime: LARGE_INTEGER, + pub LastWriteTime: LARGE_INTEGER, + pub ChangeTime: LARGE_INTEGER, + pub EndOfFile: LARGE_INTEGER, + pub AllocationSize: LARGE_INTEGER, + pub FileAttributes: ULONG, + pub FileNameLength: ULONG, + pub EaSize: ULONG, + pub ReparsePointTag: ULONG, + pub FileId: LARGE_INTEGER, + pub FileId128: FILE_ID_128, + pub ShortNameLength: CCHAR, + pub ShortName: [WCHAR; 12usize], + pub FileName: [WCHAR; 1usize], +} +#[test] +fn bindgen_test_layout__FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION() { + const UNINIT: ::core::mem::MaybeUninit<_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION>(), + 128usize, + concat!("Size of: ", stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION)), + ); + assert_eq!( + ::core::mem::align_of::<_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION>(), + 8usize, + concat!("Alignment of ", stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).NextEntryOffset) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(NextEntryOffset), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileIndex) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileIndex), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).CreationTime) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(CreationTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).LastAccessTime) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(LastAccessTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).LastWriteTime) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(LastWriteTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ChangeTime) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(ChangeTime), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EndOfFile) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(EndOfFile), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).AllocationSize) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(AllocationSize), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileAttributes) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileAttributes), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileNameLength) as usize - ptr as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileNameLength), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EaSize) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(EaSize), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ReparsePointTag) as usize - ptr as usize }, + 68usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(ReparsePointTag), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileId) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileId), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileId128) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileId128), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ShortNameLength) as usize - ptr as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(ShortNameLength), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ShortName) as usize - ptr as usize }, + 98usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(ShortName), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FileName) as usize - ptr as usize }, + 122usize, + concat!( + "Offset of field: ", + stringify!(_FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION), + "::", + stringify!(FileName), + ), + ); +} +impl Default for _FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION = _FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION; +pub type PFILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION = *mut _FILE_ID_ALL_EXTD_BOTH_DIR_INFORMATION; +#[repr(C)] +#[derive(Copy, Clone)] pub struct _FILE_OBJECTID_INFORMATION { pub FileReference: LONGLONG, pub ObjectId: [UCHAR; 16usize], @@ -159381,6 +160972,38 @@ fn bindgen_test_layout__FILE_FS_DATA_COPY_INFORMATION() { pub type FILE_FS_DATA_COPY_INFORMATION = _FILE_FS_DATA_COPY_INFORMATION; pub type PFILE_FS_DATA_COPY_INFORMATION = *mut _FILE_FS_DATA_COPY_INFORMATION; #[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _FILE_FS_GUID_INFORMATION { + pub FsGuid: GUID, +} +#[test] +fn bindgen_test_layout__FILE_FS_GUID_INFORMATION() { + const UNINIT: ::core::mem::MaybeUninit<_FILE_FS_GUID_INFORMATION> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_FILE_FS_GUID_INFORMATION>(), + 16usize, + concat!("Size of: ", stringify!(_FILE_FS_GUID_INFORMATION)), + ); + assert_eq!( + ::core::mem::align_of::<_FILE_FS_GUID_INFORMATION>(), + 4usize, + concat!("Alignment of ", stringify!(_FILE_FS_GUID_INFORMATION)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).FsGuid) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_FILE_FS_GUID_INFORMATION), + "::", + stringify!(FsGuid), + ), + ); +} +pub type FILE_FS_GUID_INFORMATION = _FILE_FS_GUID_INFORMATION; +pub type PFILE_FS_GUID_INFORMATION = *mut _FILE_FS_GUID_INFORMATION; +#[repr(C)] #[derive(Copy, Clone)] pub struct _FILE_END_OF_FILE_INFORMATION_EX { pub EndOfFile: LARGE_INTEGER, @@ -159898,7 +161521,9 @@ pub struct REFS_VOLUME_DATA_BUFFER { pub FastTierDataFillRatio: USHORT, pub SlowTierDataFillRatio: USHORT, pub DestagesFastTierToSlowTierRate: ULONG, - pub Reserved: [LARGE_INTEGER; 9usize], + pub MetadataChecksumType: USHORT, + pub Reserved0: [UCHAR; 6usize], + pub Reserved: [LARGE_INTEGER; 8usize], } #[test] fn bindgen_test_layout_REFS_VOLUME_DATA_BUFFER() { @@ -160079,8 +161704,30 @@ fn bindgen_test_layout_REFS_VOLUME_DATA_BUFFER() { ), ); assert_eq!( - unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, + unsafe { + ::core::ptr::addr_of!((*ptr).MetadataChecksumType) as usize - ptr as usize + }, 80usize, + concat!( + "Offset of field: ", + stringify!(REFS_VOLUME_DATA_BUFFER), + "::", + stringify!(MetadataChecksumType), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Reserved0) as usize - ptr as usize }, + 82usize, + concat!( + "Offset of field: ", + stringify!(REFS_VOLUME_DATA_BUFFER), + "::", + stringify!(Reserved0), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, + 88usize, concat!( "Offset of field: ", stringify!(REFS_VOLUME_DATA_BUFFER), @@ -179398,54 +181045,54 @@ pub struct _VOLUME_REFS_INFO_BUFFER { pub CachePopulationUpdatesCounter: LONG, pub CacheWriteThroughUpdatesCounter: LONG, pub MaxCacheTransactionsOutstanding: LONG, - pub DataWritesReallocationCount: LONG, - pub DataInPlaceWriteCount: LONG, - pub MetadataAllocationsFastTierCount: LONG, - pub MetadataAllocationsSlowTierCount: LONG, - pub DataAllocationsFastTierCount: LONG, - pub DataAllocationsSlowTierCount: LONG, - pub DestagesSlowTierToFastTier: LONG, - pub DestagesFastTierToSlowTier: LONG, + pub DataWritesReallocationCount: LONGLONG, + pub DataInPlaceWriteCount: LONGLONG, + pub MetadataAllocationsFastTierCount: LONGLONG, + pub MetadataAllocationsSlowTierCount: LONGLONG, + pub DataAllocationsFastTierCount: LONGLONG, + pub DataAllocationsSlowTierCount: LONGLONG, + pub DestagesSlowTierToFastTier: LONGLONG, + pub DestagesFastTierToSlowTier: LONGLONG, pub SlowTierDataFillRatio: LONG, pub FastTierDataFillRatio: LONG, pub SlowTierMetadataFillRatio: LONG, pub FastTierMetadataFillRatio: LONG, - pub SlowToFastDestageReadLatency: LONG, + pub SlowToFastDestageReadLatency: LONGLONG, pub SlowToFastDestageReadLatencyBase: LONG, - pub SlowToFastDestageWriteLatency: LONG, + pub SlowToFastDestageWriteLatency: LONGLONG, pub SlowToFastDestageWriteLatencyBase: LONG, - pub FastToSlowDestageReadLatency: LONG, + pub FastToSlowDestageReadLatency: LONGLONG, pub FastToSlowDestageReadLatencyBase: LONG, - pub FastToSlowDestageWriteLatency: LONG, + pub FastToSlowDestageWriteLatency: LONGLONG, pub FastToSlowDestageWriteLatencyBase: LONG, - pub SlowTierContainerFillRatio: LONG, + pub SlowTierContainerFillRatio: LONGLONG, pub SlowTierContainerFillRatioBase: LONG, - pub FastTierContainerFillRatio: LONG, + pub FastTierContainerFillRatio: LONGLONG, pub FastTierContainerFillRatioBase: LONG, - pub TreeUpdateLatency: LONG, - pub TreeUpdateLatencyBase: LONG, - pub CheckpointLatency: LONG, - pub CheckpointLatencyBase: LONG, - pub TreeUpdateCount: LONG, - pub CheckpointCount: LONG, - pub LogWriteCount: LONG, + pub Unused1: LONG, + pub Unused2: LONG, + pub Unused3: LONG, + pub Unused4: LONG, + pub TreeUpdateCount: LONGLONG, + pub CheckpointCount: LONGLONG, + pub LogWriteCount: LONGLONG, pub LogFillRatio: LONG, pub ReadCacheInvalidationsForOverwrite: LONG, pub ReadCacheInvalidationsForReuse: LONG, pub ReadCacheInvalidationsGeneral: LONG, pub ReadCacheChecksOnMount: LONG, pub ReadCacheIssuesOnMount: LONG, - pub TrimLatency: LONG, + pub TrimLatency: LONGLONG, pub TrimLatencyBase: LONG, - pub DataCompactionCount: LONG, - pub CompactionReadLatency: LONG, + pub DataCompactionCount: LONGLONG, + pub CompactionReadLatency: LONGLONG, pub CompactionReadLatencyBase: LONG, - pub CompactionWriteLatency: LONG, + pub CompactionWriteLatency: LONGLONG, pub CompactionWriteLatencyBase: LONG, pub DataInPlaceWriteClusterCount: LARGE_INTEGER, pub CompactionFailedDueToIneligibleContainer: LONG, pub CompactionFailedDueToMaxFragmentation: LONG, - pub CompactedContainerFillRatio: LONG, + pub CompactedContainerFillRatio: LONGLONG, pub CompactedContainerFillRatioBase: LONG, pub ContainerMoveRetryCount: LONG, pub ContainerMoveFailedDueToIneligibleContainer: LONG, @@ -179454,6 +181101,22 @@ pub struct _VOLUME_REFS_INFO_BUFFER { pub NumberOfDirtyMetadataPages: LARGE_INTEGER, pub NumberOfDirtyTableListEntries: LONG, pub NumberOfDeleteQueueEntries: LONG, + pub MAAFilteredViewSize: LONG, + pub MAAFilteredViewInsertions: LONG, + pub MAAFilteredViewDeletions: LONG, + pub MAAFilteredViewCollisions: LONG, + pub MAAFilteredViewPurges: LONG, + pub MAARegionsVisitedPerAllocationSum: LONGLONG, + pub MAARegionsVisitedPerAllocationBase: LONG, + pub MAAMaxRegionsVisitedPerAllocation: LONG, + pub TreeUpdateLatencyExclusive: LONGLONG, + pub TreeUpdateLatencyTotal: LONGLONG, + pub TreeUpdateLatencyBase: LONG, + pub CheckpointLatencyTreeUpdateExclusive: LONGLONG, + pub CheckpointLatencyTreeUpdateTotal: LONGLONG, + pub CheckpointLatencyTreeUpdateBase: LONG, + pub CheckpointLatencyTotal: LONGLONG, + pub CheckpointLatencyTotalBase: LONG, } #[test] fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { @@ -179461,7 +181124,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { let ptr = UNINIT.as_ptr(); assert_eq!( ::core::mem::size_of::<_VOLUME_REFS_INFO_BUFFER>(), - 376usize, + 608usize, concat!("Size of: ", stringify!(_VOLUME_REFS_INFO_BUFFER)), ); assert_eq!( @@ -179754,7 +181417,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).DataWritesReallocationCount) as usize - ptr as usize }, - 140usize, + 144usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179766,7 +181429,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).DataInPlaceWriteCount) as usize - ptr as usize }, - 144usize, + 152usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179779,7 +181442,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).MetadataAllocationsFastTierCount) as usize - ptr as usize }, - 148usize, + 160usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179792,7 +181455,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).MetadataAllocationsSlowTierCount) as usize - ptr as usize }, - 152usize, + 168usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179805,7 +181468,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).DataAllocationsFastTierCount) as usize - ptr as usize }, - 156usize, + 176usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179818,7 +181481,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).DataAllocationsSlowTierCount) as usize - ptr as usize }, - 160usize, + 184usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179831,7 +181494,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).DestagesSlowTierToFastTier) as usize - ptr as usize }, - 164usize, + 192usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179844,7 +181507,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).DestagesFastTierToSlowTier) as usize - ptr as usize }, - 168usize, + 200usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179856,7 +181519,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).SlowTierDataFillRatio) as usize - ptr as usize }, - 172usize, + 208usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179868,7 +181531,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).FastTierDataFillRatio) as usize - ptr as usize }, - 176usize, + 212usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179881,7 +181544,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).SlowTierMetadataFillRatio) as usize - ptr as usize }, - 180usize, + 216usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179894,7 +181557,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).FastTierMetadataFillRatio) as usize - ptr as usize }, - 184usize, + 220usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179907,7 +181570,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).SlowToFastDestageReadLatency) as usize - ptr as usize }, - 188usize, + 224usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179920,7 +181583,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).SlowToFastDestageReadLatencyBase) as usize - ptr as usize }, - 192usize, + 232usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179933,7 +181596,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).SlowToFastDestageWriteLatency) as usize - ptr as usize }, - 196usize, + 240usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179946,7 +181609,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).SlowToFastDestageWriteLatencyBase) as usize - ptr as usize }, - 200usize, + 248usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179959,7 +181622,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).FastToSlowDestageReadLatency) as usize - ptr as usize }, - 204usize, + 256usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179972,7 +181635,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).FastToSlowDestageReadLatencyBase) as usize - ptr as usize }, - 208usize, + 264usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179985,7 +181648,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).FastToSlowDestageWriteLatency) as usize - ptr as usize }, - 212usize, + 272usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -179998,7 +181661,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).FastToSlowDestageWriteLatencyBase) as usize - ptr as usize }, - 216usize, + 280usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180011,7 +181674,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).SlowTierContainerFillRatio) as usize - ptr as usize }, - 220usize, + 288usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180024,7 +181687,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).SlowTierContainerFillRatioBase) as usize - ptr as usize }, - 224usize, + 296usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180037,7 +181700,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).FastTierContainerFillRatio) as usize - ptr as usize }, - 228usize, + 304usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180050,7 +181713,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).FastTierContainerFillRatioBase) as usize - ptr as usize }, - 232usize, + 312usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180059,56 +181722,48 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ), ); assert_eq!( - unsafe { - ::core::ptr::addr_of!((*ptr).TreeUpdateLatency) as usize - ptr as usize - }, - 236usize, + unsafe { ::core::ptr::addr_of!((*ptr).Unused1) as usize - ptr as usize }, + 316usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), "::", - stringify!(TreeUpdateLatency), + stringify!(Unused1), ), ); assert_eq!( - unsafe { - ::core::ptr::addr_of!((*ptr).TreeUpdateLatencyBase) as usize - ptr as usize - }, - 240usize, + unsafe { ::core::ptr::addr_of!((*ptr).Unused2) as usize - ptr as usize }, + 320usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), "::", - stringify!(TreeUpdateLatencyBase), + stringify!(Unused2), ), ); assert_eq!( - unsafe { - ::core::ptr::addr_of!((*ptr).CheckpointLatency) as usize - ptr as usize - }, - 244usize, + unsafe { ::core::ptr::addr_of!((*ptr).Unused3) as usize - ptr as usize }, + 324usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), "::", - stringify!(CheckpointLatency), + stringify!(Unused3), ), ); assert_eq!( - unsafe { - ::core::ptr::addr_of!((*ptr).CheckpointLatencyBase) as usize - ptr as usize - }, - 248usize, + unsafe { ::core::ptr::addr_of!((*ptr).Unused4) as usize - ptr as usize }, + 328usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), "::", - stringify!(CheckpointLatencyBase), + stringify!(Unused4), ), ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).TreeUpdateCount) as usize - ptr as usize }, - 252usize, + 336usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180118,7 +181773,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).CheckpointCount) as usize - ptr as usize }, - 256usize, + 344usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180128,7 +181783,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).LogWriteCount) as usize - ptr as usize }, - 260usize, + 352usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180138,7 +181793,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).LogFillRatio) as usize - ptr as usize }, - 264usize, + 360usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180151,7 +181806,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).ReadCacheInvalidationsForOverwrite) as usize - ptr as usize }, - 268usize, + 364usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180164,7 +181819,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).ReadCacheInvalidationsForReuse) as usize - ptr as usize }, - 272usize, + 368usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180177,7 +181832,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).ReadCacheInvalidationsGeneral) as usize - ptr as usize }, - 276usize, + 372usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180189,7 +181844,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).ReadCacheChecksOnMount) as usize - ptr as usize }, - 280usize, + 376usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180201,7 +181856,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).ReadCacheIssuesOnMount) as usize - ptr as usize }, - 284usize, + 380usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180211,7 +181866,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).TrimLatency) as usize - ptr as usize }, - 288usize, + 384usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180221,7 +181876,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).TrimLatencyBase) as usize - ptr as usize }, - 292usize, + 392usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180233,7 +181888,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).DataCompactionCount) as usize - ptr as usize }, - 296usize, + 400usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180245,7 +181900,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).CompactionReadLatency) as usize - ptr as usize }, - 300usize, + 408usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180258,7 +181913,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).CompactionReadLatencyBase) as usize - ptr as usize }, - 304usize, + 416usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180270,7 +181925,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).CompactionWriteLatency) as usize - ptr as usize }, - 308usize, + 424usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180283,7 +181938,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).CompactionWriteLatencyBase) as usize - ptr as usize }, - 312usize, + 432usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180296,7 +181951,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).DataInPlaceWriteClusterCount) as usize - ptr as usize }, - 320usize, + 440usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180309,7 +181964,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).CompactionFailedDueToIneligibleContainer) as usize - ptr as usize }, - 328usize, + 448usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180322,7 +181977,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).CompactionFailedDueToMaxFragmentation) as usize - ptr as usize }, - 332usize, + 452usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180335,7 +181990,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).CompactedContainerFillRatio) as usize - ptr as usize }, - 336usize, + 456usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180348,7 +182003,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).CompactedContainerFillRatioBase) as usize - ptr as usize }, - 340usize, + 464usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180360,7 +182015,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).ContainerMoveRetryCount) as usize - ptr as usize }, - 344usize, + 468usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180373,7 +182028,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).ContainerMoveFailedDueToIneligibleContainer) as usize - ptr as usize }, - 348usize, + 472usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180385,7 +182040,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).CompactionFailureCount) as usize - ptr as usize }, - 352usize, + 476usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180398,7 +182053,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).ContainerMoveFailureCount) as usize - ptr as usize }, - 356usize, + 480usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180411,7 +182066,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).NumberOfDirtyMetadataPages) as usize - ptr as usize }, - 360usize, + 488usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180424,7 +182079,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).NumberOfDirtyTableListEntries) as usize - ptr as usize }, - 368usize, + 496usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180437,7 +182092,7 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { ::core::ptr::addr_of!((*ptr).NumberOfDeleteQueueEntries) as usize - ptr as usize }, - 372usize, + 500usize, concat!( "Offset of field: ", stringify!(_VOLUME_REFS_INFO_BUFFER), @@ -180445,6 +182100,209 @@ fn bindgen_test_layout__VOLUME_REFS_INFO_BUFFER() { stringify!(NumberOfDeleteQueueEntries), ), ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MAAFilteredViewSize) as usize - ptr as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(MAAFilteredViewSize), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MAAFilteredViewInsertions) as usize + - ptr as usize + }, + 508usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(MAAFilteredViewInsertions), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MAAFilteredViewDeletions) as usize + - ptr as usize + }, + 512usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(MAAFilteredViewDeletions), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MAAFilteredViewCollisions) as usize + - ptr as usize + }, + 516usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(MAAFilteredViewCollisions), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MAAFilteredViewPurges) as usize - ptr as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(MAAFilteredViewPurges), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MAARegionsVisitedPerAllocationSum) as usize + - ptr as usize + }, + 528usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(MAARegionsVisitedPerAllocationSum), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MAARegionsVisitedPerAllocationBase) as usize + - ptr as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(MAARegionsVisitedPerAllocationBase), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MAAMaxRegionsVisitedPerAllocation) as usize + - ptr as usize + }, + 540usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(MAAMaxRegionsVisitedPerAllocation), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).TreeUpdateLatencyExclusive) as usize + - ptr as usize + }, + 544usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(TreeUpdateLatencyExclusive), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).TreeUpdateLatencyTotal) as usize - ptr as usize + }, + 552usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(TreeUpdateLatencyTotal), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).TreeUpdateLatencyBase) as usize - ptr as usize + }, + 560usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(TreeUpdateLatencyBase), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).CheckpointLatencyTreeUpdateExclusive) as usize + - ptr as usize + }, + 568usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(CheckpointLatencyTreeUpdateExclusive), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).CheckpointLatencyTreeUpdateTotal) as usize + - ptr as usize + }, + 576usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(CheckpointLatencyTreeUpdateTotal), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).CheckpointLatencyTreeUpdateBase) as usize + - ptr as usize + }, + 584usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(CheckpointLatencyTreeUpdateBase), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).CheckpointLatencyTotal) as usize - ptr as usize + }, + 592usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(CheckpointLatencyTotal), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).CheckpointLatencyTotalBase) as usize + - ptr as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(_VOLUME_REFS_INFO_BUFFER), + "::", + stringify!(CheckpointLatencyTotalBase), + ), + ); } impl Default for _VOLUME_REFS_INFO_BUFFER { fn default() -> Self { @@ -181679,6 +183537,7 @@ pub type PREFS_STREAM_SNAPSHOT_QUERY_DELTAS_OUTPUT_BUFFER = *mut _REFS_STREAM_SN #[derive(Copy, Clone)] pub struct _DUPLICATE_CLUSTER_DATA { pub SourceLcn: LONGLONG, + pub TargetLcn: LONGLONG, pub TargetFileOffset: LARGE_INTEGER, pub DuplicationLimit: ULONG, pub Reserved: ULONG, @@ -181689,7 +183548,7 @@ fn bindgen_test_layout__DUPLICATE_CLUSTER_DATA() { let ptr = UNINIT.as_ptr(); assert_eq!( ::core::mem::size_of::<_DUPLICATE_CLUSTER_DATA>(), - 24usize, + 32usize, concat!("Size of: ", stringify!(_DUPLICATE_CLUSTER_DATA)), ); assert_eq!( @@ -181707,11 +183566,21 @@ fn bindgen_test_layout__DUPLICATE_CLUSTER_DATA() { stringify!(SourceLcn), ), ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).TargetLcn) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_DUPLICATE_CLUSTER_DATA), + "::", + stringify!(TargetLcn), + ), + ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).TargetFileOffset) as usize - ptr as usize }, - 8usize, + 16usize, concat!( "Offset of field: ", stringify!(_DUPLICATE_CLUSTER_DATA), @@ -181723,7 +183592,7 @@ fn bindgen_test_layout__DUPLICATE_CLUSTER_DATA() { unsafe { ::core::ptr::addr_of!((*ptr).DuplicationLimit) as usize - ptr as usize }, - 16usize, + 24usize, concat!( "Offset of field: ", stringify!(_DUPLICATE_CLUSTER_DATA), @@ -181733,7 +183602,7 @@ fn bindgen_test_layout__DUPLICATE_CLUSTER_DATA() { ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, - 20usize, + 28usize, concat!( "Offset of field: ", stringify!(_DUPLICATE_CLUSTER_DATA), @@ -181756,9 +183625,13 @@ pub type PDUPLICATE_CLUSTER_DATA = *mut _DUPLICATE_CLUSTER_DATA; pub mod _LCN_WEAK_REFERENCE_STATE { pub type Type = ::core::ffi::c_int; pub const LCN_WEAK_REFERENCE_VALID: Type = 1; - pub const LCN_CHECKSUM_VALID: Type = 2; + pub const LCN_WEAK_REFERENCE_BROKEN: Type = 2; + pub const LCN_CHECKSUM_VALID: Type = 4; + pub const LCN_IS_VALID: Type = 8; + pub const LCN_IS_STREAM_RESERVED: Type = 16; + pub const LCN_IS_READ_ONLY: Type = 32; } -pub type LCN_WEAK_REFERENCE_STATE = USHORT; +pub type LCN_WEAK_REFERENCE_STATE = ULONG; pub type PLCN_WEAK_REFERENCE_STATE = *mut LCN_WEAK_REFERENCE_STATE; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] @@ -181896,70 +183769,456 @@ pub type LCN_WEAK_REFERENCE_CREATE_INPUT_BUFFER = _LCN_WEAK_REFERENCE_CREATE_INP pub type PLCN_WEAK_REFERENCE_CREATE_INPUT_BUFFER = *mut _LCN_WEAK_REFERENCE_CREATE_INPUT_BUFFER; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] -pub struct _REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER { +pub struct _LCN_WEAK_REFERENCE_VCN_MAPPING { + pub Vcn: LONGLONG, + pub Lcn: LONGLONG, + pub CountOfRange: LONGLONG, +} +#[test] +fn bindgen_test_layout__LCN_WEAK_REFERENCE_VCN_MAPPING() { + const UNINIT: ::core::mem::MaybeUninit<_LCN_WEAK_REFERENCE_VCN_MAPPING> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_LCN_WEAK_REFERENCE_VCN_MAPPING>(), + 24usize, + concat!("Size of: ", stringify!(_LCN_WEAK_REFERENCE_VCN_MAPPING)), + ); + assert_eq!( + ::core::mem::align_of::<_LCN_WEAK_REFERENCE_VCN_MAPPING>(), + 8usize, + concat!("Alignment of ", stringify!(_LCN_WEAK_REFERENCE_VCN_MAPPING)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Vcn) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_LCN_WEAK_REFERENCE_VCN_MAPPING), + "::", + stringify!(Vcn), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Lcn) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_LCN_WEAK_REFERENCE_VCN_MAPPING), + "::", + stringify!(Lcn), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).CountOfRange) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_LCN_WEAK_REFERENCE_VCN_MAPPING), + "::", + stringify!(CountOfRange), + ), + ); +} +pub type LCN_WEAK_REFERENCE_VCN_MAPPING = _LCN_WEAK_REFERENCE_VCN_MAPPING; +pub type PLCN_WEAK_REFERENCE_VCN_MAPPING = *mut _LCN_WEAK_REFERENCE_VCN_MAPPING; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER { + pub MappingCount: ULONG, + pub VcnLcnMappings: [LCN_WEAK_REFERENCE_VCN_MAPPING; 1usize], +} +#[test] +fn bindgen_test_layout__LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER() { + const UNINIT: ::core::mem::MaybeUninit<_LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER>(), + 32usize, + concat!("Size of: ", stringify!(_LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER)), + ); + assert_eq!( + ::core::mem::align_of::<_LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER>(), + 8usize, + concat!("Alignment of ", stringify!(_LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).MappingCount) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER), + "::", + stringify!(MappingCount), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).VcnLcnMappings) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER), + "::", + stringify!(VcnLcnMappings), + ), + ); +} +pub type LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER = _LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER; +pub type PLCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER = *mut _LCN_WEAK_REFERENCE_CREATE_OUTPUT_BUFFER; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _LCN_WEAK_REFERENCE_RANGE { + pub StartOfRange: LONGLONG, + pub CountOfRange: LONGLONG, +} +#[test] +fn bindgen_test_layout__LCN_WEAK_REFERENCE_RANGE() { + const UNINIT: ::core::mem::MaybeUninit<_LCN_WEAK_REFERENCE_RANGE> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_LCN_WEAK_REFERENCE_RANGE>(), + 16usize, + concat!("Size of: ", stringify!(_LCN_WEAK_REFERENCE_RANGE)), + ); + assert_eq!( + ::core::mem::align_of::<_LCN_WEAK_REFERENCE_RANGE>(), + 8usize, + concat!("Alignment of ", stringify!(_LCN_WEAK_REFERENCE_RANGE)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).StartOfRange) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_LCN_WEAK_REFERENCE_RANGE), + "::", + stringify!(StartOfRange), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).CountOfRange) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_LCN_WEAK_REFERENCE_RANGE), + "::", + stringify!(CountOfRange), + ), + ); +} +pub type LCN_WEAK_REFERENCE_RANGE = _LCN_WEAK_REFERENCE_RANGE; +pub type PLCN_WEAK_REFERENCE_RANGE = *mut _LCN_WEAK_REFERENCE_RANGE; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER { + pub RangeCount: ULONG, + pub Ranges: [LCN_WEAK_REFERENCE_RANGE; 1usize], +} +#[test] +fn bindgen_test_layout__LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER() { + const UNINIT: ::core::mem::MaybeUninit<_LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER>(), + 24usize, + concat!("Size of: ", stringify!(_LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER)), + ); + assert_eq!( + ::core::mem::align_of::<_LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER>(), + 8usize, + concat!("Alignment of ", stringify!(_LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).RangeCount) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER), + "::", + stringify!(RangeCount), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Ranges) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER), + "::", + stringify!(Ranges), + ), + ); +} +pub type LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER = _LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER; +pub type PLCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER = *mut _LCN_WEAK_REFERENCE_CLEAR_INPUT_BUFFER; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER { + pub Version: ULONG, + pub SetDedupState: BOOLEAN, pub Enable: BOOLEAN, + pub SetWeakRefState: BOOLEAN, + pub EnableWeakRef: BOOLEAN, + pub SetDirtyRangeTrackingState: BOOLEAN, + pub EnableDirtyRangeTracking: BOOLEAN, } #[test] -fn bindgen_test_layout__REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER() { - const UNINIT: ::core::mem::MaybeUninit<_REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER> = ::core::mem::MaybeUninit::uninit(); +fn bindgen_test_layout__REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER() { + const UNINIT: ::core::mem::MaybeUninit<_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER> = ::core::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::core::mem::size_of::<_REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER>(), - 1usize, - concat!("Size of: ", stringify!(_REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER)), + ::core::mem::size_of::<_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER>(), + 12usize, + concat!("Size of: ", stringify!(_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER)), ); assert_eq!( - ::core::mem::align_of::<_REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER>(), - 1usize, - concat!("Alignment of ", stringify!(_REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER)), + ::core::mem::align_of::<_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER>(), + 4usize, + concat!("Alignment of ", stringify!(_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER)), ); assert_eq!( - unsafe { ::core::ptr::addr_of!((*ptr).Enable) as usize - ptr as usize }, + unsafe { ::core::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER), + stringify!(_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER), + "::", + stringify!(Version), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).SetDedupState) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER), + "::", + stringify!(SetDedupState), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Enable) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER), "::", stringify!(Enable), ), ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).SetWeakRefState) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER), + "::", + stringify!(SetWeakRefState), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EnableWeakRef) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER), + "::", + stringify!(EnableWeakRef), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).SetDirtyRangeTrackingState) as usize + - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER), + "::", + stringify!(SetDirtyRangeTrackingState), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).EnableDirtyRangeTracking) as usize + - ptr as usize + }, + 9usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER), + "::", + stringify!(EnableDirtyRangeTracking), + ), + ); } -pub type REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER = _REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER; -pub type PREFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER = *mut _REFS_SET_VOLUME_DEDUP_INFO_INPUT_BUFFER; +pub type REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER = _REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER; +pub type PREFS_VOLUME_DEDUP_INFO_INPUT_BUFFER = *mut _REFS_VOLUME_DEDUP_INFO_INPUT_BUFFER; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] -pub struct _REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER { +pub struct _REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER { + pub Version: ULONG, pub Enabled: BOOLEAN, + pub EnabledWeakRef: BOOLEAN, + pub EnabledDirtyRangeTracking: BOOLEAN, + pub IsClustered: BOOLEAN, + pub VolumeIdHash: ULONG, + pub VolumeGuid: GUID, + pub VolumeUniqueGuid: GUID, +} +#[test] +fn bindgen_test_layout__REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER() { + const UNINIT: ::core::mem::MaybeUninit<_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER>(), + 44usize, + concat!("Size of: ", stringify!(_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER)), + ); + assert_eq!( + ::core::mem::align_of::<_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER>(), + 4usize, + concat!("Alignment of ", stringify!(_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER), + "::", + stringify!(Version), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Enabled) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER), + "::", + stringify!(Enabled), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EnabledWeakRef) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER), + "::", + stringify!(EnabledWeakRef), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).EnabledDirtyRangeTracking) as usize + - ptr as usize + }, + 6usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER), + "::", + stringify!(EnabledDirtyRangeTracking), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).IsClustered) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER), + "::", + stringify!(IsClustered), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).VolumeIdHash) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER), + "::", + stringify!(VolumeIdHash), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).VolumeGuid) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER), + "::", + stringify!(VolumeGuid), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).VolumeUniqueGuid) as usize - ptr as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(_REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER), + "::", + stringify!(VolumeUniqueGuid), + ), + ); +} +pub type REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER = _REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER; +pub type PREFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER = *mut _REFS_VOLUME_DEDUP_INFO_OUTPUT_BUFFER; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER { + pub Version: ULONG, + pub TotalSharedLcns: ULONGLONG, } #[test] -fn bindgen_test_layout__REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER() { +fn bindgen_test_layout__REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER() { const UNINIT: ::core::mem::MaybeUninit< - _REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER, + _REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER, > = ::core::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::core::mem::size_of::<_REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER>(), - 1usize, - concat!("Size of: ", stringify!(_REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER)), + ::core::mem::size_of::<_REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER>(), + 16usize, + concat!( + "Size of: ", + stringify!(_REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER), + ), ); assert_eq!( - ::core::mem::align_of::<_REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER>(), - 1usize, - concat!("Alignment of ", stringify!(_REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER)), + ::core::mem::align_of::<_REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER), + ), ); assert_eq!( - unsafe { ::core::ptr::addr_of!((*ptr).Enabled) as usize - ptr as usize }, + unsafe { ::core::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, 0usize, concat!( "Offset of field: ", - stringify!(_REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER), + stringify!(_REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER), "::", - stringify!(Enabled), + stringify!(Version), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).TotalSharedLcns) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER), + "::", + stringify!(TotalSharedLcns), ), ); } -pub type REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER = _REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER; -pub type PREFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER = *mut _REFS_QUERY_VOLUME_DEDUP_INFO_OUTPUT_BUFFER; +pub type REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER = _REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER; +pub type PREFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER = *mut _REFS_QUERY_VOLUME_TOTAL_SHARED_LCNS_OUTPUT_BUFFER; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct _SET_CACHED_RUNS_STATE_INPUT_BUFFER { @@ -181994,28 +184253,35 @@ pub type SET_CACHED_RUNS_STATE_INPUT_BUFFER = _SET_CACHED_RUNS_STATE_INPUT_BUFFE pub type PSET_CACHED_RUNS_STATE_INPUT_BUFFER = *mut _SET_CACHED_RUNS_STATE_INPUT_BUFFER; pub mod _REFS_COMPRESSION_FORMATS { pub type Type = ::core::ffi::c_int; - pub const REFS_COMPRESSION_FORMAT_UNCOMPRESSED: Type = 0; - pub const REFS_COMPRESSION_FORMAT_LZ4: Type = 1; - pub const REFS_COMPRESSION_FORMAT_ZSTD: Type = 2; - pub const REFS_COMPRESSION_FORMAT_MAX: Type = 3; + pub const REFS_COMPRESSION_FORMAT_UNCHANGED: Type = 0; + pub const REFS_COMPRESSION_FORMAT_UNKNOWN: Type = 1; + pub const REFS_COMPRESSION_FORMAT_UNCOMPRESSED: Type = 2; + pub const REFS_COMPRESSION_FORMAT_LZ4: Type = 3; + pub const REFS_COMPRESSION_FORMAT_ZSTD: Type = 4; } pub use self::_REFS_COMPRESSION_FORMATS::Type as REFS_COMPRESSION_FORMATS; pub type PREFS_COMPRESSION_FORMATS = *mut _REFS_COMPRESSION_FORMATS::Type; pub mod _REFS_SET_VOLUME_COMPRESSION_INFO_FLAGS { pub type Type = ::core::ffi::c_int; - pub const REFS_SET_VOLUME_COMPRESSION_INFO_FLAG_COMPRESS_SYNC: Type = 1; - pub const REFS_SET_VOLUME_COMPRESSION_INFO_FLAG_MAX: Type = 1; + pub const REFS_SET_VOLUME_COMPRESSION_INFO_FLAG_START_COMPRESSION: Type = 1; + pub const REFS_SET_VOLUME_COMPRESSION_INFO_FLAG_STOP_COMPRESSION: Type = 2; + pub const REFS_SET_VOLUME_COMPRESSION_INFO_FLAG_GC_ONLY: Type = 4; + pub const REFS_SET_VOLUME_COMPRESSION_INFO_FLAG_MAX: Type = 2; } pub use self::_REFS_SET_VOLUME_COMPRESSION_INFO_FLAGS::Type as REFS_SET_VOLUME_COMPRESSION_INFO_FLAGS; pub type PREFS_SET_VOLUME_COMPRESSION_INFO_FLAGS = *mut _REFS_SET_VOLUME_COMPRESSION_INFO_FLAGS::Type; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER { + pub Version: ULONG, pub CompressionFormat: REFS_COMPRESSION_FORMATS, pub CompressionLevel: SHORT, pub CompressionChunkSizeBytes: ULONG, - pub Flags: REFS_SET_VOLUME_COMPRESSION_INFO_FLAGS, - pub Reserved: [ULONGLONG; 8usize], + pub Flags: ULONG, + pub CompressionTuning: ULONG, + pub RecompressionTuning: ULONG, + pub DecompressionTuning: ULONG, + pub Reserved: [ULONG; 6usize], } #[test] fn bindgen_test_layout__REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER() { @@ -182025,22 +184291,32 @@ fn bindgen_test_layout__REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER() { let ptr = UNINIT.as_ptr(); assert_eq!( ::core::mem::size_of::<_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER>(), - 80usize, + 56usize, concat!("Size of: ", stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER)), ); assert_eq!( ::core::mem::align_of::<_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER>(), - 8usize, + 4usize, concat!( "Alignment of ", stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER), ), ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER), + "::", + stringify!(Version), + ), + ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).CompressionFormat) as usize - ptr as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER), @@ -182052,7 +184328,7 @@ fn bindgen_test_layout__REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).CompressionLevel) as usize - ptr as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER), @@ -182065,7 +184341,7 @@ fn bindgen_test_layout__REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER() { ::core::ptr::addr_of!((*ptr).CompressionChunkSizeBytes) as usize - ptr as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER), @@ -182075,7 +184351,7 @@ fn bindgen_test_layout__REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER() { ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER), @@ -182083,9 +184359,45 @@ fn bindgen_test_layout__REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER() { stringify!(Flags), ), ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).CompressionTuning) as usize - ptr as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER), + "::", + stringify!(CompressionTuning), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).RecompressionTuning) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER), + "::", + stringify!(RecompressionTuning), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).DecompressionTuning) as usize - ptr as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER), + "::", + stringify!(DecompressionTuning), + ), + ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, - 16usize, + 32usize, concat!( "Offset of field: ", stringify!(_REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER), @@ -182105,9 +184417,17 @@ impl Default for _REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER { } pub type REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER = _REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER; pub type PREFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER = *mut _REFS_SET_VOLUME_COMPRESSION_INFO_INPUT_BUFFER; +pub mod _REFS_QUERY_VOLUME_COMPRESSION_INFO_FLAGS { + pub type Type = ::core::ffi::c_int; + pub const REFS_QUERY_VOLUME_COMPRESSION_INFO_FLAGS_RUNNING: Type = 1; + pub const REFS_QUERY_VOLUME_COMPRESSION_INFO_FLAGS_STOPPED: Type = 2; +} +pub use self::_REFS_QUERY_VOLUME_COMPRESSION_INFO_FLAGS::Type as REFS_QUERY_VOLUME_COMPRESSION_INFO_FLAGS; +pub type PREFS_QUERY_VOLUME_COMPRESSION_INFO_FLAGS = *mut _REFS_QUERY_VOLUME_COMPRESSION_INFO_FLAGS::Type; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER { + pub Version: ULONG, pub DefaultCompressionFormat: REFS_COMPRESSION_FORMATS, pub DefaultCompressionLevel: SHORT, pub DefaultCompressionChunkSizeBytes: ULONG, @@ -182117,7 +184437,11 @@ pub struct _REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER { pub TotalCompressibleClustersAllocated: ULONGLONG, pub TotalCompressibleClustersInUse: ULONGLONG, pub TotalCompressedClusters: ULONGLONG, - pub Reserved: [ULONGLONG; 6usize], + pub Flags: ULONG, + pub CompressionTuning: ULONG, + pub RecompressionTuning: ULONG, + pub DecompressionTuning: ULONG, + pub Reserved: [ULONG; 9usize], } #[test] fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { @@ -182127,7 +184451,7 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { let ptr = UNINIT.as_ptr(); assert_eq!( ::core::mem::size_of::<_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER>(), - 104usize, + 120usize, concat!( "Size of: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182141,12 +184465,22 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), ), ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), + "::", + stringify!(Version), + ), + ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).DefaultCompressionFormat) as usize - ptr as usize }, - 0usize, + 4usize, concat!( "Offset of field: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182158,7 +184492,7 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).DefaultCompressionLevel) as usize - ptr as usize }, - 4usize, + 8usize, concat!( "Offset of field: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182171,7 +184505,7 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { ::core::ptr::addr_of!((*ptr).DefaultCompressionChunkSizeBytes) as usize - ptr as usize }, - 8usize, + 12usize, concat!( "Offset of field: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182183,7 +184517,7 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).VolumeClusterSizeBytes) as usize - ptr as usize }, - 12usize, + 16usize, concat!( "Offset of field: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182195,7 +184529,7 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).TotalVolumeClusters) as usize - ptr as usize }, - 16usize, + 24usize, concat!( "Offset of field: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182207,7 +184541,7 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).TotalAllocatedClusters) as usize - ptr as usize }, - 24usize, + 32usize, concat!( "Offset of field: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182220,7 +184554,7 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { ::core::ptr::addr_of!((*ptr).TotalCompressibleClustersAllocated) as usize - ptr as usize }, - 32usize, + 40usize, concat!( "Offset of field: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182233,7 +184567,7 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { ::core::ptr::addr_of!((*ptr).TotalCompressibleClustersInUse) as usize - ptr as usize }, - 40usize, + 48usize, concat!( "Offset of field: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182245,7 +184579,7 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { unsafe { ::core::ptr::addr_of!((*ptr).TotalCompressedClusters) as usize - ptr as usize }, - 48usize, + 56usize, concat!( "Offset of field: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182253,9 +184587,55 @@ fn bindgen_test_layout__REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER() { stringify!(TotalCompressedClusters), ), ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Flags) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), + "::", + stringify!(Flags), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).CompressionTuning) as usize - ptr as usize + }, + 68usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), + "::", + stringify!(CompressionTuning), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).RecompressionTuning) as usize - ptr as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), + "::", + stringify!(RecompressionTuning), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).DecompressionTuning) as usize - ptr as usize + }, + 76usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), + "::", + stringify!(DecompressionTuning), + ), + ); assert_eq!( unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, - 56usize, + 80usize, concat!( "Offset of field: ", stringify!(_REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER), @@ -182276,6 +184656,712 @@ impl Default for _REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER { pub type REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER = _REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER; pub type PREFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER = *mut _REFS_QUERY_VOLUME_COMPRESSION_INFO_OUTPUT_BUFFER; #[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER { + pub Version: ULONG, + pub GlobalSecondsToTrack: ULONG, + pub MetricsPeriodicitySeconds: ULONG, + pub MetricsGenerationsPerContainer: ULONG, + pub Reserved: [ULONG; 8usize], +} +#[test] +fn bindgen_test_layout__REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER() { + const UNINIT: ::core::mem::MaybeUninit< + _REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER, + > = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER>(), + 48usize, + concat!("Size of: ", stringify!(_REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER)), + ); + assert_eq!( + ::core::mem::align_of::<_REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER>(), + 4usize, + concat!( + "Alignment of ", + stringify!(_REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER), + "::", + stringify!(Version), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).GlobalSecondsToTrack) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER), + "::", + stringify!(GlobalSecondsToTrack), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MetricsPeriodicitySeconds) as usize + - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER), + "::", + stringify!(MetricsPeriodicitySeconds), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MetricsGenerationsPerContainer) as usize + - ptr as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(_REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER), + "::", + stringify!(MetricsGenerationsPerContainer), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER), + "::", + stringify!(Reserved), + ), + ); +} +pub type REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER = _REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER; +pub type PREFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER = *mut _REFS_SET_VOLUME_IO_METRICS_INFO_INPUT_BUFFER; +pub mod _REFS_QUERY_VOLUME_IO_METRICS_INFO_QUERY_TYPE { + pub type Type = ::core::ffi::c_int; + pub const REFS_QUERY_VOLUME_IO_METRICS_INFO_QUERY_TYPE_PARAMETERS: Type = 1; + pub const REFS_QUERY_VOLUME_IO_METRICS_INFO_QUERY_TYPE_METRICS_DATA: Type = 2; +} +pub use self::_REFS_QUERY_VOLUME_IO_METRICS_INFO_QUERY_TYPE::Type as REFS_QUERY_VOLUME_IO_METRICS_INFO_QUERY_TYPE; +pub type PREFS_QUERY_VOLUME_IO_METRICS_INFO_QUERY_TYPE = *mut _REFS_QUERY_VOLUME_IO_METRICS_INFO_QUERY_TYPE::Type; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER { + pub Version: ULONG, + pub QueryType: REFS_QUERY_VOLUME_IO_METRICS_INFO_QUERY_TYPE, + pub Reserved: [ULONG; 6usize], + pub __bindgen_anon_1: _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1 { + pub UnusedAlign: ULONGLONG, + pub Parameters: _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_1, + pub MetricsData: _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 { + pub Reserved: [ULONG; 6usize], +} +#[test] +fn bindgen_test_layout__REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_1() { + const UNINIT: ::core::mem::MaybeUninit< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_1, + > = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_1, + >(), + 24usize, + concat!( + "Size of: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 + ), + ), + ); + assert_eq!( + ::core::mem::align_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_1, + >(), + 4usize, + concat!( + "Alignment of ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 + ), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 + ), + "::", + stringify!(Reserved), + ), + ); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 { + pub ResumeKeyBlob: [ULONGLONG; 2usize], + pub Reserved: [ULONG; 6usize], +} +#[test] +fn bindgen_test_layout__REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_2() { + const UNINIT: ::core::mem::MaybeUninit< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_2, + > = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_2, + >(), + 40usize, + concat!( + "Size of: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 + ), + ), + ); + assert_eq!( + ::core::mem::align_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_2, + >(), + 8usize, + concat!( + "Alignment of ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 + ), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ResumeKeyBlob) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 + ), + "::", + stringify!(ResumeKeyBlob), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 + ), + "::", + stringify!(Reserved), + ), + ); +} +#[test] +fn bindgen_test_layout__REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1() { + const UNINIT: ::core::mem::MaybeUninit< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1, + > = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1, + >(), + 40usize, + concat!( + "Size of: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1), + ), + ); + assert_eq!( + ::core::mem::align_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1, + >(), + 8usize, + concat!( + "Alignment of ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).UnusedAlign) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1), + "::", + stringify!(UnusedAlign), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Parameters) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1), + "::", + stringify!(Parameters), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).MetricsData) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1), + "::", + stringify!(MetricsData), + ), + ); +} +impl Default for _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[test] +fn bindgen_test_layout__REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER() { + const UNINIT: ::core::mem::MaybeUninit< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER, + > = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER>(), + 72usize, + concat!("Size of: ", stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER)), + ); + assert_eq!( + ::core::mem::align_of::<_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER), + "::", + stringify!(Version), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).QueryType) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER), + "::", + stringify!(QueryType), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER), + "::", + stringify!(Reserved), + ), + ); +} +impl Default for _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER = _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER; +pub type PREFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER = *mut _REFS_QUERY_VOLUME_IO_METRICS_INFO_INPUT_BUFFER; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA { + pub PlaceHolder: ULONGLONG, +} +#[test] +fn bindgen_test_layout__REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA() { + const UNINIT: ::core::mem::MaybeUninit<_REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA>(), + 8usize, + concat!("Size of: ", stringify!(_REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA)), + ); + assert_eq!( + ::core::mem::align_of::<_REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA>(), + 8usize, + concat!("Alignment of ", stringify!(_REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).PlaceHolder) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA), + "::", + stringify!(PlaceHolder), + ), + ); +} +pub type REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA = _REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA; +pub type PREFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA = *mut _REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER { + pub Version: ULONG, + pub QueryType: REFS_QUERY_VOLUME_IO_METRICS_INFO_QUERY_TYPE, + pub Reserved: [ULONG; 6usize], + pub __bindgen_anon_1: _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1 { + pub UnusedAlign: ULONGLONG, + pub Parameters: _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1, + pub MetricsData: _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 { + pub GlobalSecondsToTrack: ULONG, + pub MetricsPeriodicitySeconds: ULONG, + pub MetricsGenerationsPerContainer: ULONG, + pub Reserved: [ULONG; 6usize], +} +#[test] +fn bindgen_test_layout__REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1() { + const UNINIT: ::core::mem::MaybeUninit< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1, + > = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1, + >(), + 36usize, + concat!( + "Size of: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 + ), + ), + ); + assert_eq!( + ::core::mem::align_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1, + >(), + 4usize, + concat!( + "Alignment of ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 + ), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).GlobalSecondsToTrack) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 + ), + "::", + stringify!(GlobalSecondsToTrack), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MetricsPeriodicitySeconds) as usize + - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 + ), + "::", + stringify!(MetricsPeriodicitySeconds), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).MetricsGenerationsPerContainer) as usize + - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 + ), + "::", + stringify!(MetricsGenerationsPerContainer), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_1 + ), + "::", + stringify!(Reserved), + ), + ); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 { + pub EntryCount: ULONG, + pub ResumeKeyBlob: [ULONGLONG; 2usize], + pub Reserved: [ULONG; 6usize], + pub Metrics: [REFS_QUERY_VOLUME_IO_METRICS_METRICS_DATA; 1usize], +} +#[test] +fn bindgen_test_layout__REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2() { + const UNINIT: ::core::mem::MaybeUninit< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2, + > = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2, + >(), + 56usize, + concat!( + "Size of: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 + ), + ), + ); + assert_eq!( + ::core::mem::align_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2, + >(), + 8usize, + concat!( + "Alignment of ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 + ), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).EntryCount) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 + ), + "::", + stringify!(EntryCount), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ResumeKeyBlob) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 + ), + "::", + stringify!(ResumeKeyBlob), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 + ), + "::", + stringify!(Reserved), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Metrics) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!( + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1__bindgen_ty_2 + ), + "::", + stringify!(Metrics), + ), + ); +} +#[test] +fn bindgen_test_layout__REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1() { + const UNINIT: ::core::mem::MaybeUninit< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1, + > = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1, + >(), + 56usize, + concat!( + "Size of: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1), + ), + ); + assert_eq!( + ::core::mem::align_of::< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1, + >(), + 8usize, + concat!( + "Alignment of ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).UnusedAlign) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1), + "::", + stringify!(UnusedAlign), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Parameters) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1), + "::", + stringify!(Parameters), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).MetricsData) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1), + "::", + stringify!(MetricsData), + ), + ); +} +impl Default for _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[test] +fn bindgen_test_layout__REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER() { + const UNINIT: ::core::mem::MaybeUninit< + _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER, + > = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER>(), + 88usize, + concat!( + "Size of: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER), + ), + ); + assert_eq!( + ::core::mem::align_of::<_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER>(), + 8usize, + concat!( + "Alignment of ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Version) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER), + "::", + stringify!(Version), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).QueryType) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER), + "::", + stringify!(QueryType), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).Reserved) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER), + "::", + stringify!(Reserved), + ), + ); +} +impl Default for _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER { + fn default() -> Self { + let mut s = ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER = _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER; +pub type PREFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER = *mut _REFS_QUERY_VOLUME_IO_METRICS_INFO_OUTPUT_BUFFER; +#[repr(C)] #[derive(Debug, Copy, Clone)] pub struct _FILE_STORAGE_RESERVE_ID_INFORMATION { pub StorageReserveId: STORAGE_RESERVE_ID, @@ -190902,6 +193988,209 @@ fn bindgen_test_layout__SEC_CHANNEL_BINDINGS() { } pub type SEC_CHANNEL_BINDINGS = _SEC_CHANNEL_BINDINGS; pub type PSEC_CHANNEL_BINDINGS = *mut _SEC_CHANNEL_BINDINGS; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SEC_CHANNEL_BINDINGS_EX { + pub magicNumber: ::core::ffi::c_ulong, + pub flags: ::core::ffi::c_ulong, + pub cbHeaderLength: ::core::ffi::c_ulong, + pub cbStructureLength: ::core::ffi::c_ulong, + pub dwInitiatorAddrType: ::core::ffi::c_ulong, + pub cbInitiatorLength: ::core::ffi::c_ulong, + pub dwInitiatorOffset: ::core::ffi::c_ulong, + pub dwAcceptorAddrType: ::core::ffi::c_ulong, + pub cbAcceptorLength: ::core::ffi::c_ulong, + pub dwAcceptorOffset: ::core::ffi::c_ulong, + pub cbApplicationDataLength: ::core::ffi::c_ulong, + pub dwApplicationDataOffset: ::core::ffi::c_ulong, +} +#[test] +fn bindgen_test_layout__SEC_CHANNEL_BINDINGS_EX() { + const UNINIT: ::core::mem::MaybeUninit<_SEC_CHANNEL_BINDINGS_EX> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_SEC_CHANNEL_BINDINGS_EX>(), + 48usize, + concat!("Size of: ", stringify!(_SEC_CHANNEL_BINDINGS_EX)), + ); + assert_eq!( + ::core::mem::align_of::<_SEC_CHANNEL_BINDINGS_EX>(), + 4usize, + concat!("Alignment of ", stringify!(_SEC_CHANNEL_BINDINGS_EX)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).magicNumber) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(magicNumber), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(flags), + ), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).cbHeaderLength) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(cbHeaderLength), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).cbStructureLength) as usize - ptr as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(cbStructureLength), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).dwInitiatorAddrType) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(dwInitiatorAddrType), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).cbInitiatorLength) as usize - ptr as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(cbInitiatorLength), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).dwInitiatorOffset) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(dwInitiatorOffset), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).dwAcceptorAddrType) as usize - ptr as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(dwAcceptorAddrType), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).cbAcceptorLength) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(cbAcceptorLength), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).dwAcceptorOffset) as usize - ptr as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(dwAcceptorOffset), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).cbApplicationDataLength) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(cbApplicationDataLength), + ), + ); + assert_eq!( + unsafe { + ::core::ptr::addr_of!((*ptr).dwApplicationDataOffset) as usize - ptr as usize + }, + 44usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_EX), + "::", + stringify!(dwApplicationDataOffset), + ), + ); +} +pub type SEC_CHANNEL_BINDINGS_EX = _SEC_CHANNEL_BINDINGS_EX; +pub type PSEC_CHANNEL_BINDINGS_EX = *mut _SEC_CHANNEL_BINDINGS_EX; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _SEC_CHANNEL_BINDINGS_RESULT { + pub flags: ::core::ffi::c_ulong, +} +#[test] +fn bindgen_test_layout__SEC_CHANNEL_BINDINGS_RESULT() { + const UNINIT: ::core::mem::MaybeUninit<_SEC_CHANNEL_BINDINGS_RESULT> = ::core::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_SEC_CHANNEL_BINDINGS_RESULT>(), + 4usize, + concat!("Size of: ", stringify!(_SEC_CHANNEL_BINDINGS_RESULT)), + ); + assert_eq!( + ::core::mem::align_of::<_SEC_CHANNEL_BINDINGS_RESULT>(), + 4usize, + concat!("Alignment of ", stringify!(_SEC_CHANNEL_BINDINGS_RESULT)), + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_SEC_CHANNEL_BINDINGS_RESULT), + "::", + stringify!(flags), + ), + ); +} +pub type SEC_CHANNEL_BINDINGS_RESULT = _SEC_CHANNEL_BINDINGS_RESULT; +pub type PSEC_CHANNEL_BINDINGS_RESULT = *mut _SEC_CHANNEL_BINDINGS_RESULT; pub mod _SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT { pub type Type = ::core::ffi::c_int; pub const SecApplicationProtocolNegotiationExt_None: Type = 0; diff --git a/crates/wdk-sys/src/types.rs b/crates/wdk-sys/src/types.rs index fa150237..ea96403e 100644 --- a/crates/wdk-sys/src/types.rs +++ b/crates/wdk-sys/src/types.rs @@ -10,8 +10,20 @@ #[allow(clippy::cast_possible_truncation)] #[allow(clippy::cognitive_complexity)] #[allow(clippy::default_trait_access)] -#[rustversion::attr(before(2023-09-10), allow(clippy::incorrect_clone_impl_on_copy_type))] -#[rustversion::attr(since(2023-09-10), allow(clippy::non_canonical_clone_impl))] +#[rustversion::attr( + any( + all(not(nightly), before(1.74)), + all(nightly, before(2023-09-13)), + ), + allow(clippy::incorrect_clone_impl_on_copy_type) +)] +#[rustversion::attr( + any( + all(not(nightly), since(1.74)), + all(nightly, since(2023-09-13)), + ), + allow(clippy::non_canonical_clone_impl) +)] #[allow(clippy::missing_safety_doc)] #[allow(clippy::missing_const_for_fn)] #[allow(clippy::module_name_repetitions)]