From d39da4bc06efccee3c67dc519890bd60e44b1e06 Mon Sep 17 00:00:00 2001 From: enricobuehler Date: Mon, 22 Jun 2026 21:54:50 +0200 Subject: [PATCH] =?UTF-8?q?feat(windows):=20pf-vdisplay=20=E2=80=94=20all-?= =?UTF-8?q?Rust=20IddCx=20virtual=20display=20(replaces=20SudoVDA)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit P1 done: a pure-Rust UMDF2 IddCx driver, drop-in compatible with the host's existing vdisplay/sudovda.rs control plane (the {e5bcc234} interface + the SudoVDA IOCTL ABI), so the host drives it unchanged. Validated streaming on glass at 5120x1440@240 — steady 240 fps, ~2.4 ms encode, clean teardown, full parity with SudoVDA. - Vendored wdf-umdf-sys / wdf-umdf bindgen crates (MIT, from virtual-display-rs) + the SDK-version build.rs fix that resolves the IddCxStub lib path by the WDK version actually containing um\x64\iddcx, not the max base SDK. - pf-vdisplay crate: entry/callbacks/context/control/monitor/edid/ swap_chain_processor. Our OWN 128-byte EDID (manufacturer PNK, product punktfunk — no SudoVDA bytes), a real swap-chain drain (faithful vdd port, required so DWM keeps compositing), the SudoVDA-compatible IOCTL control plane (ADD/REMOVE/PING/GET_WATCHDOG/GET_VERSION/SET_RENDER_ADAPTER) + a watchdog that tears down orphaned monitors when the host stops pinging. - deploy-dev.ps1: stage + sign + stampinf (date.time DriverVer) + Inf2Cat + install, codifying the "bump DriverVer or pnputil keeps the old binary" gotcha. - docs/windows-virtual-display-rust-port.md: investigation, the on-glass validation, and the two traps that cost time (Session-0 measurement + accumulated device-state needing a reboot). Co-Authored-By: Claude Opus 4.8 --- docs/windows-virtual-display-rust-port.md | 278 ++ .../vdisplay-driver/.cargo/config.toml | 2 + packaging/windows/vdisplay-driver/.gitignore | 3 + packaging/windows/vdisplay-driver/Cargo.lock | 510 +++ packaging/windows/vdisplay-driver/Cargo.toml | 26 + .../LICENSE.virtual-display-rs | 21 + packaging/windows/vdisplay-driver/README.md | 61 + .../windows/vdisplay-driver/deploy-dev.ps1 | 77 + .../pf-vdisplay/.cargo/config.toml | 11 + .../vdisplay-driver/pf-vdisplay/Cargo.toml | 29 + .../vdisplay-driver/pf-vdisplay/build.rs | 5 + .../pf-vdisplay/pf_vdisplay.inx | 77 + .../pf-vdisplay/src/callbacks.rs | 322 ++ .../pf-vdisplay/src/context.rs | 328 ++ .../pf-vdisplay/src/control.rs | 339 ++ .../pf-vdisplay/src/direct_3d_device.rs | 77 + .../vdisplay-driver/pf-vdisplay/src/edid.rs | 114 + .../vdisplay-driver/pf-vdisplay/src/entry.rs | 119 + .../pf-vdisplay/src/helpers.rs | 38 + .../vdisplay-driver/pf-vdisplay/src/lib.rs | 33 + .../vdisplay-driver/pf-vdisplay/src/logger.rs | 34 + .../pf-vdisplay/src/monitor.rs | 103 + .../vdisplay-driver/pf-vdisplay/src/panic.rs | 20 + .../pf-vdisplay/src/swap_chain_processor.rs | 158 + .../vdisplay-driver/rust-toolchain.toml | 4 + .../vdisplay-driver/wdf-umdf-sys/Cargo.toml | 17 + .../vdisplay-driver/wdf-umdf-sys/build.rs | 275 ++ .../vdisplay-driver/wdf-umdf-sys/c/wrapper.h | 22 + .../wdf-umdf-sys/src/bindings.rs | 17 + .../vdisplay-driver/wdf-umdf-sys/src/lib.rs | 211 ++ .../wdf-umdf-sys/src/ntstatus.rs | 2789 +++++++++++++++++ .../vdisplay-driver/wdf-umdf/Cargo.toml | 12 + .../vdisplay-driver/wdf-umdf/src/iddcx.rs | 319 ++ .../vdisplay-driver/wdf-umdf/src/lib.rs | 30 + .../vdisplay-driver/wdf-umdf/src/wdf.rs | 667 ++++ 35 files changed, 7148 insertions(+) create mode 100644 docs/windows-virtual-display-rust-port.md create mode 100644 packaging/windows/vdisplay-driver/.cargo/config.toml create mode 100644 packaging/windows/vdisplay-driver/.gitignore create mode 100644 packaging/windows/vdisplay-driver/Cargo.lock create mode 100644 packaging/windows/vdisplay-driver/Cargo.toml create mode 100644 packaging/windows/vdisplay-driver/LICENSE.virtual-display-rs create mode 100644 packaging/windows/vdisplay-driver/README.md create mode 100644 packaging/windows/vdisplay-driver/deploy-dev.ps1 create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/.cargo/config.toml create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/Cargo.toml create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/build.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/pf_vdisplay.inx create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/callbacks.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/context.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/control.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/direct_3d_device.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/edid.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/entry.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/helpers.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/lib.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/logger.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/monitor.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/panic.rs create mode 100644 packaging/windows/vdisplay-driver/pf-vdisplay/src/swap_chain_processor.rs create mode 100644 packaging/windows/vdisplay-driver/rust-toolchain.toml create mode 100644 packaging/windows/vdisplay-driver/wdf-umdf-sys/Cargo.toml create mode 100644 packaging/windows/vdisplay-driver/wdf-umdf-sys/build.rs create mode 100644 packaging/windows/vdisplay-driver/wdf-umdf-sys/c/wrapper.h create mode 100644 packaging/windows/vdisplay-driver/wdf-umdf-sys/src/bindings.rs create mode 100644 packaging/windows/vdisplay-driver/wdf-umdf-sys/src/lib.rs create mode 100644 packaging/windows/vdisplay-driver/wdf-umdf-sys/src/ntstatus.rs create mode 100644 packaging/windows/vdisplay-driver/wdf-umdf/Cargo.toml create mode 100644 packaging/windows/vdisplay-driver/wdf-umdf/src/iddcx.rs create mode 100644 packaging/windows/vdisplay-driver/wdf-umdf/src/lib.rs create mode 100644 packaging/windows/vdisplay-driver/wdf-umdf/src/wdf.rs diff --git a/docs/windows-virtual-display-rust-port.md b/docs/windows-virtual-display-rust-port.md new file mode 100644 index 0000000..0797525 --- /dev/null +++ b/docs/windows-virtual-display-rust-port.md @@ -0,0 +1,278 @@ +# Windows virtual display — a Rust port of SudoVDA (investigation & plan) + +Status: **P1 done — `pf-vdisplay` validated streaming on glass at 5120×1440@240** (2026-06-22). The +all-Rust IddCx driver replaces the vendored **SudoVDA** C++ driver, matching the "all-Rust UMDF, zero +external driver deps" direction we finished for gamepads (ViGEmBus gone; DualSense/DS4/XUSB shipped). +The investigation/plan below is kept for context; see **Validated on-box** for the result. + +## TL;DR + +A Rust port is **feasible, low-on-blockers, and strategically aligned** — and there's an unexpected +architectural prize beyond "same thing, in Rust." + +- **Signing is not a blocker.** An IddCx driver is UMDF *user-mode*; it needs **no WHQL, no + attestation, no test-signing**. A self-signed cert in LocalMachine `Root` + `TrustedPublisher` + loads it — **exactly the model our gamepad drivers already ship** (and exactly what SudoVDA and the + other forks do). ([Do UMDF drivers require signing?](https://learn.microsoft.com/en-us/archive/blogs/peterwie/do-umdf-drivers-require-signing)) +- **We would not be first in Rust.** [`MolotovCherry/virtual-display-rs`](https://github.com/MolotovCherry/virtual-display-rs) + is a complete, shipping **IddCx driver written in Rust** (MIT), with hand-rolled IddCx/WDF bindgen + bindings (`wdf-umdf-sys` + `wdf-umdf`) and a reference swap-chain processor. This turns "greenfield + FFI" into "adapt a proven reference." +- **The prize: we can stop using DXGI Desktop Duplication.** An IddCx driver already *receives* the + composited desktop frames in its swap-chain. [Looking Glass](https://deepwiki.com/gnif/LookingGlass/2.5-indirect-display-driver-(idd)) + ships exactly this in production — driver consumes the swap-chain, hands frames to a separate + process, "operates entirely independently of DDA." Doing the same would **delete an entire class of + multi-GPU bugs** the current `capture/dxgi.rs` is built to survive (ACCESS_LOST storms, + MODE_CHANGE_IN_PROGRESS, the `win32u.dll` reparenting patch). + +Recommendation: **yes, build it in Rust**, in phases — a drop-in DDA-compatible driver first (own the +stack at low risk), then the direct-frame-push path (the real cleanup). Keep vendoring SudoVDA as the +safe interim until the Rust driver is on-glass-validated on the RTX box. + +## Validated on-box (2026-06-22) + +Before committing, the toolchain + load path were proven on the RTX box (Win11 26200, WDK 26100): + +- **A Rust IddCx driver builds with our toolchain.** Cloned [`virtual-display-rs`](https://github.com/MolotovCherry/virtual-display-rs) + and built its driver `.dll` against our WDK (UMDF 2.31 + IddCx 1.4 stubs, bindgen over `IddCx.h` via + our LLVM, nightly-2024-07-26). One fix needed: its `build.rs` picked the **max** SDK Lib version + (`10.0.28000.0`, a base SDK with no IddCx) for the `IddCxStub` search path; resolving it by the + version that actually contains `um\x64\iddcx\1.4` (`10.0.26100.0`, the WDK) fixed the link. +- **It installs self-signed and loads.** Signed `.dll`/`.cat` with our existing driver cert (the + gamepad `punktfunk-ds-test`), `pnputil /add-driver`, root devnode via `devgen`. The device came up + **Status OK / CM_PROB_NONE**, Class Display, hosted by `WUDFRd` — a Rust IddCx adapter initialized + cleanly. (SudoVDA, already live here, independently confirms IddCx + self-signed UMDF work on this + box.) Test artifacts removed afterward; SudoVDA untouched. + +**Conclusion:** the central risk ("can we build + load a Rust IddCx driver here?") is retired. The +binding question (D2) resolves toward **reusing `virtual-display-rs`'s self-contained `wdf-umdf-sys` + +`wdf-umdf` bindgen crates** (now proven to build + load on our box) rather than extending +`windows-drivers-rs` — IddCx functions are direct `IddCxStub` exports the WDF function-table macro +can't reach anyway, so a unified bindgen is the cleaner base for `pf-vdisplay`. Reference clone kept at +`C:\Users\Public\virtual-display-rs`. + +**Scaffold + driver logic landed + on-glass:** `packaging/windows/vdisplay-driver/` — vendored +`wdf-umdf-sys`/`wdf-umdf` (MIT, + the SDK-version build.rs fix) + the `pf-vdisplay` driver crate. The +full IddCx driver is ported (entry → `IDD_CX_CLIENT_CONFIG` with all 7 callbacks → device/monitor +context → our own EDID → a real swap-chain drain), with the IPC/serde/`tokio` stack replaced by an +in-tree `monitor` model and `OutputDebugString` logging. **Validated on the RTX box:** built, signed +(our `punktfunk-ds-test` cert), installed, loaded **Status OK**, and **arrived a real virtual monitor** +("VirtuDisplay+", `DISPLAY\CHY0000`) — i.e. an OURS, all-Rust IddCx virtual display creating a monitor. + +**IOCTL control plane done + on-glass (P1 functionally complete):** the SudoVDA-compatible control +plane is implemented (`EVT_IDD_CX_DEVICE_IO_CONTROL` + the `{e5bcc234-…}` interface registered via +`WdfDeviceCreateDeviceInterface`; `control.rs` with byte-identical structs) — `ADD` a monitor at a +requested mode → `{LUID, target_id}` (target id + adapter LUID captured from `IDARG_OUT_MONITORARRIVAL`), +`REMOVE` by GUID, `PING`/`GET_WATCHDOG` watchdog, `GET_VERSION`, `SET_RENDER_ADAPTER` +(`IddCxAdapterSetRenderAdapter`); per-`ADD` mode injection (requested mode preferred + fallbacks). Added +the five missing FFI wrappers to the vendored `wdf-umdf`. **Validated on the RTX box** with a probe +that mimics `vdisplay/sudovda.rs` exactly: `GET_VERSION → 0.2.1`, `GET_WATCHDOG → timeout=3`, +`ADD 1920×1080@60 → target_id=257 + adapter LUID`, a real "VirtuDisplay+" monitor arrived at the +requested mode, `REMOVE` ok. **Constraint:** pf-vdisplay can't coexist with SudoVDA — they register the +same interface GUID, so two IddCx adapters claiming it → `FAILED_POST_START`; pf-vdisplay *replaces* +SudoVDA (validated by disabling SudoVDA first). + +**Watchdog + real-host drive validated:** added the watchdog thread (1 Hz countdown reset by any IOCTL; +tears down all monitors at 0 so a gone host never leaves a phantom display; mirrors SudoVDA's +`RunWatchdog`). Pointed the **real host** at it — removed SudoVDA's devnode so pf-vdisplay is the sole +`{e5bcc234}` provider, then ran the host's `vdisplay::sudovda::tests::live_create_drop` +(`PUNKTFUNK_SUDOVDA_LIVE=1`): **test passed**, and the pf-vdisplay log shows the host's IOCTLs landing — +`ADD 1920x1080@60 → target_id=258, luid=…02619823`, then the watchdog correctly tore the monitor down +when the test process exited without a final REMOVE. So `vdisplay/sudovda.rs` drives pf-vdisplay +unchanged through the full control contract. + +**Validated streaming end-to-end on glass (2026-06-22) — P1 complete.** pf-vdisplay is a working +SudoVDA replacement. Driven by the **real host** (`serve`, the LocalSystem service) with a stock client +at **5120×1440@240**: the monitor arrives, `resolve_gdi_name → \\.\DISPLAY10`, `set_active_mode` + +CCD-isolate succeed, the DXGI output resolves **under the RTX 4090**, WGC capture + NVENC run at +**steady 240 fps, ~2.4 ms encode**, 6512 AUs sent, clean teardown (`isolate restored rc=0x0`). Same +`vdisplay/sudovda.rs` path, unchanged — full parity with SudoVDA. + +**The earlier "monitor arrives but never gets a swap-chain / no DXGI output" symptoms were a +measurement + state artifact, not a driver bug.** Two traps cost a lot of time: +1. **Session 0.** Every standalone probe (`vdtest`, the host's `live_create_drop` test) ran in + **Session 0** — the services session, whose desktop is a throwaway **1024×768** basic display. IddCx + activation happens in the **console Session 1**, where the 4090 drives the real desktop. So + `Screen.AllScreens`/CCD queries from Session 0 *can never* see the virtual monitor activate — they + report the wrong desktop. The only valid way to drive + observe it is the **host service** (SYSTEM, + which targets Session 1) plus the driver's own `OutputDebugString` (system-wide, session-agnostic). +2. **Accumulated device-state damage.** Repeated reinstalls + `Disable`/`Enable-PnpDevice` cycles + + a control handle the host **cached across all of it** left the device tree wedged (stale handle → + the host's PINGs fail → the 3 s watchdog tears the monitor down mid-session → capture opens a dying + display → "no DXGI output"). **A reboot cleared it and it worked on the first connect.** Lesson: + after device churn, restart the host service (fresh handle) — and when in doubt, reboot. + +The swap-chain processor is a **faithful port of virtual-display-rs's** (it drains correctly via +`ReleaseAndAcquireBuffer` + `FinishedProcessingFrame` — the drain is *required*; a true no-op would +stall DWM and freeze the captured image). The EDID is our **own clean 128-byte block** (manufacturer +`PNK`, product `punktfunk`) — no SudoVDA bytes. + +**Build gotcha (important for iterating):** updating an installed UMDF driver only takes if the INF +**DriverVer changes** — `deploy-dev.ps1` stamps a date.time `-v` on every run; without a bump the old +binary keeps running (silently). **Devnode hygiene:** create the root devnode with +`nefconc --create-device-node` (a clean `ROOT\DISPLAY` node), NOT `devgen /add` — devgen makes +**persistent `SWD\DEVGEN` software devices** that survive reboot *and* registry deletion and resurrect +on every `pnputil /add-driver` (they have `hwid root\pf_vdisplay`, so the driver install re-materializes +them). The production installer must use a single `nefconc`/INF-created node and never `devgen`. + +## Why we'd do this + +The user's goals, mapped to outcomes: + +| Goal | Outcome | +| --- | --- | +| Drop external deps | No more vendored prebuilt SudoVDA `.dll`/`.cat` (third-party, C++, single upstream). | +| Increase Rust coverage | The display driver joins the gamepad drivers as in-tree Rust UMDF. | +| Own the stack / easier display management | We control the IOCTL protocol, the EDID, the mode list, the watchdog — and can fold the topology/mode logic that's currently scattered in `vdisplay/sudovda.rs` into the driver. | +| Cleaner code | Phase 2 retires `capture/dxgi.rs`'s DDA workarounds + the `win32u.dll` patch. | + +## What we'd be replacing (current architecture) + +- **Driver:** SudoVDA — UMDF2 IddCx, `Class=Display`, `UmdfExtensions=IddCx0102`, + `UpperFilters=IndirectKmd`, root-enumerated `Root\SudoMaker\SudoVDA`. Vendored prebuilt under + `packaging/windows/sudovda/`, installed by `install-sudovda.ps1` (cert → `nefconc` devnode → + `pnputil`). Source is public ([SudoMaker/SudoVDA](https://github.com/SudoMaker/SudoVDA), README-only + MIT/CC0 grant over the MS sample, ~1,900 LOC C++). +- **Host contract:** `crates/punktfunk-host/src/vdisplay/sudovda.rs` opens the control device by + interface GUID `{e5bcc234-…}` and drives a tiny `METHOD_BUFFERED` IOCTL protocol — byte-identical to + SudoVDA's `Common/Include/sudovda-ioctl.h`: + - `ADD (0x800)` `{w,h,refresh,GUID,name[14],serial[14]}` → `{LUID, target_id}` + - `REMOVE (0x801)` `{GUID}` · `SET_RENDER_ADAPTER (0x802)` `{LUID}` · `GET_WATCHDOG (0x803)` · + `PING (0x888)` (mandatory keepalive) · `GET_VERSION (0x8FF)` +- **Capture:** `capture/dxgi.rs` finds the virtual monitor's GDI output **across all adapters** (it's + enumerated under the *rendering* GPU, not SudoVDA's LUID) and runs **DXGI Desktop Duplication** + (`DuplicateOutput1`, FP16 for HDR). This file is **dominated by virtual-display-over-DDA survival + code**: `DXGI_ERROR_ACCESS_LOST` re-duplication with retries, `MODE_CHANGE_IN_PROGRESS` backoff, + legacy-`DuplicateOutput` fallback, CCD display isolation to make the IDD the sole composited + desktop, and an **`install_gpu_pref_hook()` that patches `win32u.dll!NtGdiDdDDIGetCachedHybridQueryValue`** + to stop DXGI reparenting the output across GPUs. Most of that exists *because* we capture a virtual + display via DDA on a multi-GPU box. + +## Feasibility findings + +### Signing — green (the make-or-break) +UMDF user-mode ⇒ Code-Integrity signing rules don't apply to our binary (the only kernel piece is +Microsoft's inbox `IndirectKmd`). Self-signed cert in `Root` + `TrustedPublisher` is sufficient on a +normal Secure-Boot Win11 box — no `bcdedit /set testsigning`. SudoVDA and `virtual-display-rs` both +ship this way. This is the **same** model as our DualSense/DS4/XUSB drivers. (The only thing that +breaks install is a botched cert placement, not a signing *tier*.) + +### Rust prior art — exists, MIT, reusable +`virtual-display-rs` proves an all-Rust IddCx driver runs in production and gives us: +`wdf-umdf-sys` (bindgen over WDF **and** `iddcx.h`, links `IddCxStub`), `wdf-umdf` (safe wrappers — +`iddcx.rs` ~300 LOC, with an `IddCxIsFunctionAvailable!` version-gate macro), and a reference driver +(`swap_chain_processor.rs` ~158 LOC, `direct_3d_device.rs`, `edid.rs`). **Caveat:** it uses its *own* +bindgen stack, **not** `microsoft/windows-drivers-rs` — see Decision D2. + +### windows-drivers-rs IddCx support — absent, but a bounded extension +Our `wdk-sys` (m0) binds Base + WDF + feature-gated subsets (hid/gpio/spb/…). **Zero IddCx symbols.** +Adding it is the same shape as the existing subsets: an `ApiSubset::Iddcx` variant + `iddcx` feature → +`iddcx_headers()` returning `iddcx.h` for bindgen, and linking `IddCx.lib`. IddCx functions are **not** +WDF-table functions, so the `call_unsafe_wdf_function_binding!` macro doesn't apply — they're direct +`IddCx.lib` exports we'd `#[link(name="IddCx")] extern` (or bindgen) and wrap ourselves. +`windows` 0.58 (already in the tree) provides the Direct3D11/Dxgi APIs the swap-chain loop needs. + +### The IddCx driver itself — well-understood, ~1–2k LOC +Required callbacks (baselined on the MS [IddSampleDriver](https://github.com/microsoft/Windows-driver-samples/blob/main/video/IndirectDisplay/IddSampleDriver/Driver.cpp), ~1,100 LOC, IddCx 1.4): +`EVT_IDD_CX_ADAPTER_INIT_FINISHED`, `ADAPTER_COMMIT_MODES`, `PARSE_MONITOR_DESCRIPTION`, +`MONITOR_GET_DEFAULT_DESCRIPTION_MODES`, `MONITOR_QUERY_TARGET_MODES`, `MONITOR_ASSIGN_SWAPCHAIN` +(the only callback with real D3D work), `MONITOR_UNASSIGN_SWAPCHAIN`, and `DEVICE_IO_CONTROL` (where +our ADD/REMOVE/PING IOCTLs live). Init flow: `WdfDeviceCreate → IddCxDeviceInitConfig → +IddCxDeviceInitialize → IddCxAdapterInitAsync → IddCxMonitorCreate → IddCxMonitorArrival`. + +**Arbitrary resolutions don't need EDID timings:** ship one generic ~128/256-byte EDID base block to +make Windows treat the target as a real monitor, then advertise modes programmatically from the +mode-list callbacks — a static table **plus the runtime-requested client mode injected as preferred** +(exactly SudoVDA's `s_DefaultModes[]` + per-ADD preferred-mode approach). 5120×1440@240 just gets +added at ADD time. + +**HDR/10-bit:** supported, but it's the one place IddCx is *harder* than today. The default swap-chain +surface is **8-bit `A8R8G8B8`**; FP16/HDR requires the IddCx **1.11 D3D12 acquire path** +(`SetDevice2`/`ReleaseAndAcquireBuffer2` → `ID3D12Resource`, with a stricter sync model). Our box is +Win11 26200 (IddCx ≥ 1.10), so this is reachable, but it's real work — and our current WGC/DDA path +gives FP16 HDR "for free." Build against 1.10 and runtime-gate the newer DDIs (SudoVDA's pattern). + +## The architectural prize: skip DDA (Phase 2) + +An IddCx driver gets each presented frame from `IddCxSwapChainReleaseAndAcquireBuffer` as an +`IDXGIResource` on a device **we** bind via `IddCxSwapChainSetDevice`. We can copy it into a shared +texture / shared section and hand it to the host's encoder process directly — **no Desktop +Duplication**. Why this is the real win, not just a detour: + +- **It's the *intended* IddCx use case.** IddCx exists for remote/wireless/USB displays that ship + swap-chain frames over a wire; consuming frames in the driver is the designed path, and **Looking + Glass already does exactly this** (driver → shared memory → separate consumer, no DDA). +- **It kills the multi-GPU bug class.** We call `IddCxAdapterSetRenderAdapter` to pin the swap-chain to + the **same GPU as our NVENC encoder before adding the monitor**, and the OS honors it. No more DXGI + reparenting the output onto the wrong GPU, no ACCESS_LOST storms, and we can **retire + `install_gpu_pref_hook()` (the `win32u.dll` patch)** and most of `capture/dxgi.rs`. Swap-chain + re-creation becomes a documented, in-band event (`ABANDON_SWAPCHAIN`) instead of an undocumented + failure we fight with retries. + +What it does **not** remove (be honest): display **topology** management — making the virtual display +the sole/primary composited desktop so the game (and Winlogon) render to it — is independent of how we +*get* frames and stays (though we can integrate it more cleanly). And the watchdog stays, now ours. + +The cost: a **Session-0 → service cross-process frame transport** (the driver host is `WUDFHost` in +Session 0 / LocalService; our host is a LocalSystem service). A `Global\`-named, explicitly-ACL'd +shared section + keyed-mutex texture (Looking Glass's shape) is where the engineering actually goes — +prototype this first, it's the only genuinely new risk. Plus the HDR D3D12 path above. + +## Decisions to make at kickoff + +- **D1 — Own the driver?** Recommend **yes, in Rust.** (Alternatives: fork SudoVDA's C++ — fastest to a + known-good HDR driver but reintroduces a C++ toolchain and README-only license provenance; or keep + vendoring — zero cost, but none of the goals.) +- **D2 — Binding stack?** The main implementation fork. + - **(a)** Extend our `windows-drivers-rs` (m0) with an `iddcx` subset — **one toolchain across all + our drivers**, our build env, but we write the IddCx bindings ourselves (+~3–5 wk), using + `virtual-display-rs`'s `iddcx.rs` as the 1:1 guide. *Preferred for consistency.* + - **(b)** Vendor `virtual-display-rs`'s `wdf-umdf*` crates (MIT) — fastest to first light, but a + *second* WDK-binding stack in-tree. + - Suggested sequence: **prototype on (b) to prove IddCx-on-our-box in days**, then build production on + **(a)** for consistency. +- **D3 — Frame transport?** Phase it: **DDA-compatible first** (zero capture-side change), **direct + push second** (the cleanup). Don't couple the driver rewrite to the transport rewrite. + +## Recommended plan + +- **P0 — now:** keep vendoring SudoVDA. No change. (The gamepad-driver installer work just shipped; + this is independent.) +- **P1 — drop-in Rust IddCx driver (`pf-vdisplay`).** Replicate SudoVDA's IOCTL contract **exactly** + (same struct layouts; reuse or re-issue the control interface GUID) so `vdisplay/sudovda.rs` needs + **~zero change** (at most a GUID constant). Class=Display + IddCx INF, our own EDID + programmatic + mode list incl. the per-ADD client mode, the watchdog, a real swap-chain drain (the vdd port — the + drain is required so DWM keeps compositing; DDA/WGC still captures the desktop). Bundle + self-sign + + `pnputil`-install via the installer, identical to the gamepad-driver path we just built. **Outcome:** all-Rust, SudoVDA dependency dropped, DDA capture + unchanged. Effort ≈ **2–4 wk to first light**, **5–7 wk to parity** (HDR, multi-monitor, CI). +- **P2 — direct frame push (kill DDA).** Add a swap-chain processor that copies each frame into a + shared section/texture; new `capture` backend reads it directly; pin the render adapter to the + encoder GPU. Gate behind a flag, validate against DDA, then retire the DDA path + the `win32u.dll` + patch. HDR via the IddCx 1.11 D3D12 acquire path. **Outcome:** the real "owning the stack pays off" + cleanup. Effort: additional; the Session-0 transport is the long pole. + +## Risks + +1. **D3-in-a-driver swap-chain loop** — the one genuinely new piece; bugs here = black screens/TDR. + Mitigated by `virtual-display-rs`'s `swap_chain_processor.rs` + the MS sample as references. +2. **Session-0 cross-process transport** (P2) — the actual hard part; prototype it first. +3. **HDR = the harder D3D12 1.11 path** — our current WGC/DDA HDR is free; the IddCx HDR path is not. +4. **Two binding stacks** if we go D2(b) — a maintenance cost cutting against "clean/consistent." +5. **No WHQL ⇒ no Windows Update / Dev-Center distribution** — same constraint our gamepad drivers + already accept (bundle + self-sign + import cert). + +## References + +- IddCx model + signing: [IDD model overview](https://learn.microsoft.com/en-us/windows-hardware/drivers/display/indirect-display-driver-model-overview) · + [IddCx versions](https://learn.microsoft.com/en-us/windows-hardware/drivers/display/iddcx-versions) · + [1.10+ updates](https://learn.microsoft.com/en-us/windows-hardware/drivers/display/iddcx1.10-updates) · + [UMDF signing](https://learn.microsoft.com/en-us/archive/blogs/peterwie/do-umdf-drivers-require-signing) +- Swap-chain / frames: [IDDCX_METADATA](https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/iddcx/ns-iddcx-iddcx_metadata) · + [SetDevice](https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/iddcx/nf-iddcx-iddcxswapchainsetdevice) · + [SetRenderAdapter](https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/iddcx/nf-iddcx-iddcxadaptersetrenderadapter) · + [ASSIGN_SWAPCHAIN](https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/iddcx/nc-iddcx-evt_idd_cx_monitor_assign_swapchain) +- Prior art: [microsoft IddSampleDriver](https://github.com/microsoft/Windows-driver-samples/tree/main/video/IndirectDisplay) · + [SudoMaker/SudoVDA](https://github.com/SudoMaker/SudoVDA) ([ioctl.h](https://github.com/SudoMaker/SudoVDA/blob/master/Common/Include/sudovda-ioctl.h)) · + **[MolotovCherry/virtual-display-rs (Rust, MIT)](https://github.com/MolotovCherry/virtual-display-rs)** · + [Looking Glass IDD (swap-chain → shm, no DDA)](https://deepwiki.com/gnif/LookingGlass/2.5-indirect-display-driver-(idd)) · + [itsmikethetech/Virtual-Display-Driver](https://github.com/itsmikethetech/Virtual-Display-Driver) diff --git a/packaging/windows/vdisplay-driver/.cargo/config.toml b/packaging/windows/vdisplay-driver/.cargo/config.toml new file mode 100644 index 0000000..fac678a --- /dev/null +++ b/packaging/windows/vdisplay-driver/.cargo/config.toml @@ -0,0 +1,2 @@ +[build] +rustflags = ["-C", "target-feature=+crt-static"] diff --git a/packaging/windows/vdisplay-driver/.gitignore b/packaging/windows/vdisplay-driver/.gitignore new file mode 100644 index 0000000..b3284fc --- /dev/null +++ b/packaging/windows/vdisplay-driver/.gitignore @@ -0,0 +1,3 @@ +/target +*.cer +*.pfx diff --git a/packaging/windows/vdisplay-driver/Cargo.lock b/packaging/windows/vdisplay-driver/Cargo.lock new file mode 100644 index 0000000..acef0b3 --- /dev/null +++ b/packaging/windows/vdisplay-driver/Cargo.lock @@ -0,0 +1,510 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "aho-corasick" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" +dependencies = [ + "memchr", +] + +[[package]] +name = "anyhow" +version = "1.0.102" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" + +[[package]] +name = "bindgen" +version = "0.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f" +dependencies = [ + "bitflags", + "cexpr", + "clang-sys", + "itertools", + "log", + "prettyplease", + "proc-macro2", + "quote", + "regex", + "rustc-hash", + "shlex", + "syn", +] + +[[package]] +name = "bitflags" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8" + +[[package]] +name = "bytemuck" +version = "1.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "cexpr" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" +dependencies = [ + "nom", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "clang-sys" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4" +dependencies = [ + "glob", + "libc", + "libloading", +] + +[[package]] +name = "either" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e" + +[[package]] +name = "glob" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "libc" +version = "0.2.186" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "log" +version = "0.4.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad" + +[[package]] +name = "memchr" +version = "2.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4" + +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + +[[package]] +name = "pf-vdisplay" +version = "0.1.0" +dependencies = [ + "anyhow", + "bytemuck", + "log", + "thiserror", + "wdf-umdf", + "wdf-umdf-sys", + "windows", +] + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "syn" +version = "2.0.118" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "wdf-umdf" +version = "0.1.0" +dependencies = [ + "paste", + "thiserror", + "wdf-umdf-sys", +] + +[[package]] +name = "wdf-umdf-sys" +version = "0.1.0" +dependencies = [ + "bindgen", + "bytemuck", + "paste", + "thiserror", + "winreg", +] + +[[package]] +name = "windows" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6" +dependencies = [ + "windows-core", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-core" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-result", + "windows-strings", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-implement" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-result" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-strings" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10" +dependencies = [ + "windows-result", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" +dependencies = [ + "windows-targets 0.48.5", +] + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm 0.48.5", + "windows_aarch64_msvc 0.48.5", + "windows_i686_gnu 0.48.5", + "windows_i686_msvc 0.48.5", + "windows_x86_64_gnu 0.48.5", + "windows_x86_64_gnullvm 0.48.5", + "windows_x86_64_msvc 0.48.5", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winreg" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a277a57398d4bfa075df44f501a17cfdf8542d224f0d36095a2adc7aee4ef0a5" +dependencies = [ + "cfg-if", + "windows-sys", +] diff --git a/packaging/windows/vdisplay-driver/Cargo.toml b/packaging/windows/vdisplay-driver/Cargo.toml new file mode 100644 index 0000000..c3f1d7d --- /dev/null +++ b/packaging/windows/vdisplay-driver/Cargo.toml @@ -0,0 +1,26 @@ +# pf-vdisplay — punktfunk Windows virtual display (IddCx), in Rust. +# +# A self-contained driver workspace (NOT built on windows-drivers-rs like the gamepad drivers — IddCx +# functions are direct IddCxStub exports the WDF function-table macro can't reach, so a unified bindgen +# is the cleaner base). The wdf-umdf-sys / wdf-umdf binding crates are vendored from MolotovCherry's +# MIT-licensed virtual-display-rs (see LICENSE.virtual-display-rs); pf-vdisplay is our driver, swapping +# its named-pipe IPC for the SudoVDA-compatible IOCTL control plane our host already speaks. +[workspace] +resolver = "2" +members = ["wdf-umdf-sys", "wdf-umdf", "pf-vdisplay"] + +[profile.release] +strip = true +codegen-units = 1 +lto = true + +[workspace.lints.rust] +unsafe_op_in_unsafe_fn = "deny" + +[workspace.lints.clippy] +pedantic = { level = "warn", priority = -1 } +multiple_unsafe_ops_per_block = "deny" +ignored_unit_patterns = "allow" +missing_errors_doc = "allow" +module_inception = "allow" +module_name_repetitions = "allow" diff --git a/packaging/windows/vdisplay-driver/LICENSE.virtual-display-rs b/packaging/windows/vdisplay-driver/LICENSE.virtual-display-rs new file mode 100644 index 0000000..7908f3e --- /dev/null +++ b/packaging/windows/vdisplay-driver/LICENSE.virtual-display-rs @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Cherry + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packaging/windows/vdisplay-driver/README.md b/packaging/windows/vdisplay-driver/README.md new file mode 100644 index 0000000..7e6ef44 --- /dev/null +++ b/packaging/windows/vdisplay-driver/README.md @@ -0,0 +1,61 @@ +# pf-vdisplay — punktfunk Windows virtual display (Rust IddCx) + +P1 of replacing the vendored **SudoVDA** C++ driver with one we own — a pure-Rust UMDF2 **IddCx** +(Indirect Display Driver) virtual display, drop-in compatible with the host's existing +`vdisplay/sudovda.rs` IOCTL control plane. Full rationale + roadmap: +[`docs/windows-virtual-display-rust-port.md`](../../../docs/windows-virtual-display-rust-port.md). + +## Layout + +``` +vdisplay-driver/ + wdf-umdf-sys/ VENDORED bindgen FFI to WDF + IddCx (links WdfDriverStubUm + IddCxStub) + wdf-umdf/ VENDORED safe wrappers (IddCx*/Wdf*) + pf-vdisplay/ OUR driver crate (cdylib) + pf_vdisplay.inx +``` + +`wdf-umdf-sys` / `wdf-umdf` are vendored from [MolotovCherry/virtual-display-rs](https://github.com/MolotovCherry/virtual-display-rs) +(MIT — see `LICENSE.virtual-display-rs`). They're a self-contained bindgen over the WDK, **not** +`windows-drivers-rs` (which the gamepad drivers use): IddCx functions are direct `IddCxStub` exports the +WDF function-table macro can't reach, so a unified bindgen is the cleaner base. Local fix carried in +`wdf-umdf-sys/build.rs`: resolve the `IddCxStub` lib path by the SDK version that actually contains +`um\x64\iddcx\` (a newer base SDK alongside the WDK has `um\x64` but no `iddcx`). + +## Status + +- **Scaffold builds** ✅ — workspace + vendored bindings + `pf-vdisplay` compile in-tree to + `pf_vdisplay.dll`. The reference (virtual-display-rs) was separately built + installed + loaded + (Status OK) on the RTX box, proving the IddCx-in-Rust chain end to end. +- **Next (P1 driver logic):** port the IddCx driver — `DriverEntry` → `IDD_CX_CLIENT_CONFIG` + (adapter-init / parse-monitor-description / query-target-modes / assign-swapchain) → device + monitor + context, generic EDID, no-op swap-chain drain (DDA still captures for P1). Logging via + `OutputDebugString` (no `log`/`driver-logger`/`tokio`). +- **Then (control plane):** the SudoVDA-compatible IOCTL surface on the control device + (`ADD`/`REMOVE`/`PING`/`GET_WATCHDOG`/`GET_VERSION`/`SET_RENDER_ADAPTER`, byte-identical structs + + the `{e5bcc234-…}` interface GUID) so `vdisplay/sudovda.rs` drives it **unchanged**; a default mode + table + the per-`ADD` client mode injected as preferred; the watchdog. +- **Later (P2):** push swap-chain frames straight to the host (skip DDA); HDR via the IddCx 1.11 D3D12 + acquire path. + +## Build + +Needs the WDK (UMDF 2.31 + IddCx stubs), LLVM/clang (`LIBCLANG_PATH`), and the pinned +`nightly-2024-07-26` (auto-selected via `rust-toolchain.toml`). From `pf-vdisplay/`, inside an MSVC dev +shell: + +``` +set LIBCLANG_PATH=C:\Program Files\LLVM\bin +cargo build # -> ../target/x86_64-pc-windows-msvc/debug/pf_vdisplay.dll +``` + +## Sign + install (same recipe as the gamepad drivers) + +1. (no FORCE_INTEGRITY bit to clear — this crate doesn't set `/INTEGRITYCHECK`) +2. `signtool sign /fd SHA256 /sha1 ` the renamed `pf_vdisplay.dll` +3. `stampinf -f pf_vdisplay.inf -d * -a amd64 -u 2.15.0 -v ` ; `Inf2Cat /driver: /os:10_X64` ; + sign the `.cat` +4. `pnputil /add-driver pf_vdisplay.inf` ; create the root devnode (`nefconc --create-device-node + --hardware-id root\pf_vdisplay --class-name Display --class-guid {4d36e968-…}`, mirroring + `install-sudovda.ps1`) + +Bundles into the Inno Setup installer the same way as `gamepad-drivers/` once the driver is functional. diff --git a/packaging/windows/vdisplay-driver/deploy-dev.ps1 b/packaging/windows/vdisplay-driver/deploy-dev.ps1 new file mode 100644 index 0000000..d3869bc --- /dev/null +++ b/packaging/windows/vdisplay-driver/deploy-dev.ps1 @@ -0,0 +1,77 @@ +#requires -Version 5.1 +<# +.SYNOPSIS + Stage, sign, and (optionally) install the pf-vdisplay UMDF IddCx driver for local dev/test. + +.DESCRIPTION + Copies the freshly built pf_vdisplay.dll into the stage dir, signs it with the self-signed test cert, + stamps a STRICTLY INCREASING DriverVer (date.time) into the INF, then generates and signs the catalog. + With -Install it also pnputil /add-driver's the package and creates the Root\pf_vdisplay devnode. + + Why the DriverVer bump matters: `pnputil /add-driver /install` only replaces an already-installed + driver binary when the INF DriverVer is higher than the installed one. Re-deploying without a bump + silently keeps the OLD binary loaded — a trap that masks code changes during iteration. + + Build first: from pf-vdisplay/, in an MSVC dev shell with LIBCLANG_PATH set, run `cargo build`. + + NOTE: pf-vdisplay and SudoVDA register the SAME control-interface GUID, so only one may be active at a + time. On the dev box, disable/remove the SudoVDA devnode before installing pf-vdisplay (and restore it + after). This script does not touch SudoVDA. + +.PARAMETER Install + Also add the driver package to the store and create the root devnode. +#> +[CmdletBinding()] +param( + [string]$Stage = 'C:\Users\Public\pfvd-stage', + [string]$Thumbprint = '6A52984E54376C45A1C236B1A2C8A746C5AB6131', + [string]$Nefconc = 'C:\Users\Public\virtual-display-rs\installer\files\nefconc.exe', + [switch]$Install +) +$ErrorActionPreference = 'Stop' + +$root = Split-Path -Parent $MyInvocation.MyCommand.Path +$dll = Join-Path $root 'target\x86_64-pc-windows-msvc\debug\pf_vdisplay.dll' +$inx = Join-Path $root 'pf-vdisplay\pf_vdisplay.inx' +if (-not (Test-Path $dll)) { throw "driver not built: $dll (run cargo build in pf-vdisplay/ first)" } + +$kits = 'C:\Program Files (x86)\Windows Kits\10\bin' +function Find-Tool([string]$name, [string]$arch) { + (Get-ChildItem "$kits\*\$arch\$name" -EA SilentlyContinue | Sort-Object FullName | Select-Object -Last 1).FullName +} +$signtool = Find-Tool 'signtool.exe' 'x64' +$stampinf = Find-Tool 'stampinf.exe' 'x64' +$inf2cat = Find-Tool 'Inf2Cat.exe' 'x86' +if (-not $signtool) { throw 'signtool.exe not found in the WDK' } +if (-not $stampinf) { throw 'stampinf.exe not found in the WDK' } +if (-not $inf2cat) { throw 'Inf2Cat.exe not found in the WDK' } + +New-Item -ItemType Directory -Force -Path $Stage | Out-Null +$stagedDll = Join-Path $Stage 'pf_vdisplay.dll' +$stagedInf = Join-Path $Stage 'pf_vdisplay.inf' +$stagedCat = Join-Path $Stage 'pf_vdisplay.cat' +Copy-Item $dll $stagedDll -Force +Copy-Item $inx $stagedInf -Force # stampinf rewrites this copy in place + +# DriverVer date+time — must strictly increase each deploy or pnputil keeps the old binary. +$now = Get-Date +$ver = '1.0.{0}.{1}' -f $now.ToString('MMdd'), $now.ToString('HHmm') + +& $signtool sign /fd SHA256 /sha1 $Thumbprint $stagedDll | Out-Null +& $stampinf -f $stagedInf -d '*' -a 'amd64' -u '2.15.0' -v $ver | Out-Null +& $inf2cat /driver:$Stage /os:10_X64 /uselocaltime | Out-Null +& $signtool sign /fd SHA256 /sha1 $Thumbprint $stagedCat | Out-Null +Write-Host "staged + signed pf-vdisplay DriverVer=$ver" + +if ($Install) { + & pnputil /add-driver $stagedInf /install | Out-Null + $present = Get-PnpDevice -EA SilentlyContinue | + Where-Object { $_.InstanceId -match 'PF_VDISPLAY' -or $_.FriendlyName -match 'punktfunk Virtual Display' } + if (-not $present) { + if (-not (Test-Path $Nefconc)) { throw "nefconc not found: $Nefconc" } + & $Nefconc --create-device-node --hardware-id 'root\pf_vdisplay' --class-name Display --class-guid '{4d36e968-e325-11ce-bfc1-08002be10318}' | Out-Null + Start-Sleep 2 + & pnputil /add-driver $stagedInf /install | Out-Null + } + Write-Host 'installed pf-vdisplay (root\pf_vdisplay devnode)' +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/.cargo/config.toml b/packaging/windows/vdisplay-driver/pf-vdisplay/.cargo/config.toml new file mode 100644 index 0000000..141aa5a --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/.cargo/config.toml @@ -0,0 +1,11 @@ +[build] +target = "x86_64-pc-windows-msvc" + +rustflags = [ + "-Zpre-link-arg=/NOLOGO", + "-Zpre-link-arg=/MANIFEST:NO", + "-Zpre-link-arg=/SUBSYSTEM:WINDOWS", + "-Zpre-link-arg=/DYNAMICBASE", + "-Zpre-link-arg=/NXCOMPAT", + "-Clink-arg=/OPT:REF,ICF", +] diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/Cargo.toml b/packaging/windows/vdisplay-driver/pf-vdisplay/Cargo.toml new file mode 100644 index 0000000..ef63918 --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "pf-vdisplay" +version = "0.1.0" +edition = "2021" + +[lib] +crate-type = ["cdylib"] + +[dependencies] +wdf-umdf-sys = { path = "../wdf-umdf-sys" } +wdf-umdf = { path = "../wdf-umdf" } +bytemuck = { version = "1.19", features = ["derive"] } +thiserror = "2.0" +anyhow = "1.0" +log = "0.4" + +[dependencies.windows] +version = "0.58.0" +features = [ + "Win32_Foundation", + "Win32_Security", + "Win32_System_SystemServices", + "Win32_System_Threading", + "Win32_System_Diagnostics_Debug", + "Win32_Graphics_Direct3D", + "Win32_Graphics_Direct3D11", + "Win32_Graphics_Dxgi", + "Win32_Graphics_Dxgi_Common", +] diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/build.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/build.rs new file mode 100644 index 0000000..fe4f348 --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/build.rs @@ -0,0 +1,5 @@ +fn main() { + // UMDF includes need the static C runtime linked. + println!("cargo::rustc-link-lib=static=ucrt"); + println!("cargo::rerun-if-changed=build.rs"); +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/pf_vdisplay.inx b/packaging/windows/vdisplay-driver/pf-vdisplay/pf_vdisplay.inx new file mode 100644 index 0000000..9d08f96 --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/pf_vdisplay.inx @@ -0,0 +1,77 @@ +;/*++ +; pf-vdisplay - punktfunk virtual display, UMDF2 IddCx driver INF (template; stampinf -> .inf). +; Adapted from MolotovCherry/virtual-display-rs (MIT) + SudoVDA's control-device security DACL. +;--*/ +[Version] +PnpLockdown=1 +Signature="$Windows NT$" +ClassGUID={4D36E968-E325-11CE-BFC1-08002BE10318} +Class=Display +ClassVer=2.0 +Provider=%ManufacturerName% +CatalogFile=pf_vdisplay.cat +DriverVer= + +[Manufacturer] +%ManufacturerName%=Standard,NT$ARCH$ + +[Standard.NT$ARCH$] +%DeviceName%=pf_vdisplay_Install, Root\pf_vdisplay + +[SourceDisksFiles] +pf_vdisplay.dll=1 + +[SourceDisksNames] +1=%DiskName% + +; =================== UMDF IddCx device ==================== + +[pf_vdisplay_Install.NT] +CopyFiles=UMDriverCopy + +[pf_vdisplay_Install.NT.hw] +AddReg=pf_vdisplay_HardwareDeviceSettings + +[pf_vdisplay_HardwareDeviceSettings] +HKR, , "UpperFilters", %REG_MULTI_SZ%, "IndirectKmd" +HKR, "WUDF", "DeviceGroupId", %REG_SZ%, "pfVDisplayGroup" +; Let the host (LocalSystem service) + admins open the control device for the ADD/REMOVE/PING IOCTLs. +HKR, , "Security", , "D:P(A;;GA;;;SY)(A;;GA;;;BA)(A;;GRGW;;;WD)" + +[pf_vdisplay_Install.NT.Services] +AddService=WUDFRd,0x000001fa,WUDFRD_ServiceInstall + +[pf_vdisplay_Install.NT.Wdf] +UmdfService=pf_vdisplay, pf_vdisplay_Install +UmdfServiceOrder=pf_vdisplay +UmdfKernelModeClientPolicy=AllowKernelModeClients +UmdfHostProcessSharing=ProcessSharingDisabled + +[pf_vdisplay_Install] +UmdfLibraryVersion=$UMDFVERSION$ +ServiceBinary=%12%\UMDF\pf_vdisplay.dll +UmdfExtensions=IddCx0102 + +[WUDFRD_ServiceInstall] +DisplayName=%WudfRdDisplayName% +ServiceType=1 +StartType=3 +ErrorControl=1 +ServiceBinary=%12%\WUDFRd.sys + +[DestinationDirs] +UMDriverCopy=12,UMDF + +[UMDriverCopy] +pf_vdisplay.dll + +[Strings] +ManufacturerName="punktfunk" +DiskName="punktfunk Virtual Display Installation Disk" +WudfRdDisplayName="Windows Driver Foundation - User-mode Driver Framework Reflector" +DeviceName="punktfunk Virtual Display" + +REG_MULTI_SZ=0x00010000 +REG_SZ=0x00000000 +REG_EXPAND_SZ=0x00020000 +REG_DWORD=0x00010001 diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/callbacks.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/callbacks.rs new file mode 100644 index 0000000..2fe1dd4 --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/callbacks.rs @@ -0,0 +1,322 @@ +use std::{ + mem::{self, MaybeUninit}, + ptr::NonNull, +}; + +use log::{error, info}; +use wdf_umdf_sys::{ + DISPLAYCONFIG_VIDEO_SIGNAL_INFO__bindgen_ty_1, + DISPLAYCONFIG_VIDEO_SIGNAL_INFO__bindgen_ty_1__bindgen_ty_1, __BindgenBitfieldUnit, + DISPLAYCONFIG_2DREGION, DISPLAYCONFIG_RATIONAL, DISPLAYCONFIG_SCANLINE_ORDERING, + DISPLAYCONFIG_TARGET_MODE, DISPLAYCONFIG_VIDEO_SIGNAL_INFO, IDARG_IN_ADAPTER_INIT_FINISHED, + IDARG_IN_COMMITMODES, IDARG_IN_GETDEFAULTDESCRIPTIONMODES, IDARG_IN_PARSEMONITORDESCRIPTION, + IDARG_IN_QUERYTARGETMODES, IDARG_IN_SETSWAPCHAIN, IDARG_OUT_GETDEFAULTDESCRIPTIONMODES, + IDARG_OUT_PARSEMONITORDESCRIPTION, IDARG_OUT_QUERYTARGETMODES, IDDCX_ADAPTER__, + IDDCX_MONITOR_MODE, IDDCX_MONITOR_MODE_ORIGIN, IDDCX_MONITOR__, IDDCX_TARGET_MODE, NTSTATUS, + WDFDEVICE, WDF_POWER_DEVICE_STATE, +}; + +use crate::{ + context::{DeviceContext, MonitorContext}, + edid::Edid, + monitor::{AdapterObject, FlattenModes, ADAPTER, MONITOR_MODES}, +}; + +pub extern "C-unwind" fn adapter_init_finished( + adapter_object: *mut IDDCX_ADAPTER__, + _p_in_args: *const IDARG_IN_ADAPTER_INIT_FINISHED, +) -> NTSTATUS { + let Some(adapter_ptr) = NonNull::new(adapter_object) else { + error!("Adapter ptr was null"); + return NTSTATUS::STATUS_INVALID_ADDRESS; + }; + + // store adapter object for the control plane to use + if ADAPTER.set(AdapterObject(adapter_ptr)).is_err() { + error!("Failed to set adapter"); + return NTSTATUS::STATUS_ADAPTER_HARDWARE_ERROR; + } + + DeviceContext::finish_init(); + + NTSTATUS::STATUS_SUCCESS +} + +pub extern "C-unwind" fn device_d0_entry( + device: WDFDEVICE, + _previous_state: WDF_POWER_DEVICE_STATE, +) -> NTSTATUS { + let status: NTSTATUS = unsafe { + DeviceContext::get_mut(device.cast(), |context| { + if let Err(e) = context.init_adapter() { + error!("Failed to init adapter: {e:?}"); + } + }) + .into() + }; + + if !status.is_success() { + return status; + } + + NTSTATUS::STATUS_SUCCESS +} + +fn display_info(width: u32, height: u32, refresh_rate: u32) -> DISPLAYCONFIG_VIDEO_SIGNAL_INFO { + let clock_rate = refresh_rate * (height + 4) * (height + 4) + 1000; + + DISPLAYCONFIG_VIDEO_SIGNAL_INFO { + pixelRate: u64::from(clock_rate), + hSyncFreq: DISPLAYCONFIG_RATIONAL { + Numerator: clock_rate, + Denominator: height + 4, + }, + vSyncFreq: DISPLAYCONFIG_RATIONAL { + Numerator: clock_rate, + Denominator: (height + 4) * (height + 4), + }, + activeSize: DISPLAYCONFIG_2DREGION { + cx: width, + cy: height, + }, + totalSize: DISPLAYCONFIG_2DREGION { + cx: width + 4, + cy: height + 4, + }, + __bindgen_anon_1: DISPLAYCONFIG_VIDEO_SIGNAL_INFO__bindgen_ty_1 { + AdditionalSignalInfo: unsafe { + mem::transmute::< + __BindgenBitfieldUnit<[u8; 4]>, + DISPLAYCONFIG_VIDEO_SIGNAL_INFO__bindgen_ty_1__bindgen_ty_1, + >( + DISPLAYCONFIG_VIDEO_SIGNAL_INFO__bindgen_ty_1__bindgen_ty_1::new_bitfield_1( + 255, 0, 0, + ), + ) + }, + }, + scanLineOrdering: + DISPLAYCONFIG_SCANLINE_ORDERING::DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE, + } +} + +pub extern "C-unwind" fn parse_monitor_description( + p_in_args: *const IDARG_IN_PARSEMONITORDESCRIPTION, + p_out_args: *mut IDARG_OUT_PARSEMONITORDESCRIPTION, +) -> NTSTATUS { + let in_args = unsafe { &*p_in_args }; + let out_args = unsafe { &mut *p_out_args }; + + let Ok(monitors) = MONITOR_MODES.lock() else { + error!("MONITOR_MODES mutex poisoned"); + return NTSTATUS::STATUS_DRIVER_INTERNAL_ERROR; + }; + + let edid = unsafe { + std::slice::from_raw_parts( + in_args.MonitorDescription.pData as *const u8, + in_args.MonitorDescription.DataSize as usize, + ) + }; + + let monitor_index = Edid::get_serial(edid); + let Ok(monitor_index) = monitor_index else { + error!( + "We got an edid {} bytes long, but this is incorrect", + edid.len() + ); + return NTSTATUS::STATUS_INVALID_VIEW_SIZE; + }; + + let Some(monitor) = monitors.iter().find(|&m| m.data.id == monitor_index) else { + error!("Failed to find monitor id {monitor_index}"); + return NTSTATUS::STATUS_DRIVER_INTERNAL_ERROR; + }; + + let number_of_modes: u32 = monitor + .data + .modes + .iter() + .map(|m| u32::try_from(m.refresh_rates.len()).expect("Cannot use > u32::MAX refresh rates")) + .sum(); + + out_args.MonitorModeBufferOutputCount = number_of_modes; + if in_args.MonitorModeBufferInputCount < number_of_modes { + // Return success if there was no buffer, since the caller was only asking for a count of modes + return if in_args.MonitorModeBufferInputCount > 0 { + NTSTATUS::STATUS_BUFFER_TOO_SMALL + } else { + NTSTATUS::STATUS_SUCCESS + }; + } + + let monitor_modes = unsafe { + std::slice::from_raw_parts_mut( + in_args + .pMonitorModes + .cast::>(), + number_of_modes as usize, + ) + }; + + for (mode, out_mode) in monitor.data.modes.flatten().zip(monitor_modes.iter_mut()) { + out_mode.write(IDDCX_MONITOR_MODE { + #[allow(clippy::cast_possible_truncation)] + Size: mem::size_of::() as u32, + Origin: IDDCX_MONITOR_MODE_ORIGIN::IDDCX_MONITOR_MODE_ORIGIN_MONITORDESCRIPTOR, + MonitorVideoSignalInfo: display_info(mode.width, mode.height, mode.refresh_rate), + }); + } + + // Set the preferred mode as represented in the EDID + out_args.PreferredMonitorModeIdx = 0; + + NTSTATUS::STATUS_SUCCESS +} + +pub extern "C-unwind" fn monitor_get_default_modes( + _monitor_object: *mut IDDCX_MONITOR__, + _p_in_args: *const IDARG_IN_GETDEFAULTDESCRIPTIONMODES, + _p_out_args: *mut IDARG_OUT_GETDEFAULTDESCRIPTIONMODES, +) -> NTSTATUS { + NTSTATUS::STATUS_NOT_IMPLEMENTED +} + +pub fn target_mode(width: u32, height: u32, refresh_rate: u32) -> IDDCX_TARGET_MODE { + let total_size = DISPLAYCONFIG_2DREGION { + cx: width, + cy: height, + }; + + IDDCX_TARGET_MODE { + #[allow(clippy::cast_possible_truncation)] + Size: mem::size_of::() as u32, + + TargetVideoSignalInfo: DISPLAYCONFIG_TARGET_MODE { + targetVideoSignalInfo: DISPLAYCONFIG_VIDEO_SIGNAL_INFO { + pixelRate: u64::from(refresh_rate) * u64::from(width) * u64::from(height), + hSyncFreq: DISPLAYCONFIG_RATIONAL { + Numerator: refresh_rate * height, + Denominator: 1, + }, + vSyncFreq: DISPLAYCONFIG_RATIONAL { + Numerator: refresh_rate, + Denominator: 1, + }, + totalSize: total_size, + activeSize: total_size, + scanLineOrdering: + DISPLAYCONFIG_SCANLINE_ORDERING::DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE, + __bindgen_anon_1: DISPLAYCONFIG_VIDEO_SIGNAL_INFO__bindgen_ty_1 { + AdditionalSignalInfo: unsafe { + mem::transmute::<__BindgenBitfieldUnit<[u8; 4]>, DISPLAYCONFIG_VIDEO_SIGNAL_INFO__bindgen_ty_1__bindgen_ty_1>( + DISPLAYCONFIG_VIDEO_SIGNAL_INFO__bindgen_ty_1__bindgen_ty_1::new_bitfield_1( + 255, 1, 0, + ), + ) + }, + }, + }, + }, + + ..Default::default() + } +} + +pub extern "C-unwind" fn monitor_query_modes( + monitor_object: *mut IDDCX_MONITOR__, + p_in_args: *const IDARG_IN_QUERYTARGETMODES, + p_out_args: *mut IDARG_OUT_QUERYTARGETMODES, +) -> NTSTATUS { + // find out which monitor this belongs too + + let Ok(monitors) = MONITOR_MODES.lock() else { + error!("MONITOR_MODES mutex poisoned"); + return NTSTATUS::STATUS_DRIVER_INTERNAL_ERROR; + }; + + // we have stored the monitor object per id, so we should be able to compare pointers + let Some(monitor) = monitors + .iter() + .find(|&m| m.object.is_some_and(|p| p.as_ptr() == monitor_object)) + else { + error!("Failed to find monitor object in cache for {monitor_object:?}"); + return NTSTATUS::STATUS_DRIVER_INTERNAL_ERROR; + }; + + let number_of_modes = monitor + .data + .modes + .iter() + .map(|m| u32::try_from(m.refresh_rates.len()).expect("Cannot use > u32::MAX modes")) + .sum(); + + // Create a set of modes supported for frame processing and scan-out. These are typically not based on the + // monitor's descriptor and instead are based on the static processing capability of the device. The OS will + // report the available set of modes for a given output as the intersection of monitor modes with target modes. + + let out_args = unsafe { &mut *p_out_args }; + out_args.TargetModeBufferOutputCount = number_of_modes; + + let in_args = unsafe { &*p_in_args }; + + if in_args.TargetModeBufferInputCount >= number_of_modes { + let out_target_modes = unsafe { + std::slice::from_raw_parts_mut( + in_args + .pTargetModes + .cast::>(), + number_of_modes as usize, + ) + }; + + for (mode, out_target) in monitor + .data + .modes + .flatten() + .zip(out_target_modes.iter_mut()) + { + let target_mode = target_mode(mode.width, mode.height, mode.refresh_rate); + + out_target.write(target_mode); + } + } + + NTSTATUS::STATUS_SUCCESS +} + +pub extern "C-unwind" fn adapter_commit_modes( + _adapter_object: *mut IDDCX_ADAPTER__, + _p_in_args: *const IDARG_IN_COMMITMODES, +) -> NTSTATUS { + // The swap-chain is managed by IddCx; there is nothing device-specific to reconfigure on a commit. + NTSTATUS::STATUS_SUCCESS +} + +pub extern "C-unwind" fn assign_swap_chain( + monitor_object: *mut IDDCX_MONITOR__, + p_in_args: *const IDARG_IN_SETSWAPCHAIN, +) -> NTSTATUS { + let p_in_args = unsafe { &*p_in_args }; + + unsafe { + MonitorContext::get_mut(monitor_object.cast(), |context| { + context.assign_swap_chain( + p_in_args.hSwapChain, + p_in_args.RenderAdapterLuid, + p_in_args.hNextSurfaceAvailable, + ); + }) + .into() + } +} + +pub extern "C-unwind" fn unassign_swap_chain(monitor_object: *mut IDDCX_MONITOR__) -> NTSTATUS { + info!("swap-chain unassigned (monitor inactive)"); + unsafe { + MonitorContext::get_mut(monitor_object.cast(), |context| { + context.unassign_swap_chain(); + }) + .into() + } +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/context.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/context.rs new file mode 100644 index 0000000..203c7ef --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/context.rs @@ -0,0 +1,328 @@ +use std::{ + mem::{self, size_of}, + num::{ParseIntError, TryFromIntError}, + ptr::{addr_of_mut, NonNull}, +}; + +use anyhow::anyhow; +use log::{error, info, warn}; +use wdf_umdf::{ + IddCxAdapterInitAsync, IddCxError, IddCxMonitorArrival, IddCxMonitorCreate, + IddCxMonitorSetupHardwareCursor, WdfError, WdfObjectDelete, WDF_DECLARE_CONTEXT_TYPE, +}; +use wdf_umdf_sys::{ + DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY, HANDLE, IDARG_IN_ADAPTER_INIT, IDARG_IN_MONITORCREATE, + IDARG_IN_SETUP_HWCURSOR, IDARG_OUT_ADAPTER_INIT, IDARG_OUT_MONITORARRIVAL, + IDARG_OUT_MONITORCREATE, IDDCX_ADAPTER, IDDCX_ADAPTER_CAPS, IDDCX_CURSOR_CAPS, + IDDCX_ENDPOINT_DIAGNOSTIC_INFO, IDDCX_ENDPOINT_VERSION, IDDCX_FEATURE_IMPLEMENTATION, + IDDCX_MONITOR, IDDCX_MONITOR_DESCRIPTION, IDDCX_MONITOR_DESCRIPTION_TYPE, IDDCX_MONITOR_INFO, + IDDCX_SWAPCHAIN, IDDCX_TRANSMISSION_TYPE, IDDCX_XOR_CURSOR_SUPPORT, LUID, NTSTATUS, WDFDEVICE, + WDFOBJECT, WDF_OBJECT_ATTRIBUTES, +}; +use windows::{ + core::{s, w, GUID}, + Win32::{Foundation::TRUE, System::Threading::CreateEventA}, +}; + +use crate::{ + direct_3d_device::Direct3DDevice, + edid::Edid, + monitor::MONITOR_MODES, + swap_chain_processor::SwapChainProcessor, +}; + +// Maximum amount of monitors that can be connected +pub const MAX_MONITORS: u8 = 16; + +pub struct DeviceContext { + device: WDFDEVICE, + adapter: Option, +} + +// SAFETY: Raw ptr is managed by external library +unsafe impl Send for DeviceContext {} +unsafe impl Sync for DeviceContext {} + +// for now, `device` is hardcoded into the macro, so it needs to be there even if unused +#[allow(unused)] +pub struct MonitorContext { + device: IDDCX_MONITOR, + swap_chain_processor: Option, +} + +// SAFETY: Raw ptr is managed by external library +unsafe impl Send for MonitorContext {} +unsafe impl Sync for MonitorContext {} + +WDF_DECLARE_CONTEXT_TYPE!(pub DeviceContext); +WDF_DECLARE_CONTEXT_TYPE!(pub MonitorContext); + +#[derive(Debug, thiserror::Error)] +pub enum ContextError { + #[error("Failed to parse integer: {0:?}")] + ParseInt(#[from] ParseIntError), + #[error("Failed to convert integer: {0:?}")] + TryFromInt(#[from] TryFromIntError), + #[error("Failed to convert to NTSTATUS: {0:?}")] + Ntstatus(#[from] NTSTATUS), + #[error("Failed to convert to IddCxError: {0:?}")] + IddCx(#[from] IddCxError), + #[error("Failed to convert to WdfError: {0:?}")] + Wdf(#[from] WdfError), + #[error("Windows Error: {0:?}")] + Win(#[from] windows::core::Error), + #[error("{0:?}")] + Other(#[from] anyhow::Error), +} + +impl DeviceContext { + pub fn new(device: WDFDEVICE) -> Self { + Self { + device, + adapter: None, + } + } + + pub fn init_adapter(&mut self) -> Result<(), ContextError> { + let mut version = IDDCX_ENDPOINT_VERSION { + #[allow(clippy::cast_possible_truncation)] + Size: size_of::() as u32, + + MajorVer: env!("CARGO_PKG_VERSION_MAJOR").parse::()?, + MinorVer: env!("CARGO_PKG_VERSION_MINOR").parse::()?, + Build: env!("CARGO_PKG_VERSION_PATCH").parse::()?, + ..Default::default() + }; + + let mut adapter_caps = IDDCX_ADAPTER_CAPS { + #[allow(clippy::cast_possible_truncation)] + Size: size_of::() as u32, + + MaxMonitorsSupported: u32::from(MAX_MONITORS), + + EndPointDiagnostics: IDDCX_ENDPOINT_DIAGNOSTIC_INFO { + #[allow(clippy::cast_possible_truncation)] + Size: size_of::() as u32, + GammaSupport: IDDCX_FEATURE_IMPLEMENTATION::IDDCX_FEATURE_IMPLEMENTATION_NONE, + TransmissionType: IDDCX_TRANSMISSION_TYPE::IDDCX_TRANSMISSION_TYPE_WIRED_OTHER, + + pEndPointFriendlyName: w!("punktfunk Virtual Display Adapter").as_ptr(), + pEndPointManufacturerName: w!("punktfunk").as_ptr(), + pEndPointModelName: w!("Virtual Display").as_ptr(), + + pFirmwareVersion: addr_of_mut!(version).cast(), + pHardwareVersion: addr_of_mut!(version).cast(), + }, + + ..Default::default() + }; + + let mut attr = WDF_OBJECT_ATTRIBUTES::init_context_type(unsafe { Self::get_type_info() }); + + let adapter_init = IDARG_IN_ADAPTER_INIT { + // this is WdfDevice because that's what we set last + WdfDevice: self.device, + pCaps: addr_of_mut!(adapter_caps).cast(), + ObjectAttributes: addr_of_mut!(attr).cast(), + }; + + let mut adapter_init_out = IDARG_OUT_ADAPTER_INIT::default(); + unsafe { IddCxAdapterInitAsync(&adapter_init, &mut adapter_init_out)? }; + + self.adapter = Some(adapter_init_out.AdapterObject); + + unsafe { self.clone_into(adapter_init_out.AdapterObject as WDFOBJECT)? }; + + Ok(()) + } + + pub fn finish_init() -> NTSTATUS { + // Monitors are created on demand by the IOCTL control plane (control::do_add). Start the + // watchdog so a crashed/gone host never leaves a phantom display. + crate::control::start_watchdog(); + NTSTATUS::STATUS_SUCCESS + } + + pub fn create_monitor(&mut self, index: u32) -> Result<(), ContextError> { + let mut attr = + WDF_OBJECT_ATTRIBUTES::init_context_type(unsafe { MonitorContext::get_type_info() }); + + // use the edid serial number to represent the monitor index for later identification + let mut edid = Edid::generate_with(index); + + let mut monitor_info = IDDCX_MONITOR_INFO { + #[allow(clippy::cast_possible_truncation)] + Size: size_of::() as u32, + // SAFETY: windows-rs + generated _GUID types are same size, with same fields, and repr C + // see: https://microsoft.github.io/windows-docs-rs/doc/windows/core/struct.GUID.html + // and: wmdf_umdf_sys::_GUID + MonitorContainerId: unsafe { + mem::transmute::(GUID::new()?) + }, + MonitorType: + DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY::DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI, + + ConnectorIndex: index, + MonitorDescription: IDDCX_MONITOR_DESCRIPTION { + #[allow(clippy::cast_possible_truncation)] + Size: size_of::() as u32, + + Type: IDDCX_MONITOR_DESCRIPTION_TYPE::IDDCX_MONITOR_DESCRIPTION_TYPE_EDID, + + #[allow(clippy::cast_possible_truncation)] + DataSize: edid.len() as u32, + + pData: edid.as_mut_ptr().cast(), + }, + }; + + let monitor_create = IDARG_IN_MONITORCREATE { + ObjectAttributes: &mut attr, + pMonitorInfo: &mut monitor_info, + }; + + let mut monitor_create_out = IDARG_OUT_MONITORCREATE::default(); + unsafe { + IddCxMonitorCreate( + self.adapter.ok_or(anyhow!("Failed to get adapter"))?, + &monitor_create, + &mut monitor_create_out, + )? + }; + + // store monitor object for later + { + let mut lock = MONITOR_MODES + .lock() + .map_err(|_| anyhow!("Failed to lock mutex"))?; + + for monitor in &mut *lock { + if monitor.data.id == index { + monitor.object = Some( + NonNull::new(monitor_create_out.MonitorObject) + .ok_or(anyhow!("MonitorObject was null"))?, + ); + } + } + } + + unsafe { + let context = MonitorContext::new(monitor_create_out.MonitorObject); + context.init(monitor_create_out.MonitorObject as WDFOBJECT)?; + } + + // tell os monitor is plugged in + + let mut arrival_out = IDARG_OUT_MONITORARRIVAL::default(); + + unsafe { + IddCxMonitorArrival(monitor_create_out.MonitorObject, &mut arrival_out)?; + } + + // Record the OS target id + render-adapter LUID for the ADD IOCTL reply. + { + let mut lock = MONITOR_MODES + .lock() + .map_err(|_| anyhow!("Failed to lock mutex"))?; + if let Some(mon) = lock.iter_mut().find(|m| m.data.id == index) { + mon.target_id = arrival_out.OsTargetId; + mon.adapter_luid_low = arrival_out.OsAdapterLuid.LowPart; + mon.adapter_luid_high = arrival_out.OsAdapterLuid.HighPart; + } + } + + Ok(()) + } +} + +impl MonitorContext { + pub fn new(device: IDDCX_MONITOR) -> Self { + Self { + device, + swap_chain_processor: None, + } + } + + pub fn assign_swap_chain( + &mut self, + swap_chain: IDDCX_SWAPCHAIN, + render_adapter: LUID, + new_frame_event: HANDLE, + ) { + // drop processing thread + drop(self.swap_chain_processor.take()); + + // transmute would work, but one less unsafe block, so why not + let luid = windows::Win32::Foundation::LUID { + LowPart: render_adapter.LowPart, + HighPart: render_adapter.HighPart, + }; + + // Log which GPU the OS picked to render this virtual monitor (useful on a hybrid iGPU+dGPU box, + // where the render adapter determines which adapter the host's capture must enumerate). + info!( + "swap-chain assigned: OS render adapter LUID = {:08x}:{:08x}", + render_adapter.HighPart, render_adapter.LowPart + ); + + let device = Direct3DDevice::init(luid); + + if let Ok(device) = device { + let mut processor = SwapChainProcessor::new(); + + processor.run(swap_chain, device, new_frame_event); + + self.swap_chain_processor = Some(processor); + + self.setup_hw_cursor(); + } else { + // It's important to delete the swap-chain if D3D initialization fails, so that the OS knows to generate a new + // swap-chain and try again. + error!("Direct3DDevice::init FAILED on render LUID: {device:?} — deleting swap chain for OS retry"); + + unsafe { + let _ = WdfObjectDelete(swap_chain.cast()); + } + } + } + + pub fn unassign_swap_chain(&mut self) { + self.swap_chain_processor.take(); + } + + pub fn setup_hw_cursor(&mut self) { + let mouse_event = unsafe { CreateEventA(None, false, false, s!("vdd_mouse_event")) }; + let Ok(mouse_event) = mouse_event else { + error!("CreateEventA failed: {mouse_event:?}"); + return; + }; + + // setup hardware cursor + let cursor_info = IDDCX_CURSOR_CAPS { + #[allow(clippy::cast_possible_truncation)] + Size: std::mem::size_of::() as u32, + AlphaCursorSupport: TRUE.0, + MaxX: 512, + MaxY: 512, + ColorXorCursorSupport: IDDCX_XOR_CURSOR_SUPPORT::IDDCX_XOR_CURSOR_SUPPORT_NONE, + }; + + let hw_cursor = IDARG_IN_SETUP_HWCURSOR { + CursorInfo: cursor_info, + hNewCursorDataAvailable: mouse_event.0, + }; + + let res = unsafe { IddCxMonitorSetupHardwareCursor(self.device, &hw_cursor) }; + let Ok(res) = res else { + error!("IddCxMonitorSetupHardwareCursor() failed: {res:?}"); + return; + }; + + if res.is_warning() { + warn!("IddCxMonitorSetupHardwareCursor() warn: {res:?}"); + } + if res.is_error() { + error!("IddCxMonitorSetupHardwareCursor() failed: {res:?}"); + } + } +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/control.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/control.rs new file mode 100644 index 0000000..8a3c63f --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/control.rs @@ -0,0 +1,339 @@ +//! SudoVDA-compatible IOCTL control plane (`EVT_IDD_CX_DEVICE_IO_CONTROL`). The host's +//! `vdisplay/sudovda.rs` drives this unchanged: ADD a monitor at a requested mode → `{LUID, target_id}`, +//! REMOVE by GUID, PING the watchdog, GET_VERSION/GET_WATCHDOG, SET_RENDER_ADAPTER. Struct layouts are +//! byte-identical to `Common/Include/sudovda-ioctl.h`. + +use std::ffi::c_void; +use std::mem::size_of; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::thread; +use std::time::Duration; + +use log::{error, info}; +use wdf_umdf::{ + IddCxAdapterSetRenderAdapter, IddCxMonitorDeparture, WdfRequestCompleteWithInformation, + WdfRequestRetrieveInputBuffer, WdfRequestRetrieveOutputBuffer, +}; +use wdf_umdf_sys::{IDARG_IN_ADAPTERSETRENDERADAPTER, LUID, NTSTATUS, WDFDEVICE, WDFREQUEST}; + +use crate::context::DeviceContext; +use crate::monitor::{ + default_modes, Mode, MonitorData, MonitorObject, ADAPTER, MONITOR_MODES, NEXT_ID, + PREFERRED_RENDER_ADAPTER, PROTOCOL_VERSION, WATCHDOG_COUNTDOWN, WATCHDOG_TIMEOUT, +}; + +// CTL_CODE(FILE_DEVICE_UNKNOWN=0x22, func, METHOD_BUFFERED=0, FILE_ANY_ACCESS=0). +const fn ctl(func: u32) -> u32 { + (0x22u32 << 16) | (func << 2) +} +const IOCTL_ADD: u32 = ctl(0x800); +const IOCTL_REMOVE: u32 = ctl(0x801); +const IOCTL_SET_RENDER_ADAPTER: u32 = ctl(0x802); +const IOCTL_GET_WATCHDOG: u32 = ctl(0x803); +const IOCTL_PING: u32 = ctl(0x888); +const IOCTL_GET_VERSION: u32 = ctl(0x8FF); + +#[repr(C)] +struct AddParams { + width: u32, + height: u32, + refresh: u32, + guid: [u8; 16], + device_name: [u8; 14], + serial: [u8; 14], +} +#[repr(C)] +struct AddOut { + luid_low: u32, + luid_high: i32, + target_id: u32, +} +#[repr(C)] +struct RemoveParams { + guid: [u8; 16], +} +#[repr(C)] +struct SetRenderAdapterParams { + luid_low: u32, + luid_high: i32, +} +#[repr(C)] +struct WatchdogOut { + timeout: u32, + countdown: u32, +} + +fn guid_key(b: &[u8; 16]) -> u128 { + u128::from_le_bytes(*b) +} + +/// SAFETY: `request` valid; returns a pointer to the request's input buffer of at least `min` bytes. +unsafe fn input_buf(request: WDFREQUEST, min: usize) -> Option<*const u8> { + let mut p: *mut c_void = std::ptr::null_mut(); + let mut len: usize = 0; + let r = unsafe { WdfRequestRetrieveInputBuffer(request, min, &mut p, &mut len) }; + if r.is_err() || p.is_null() || len < min { + return None; + } + Some(p.cast::()) +} + +/// SAFETY: `request` valid; returns a pointer to the request's output buffer of at least `min` bytes. +unsafe fn output_buf(request: WDFREQUEST, min: usize) -> Option<*mut u8> { + let mut p: *mut c_void = std::ptr::null_mut(); + let mut len: usize = 0; + let r = unsafe { WdfRequestRetrieveOutputBuffer(request, min, &mut p, &mut len) }; + if r.is_err() || p.is_null() || len < min { + return None; + } + Some(p.cast::()) +} + +/// `EVT_IDD_CX_DEVICE_IO_CONTROL` — IddCx redirects device IOCTLs here. Signature matches SudoVDA's +/// `SudoVDAIoDeviceControl(Device, Request, OutputBufferLength, InputBufferLength, IoControlCode)`. +pub extern "C-unwind" fn device_io_control( + device: WDFDEVICE, + request: WDFREQUEST, + output_len: usize, + input_len: usize, + ioctl_code: u32, +) { + // Reset the watchdog on any IOCTL except the watchdog query (the host PINGs to keep alive). + if ioctl_code != IOCTL_GET_WATCHDOG { + WATCHDOG_COUNTDOWN.store(WATCHDOG_TIMEOUT.load(Ordering::Relaxed), Ordering::Relaxed); + } + + let mut bytes: usize = 0; + // SAFETY: dispatch reads/writes the request buffers it validated; `device` is the IddCx device. + let status = unsafe { + match ioctl_code { + IOCTL_ADD => do_add(device, request, input_len, output_len, &mut bytes), + IOCTL_REMOVE => do_remove(request, input_len), + IOCTL_SET_RENDER_ADAPTER => do_set_render_adapter(request, input_len), + IOCTL_GET_WATCHDOG => do_get_watchdog(request, output_len, &mut bytes), + IOCTL_PING => NTSTATUS::STATUS_SUCCESS, + IOCTL_GET_VERSION => do_get_version(request, output_len, &mut bytes), + _ => NTSTATUS::STATUS_INVALID_DEVICE_REQUEST, + } + }; + + // SAFETY: completing the request we were handed. + let _ = unsafe { WdfRequestCompleteWithInformation(request, status, bytes as u64) }; +} + +unsafe fn do_add( + device: WDFDEVICE, + request: WDFREQUEST, + input_len: usize, + output_len: usize, + bytes: &mut usize, +) -> NTSTATUS { + if input_len < size_of::() || output_len < size_of::() { + return NTSTATUS::STATUS_BUFFER_TOO_SMALL; + } + let (Some(pin), Some(pout)) = ( + unsafe { input_buf(request, size_of::()) }, + unsafe { output_buf(request, size_of::()) }, + ) else { + return NTSTATUS::STATUS_BUFFER_TOO_SMALL; + }; + let params = unsafe { &*pin.cast::() }; + let guid = guid_key(¶ms.guid); + + // Dedup: an existing GUID returns its LUID + target id (the host may re-ADD on reconnect). + { + let lock = MONITOR_MODES.lock().unwrap(); + if let Some(mon) = lock.iter().find(|m| m.guid == guid) { + let out = AddOut { + luid_low: mon.adapter_luid_low, + luid_high: mon.adapter_luid_high, + target_id: mon.target_id, + }; + unsafe { pout.cast::().write_unaligned(out) }; + *bytes = size_of::(); + return NTSTATUS::STATUS_SUCCESS; + } + } + + if params.width == 0 || params.height == 0 || params.refresh == 0 { + return NTSTATUS::STATUS_INVALID_PARAMETER; + } + + let id = NEXT_ID.fetch_add(1, Ordering::Relaxed); + // Requested mode first (preferred), then fallbacks. + let mut modes = vec![Mode { + width: params.width, + height: params.height, + refresh_rates: vec![params.refresh], + }]; + modes.extend(default_modes()); + MONITOR_MODES.lock().unwrap().push(MonitorObject { + object: None, + data: MonitorData { id, modes }, + guid, + target_id: 0, + adapter_luid_low: 0, + adapter_luid_high: 0, + }); + + // Create the IddCx monitor via the device context (captures target id + LUID into the entry). + let created = unsafe { + DeviceContext::get_mut(device.cast(), |ctx| { + if let Err(e) = ctx.create_monitor(id) { + error!("ADD: create_monitor failed: {e:?}"); + } + }) + }; + + let lock = MONITOR_MODES.lock().unwrap(); + let mon = lock.iter().find(|m| m.data.id == id); + if created.is_err() || mon.map_or(true, |m| m.object.is_none()) { + drop(lock); + MONITOR_MODES.lock().unwrap().retain(|m| m.data.id != id); + error!("ADD: monitor {id} failed to arrive"); + return NTSTATUS::STATUS_UNSUCCESSFUL; + } + let mon = mon.unwrap(); + let out = AddOut { + luid_low: mon.adapter_luid_low, + luid_high: mon.adapter_luid_high, + target_id: mon.target_id, + }; + unsafe { pout.cast::().write_unaligned(out) }; + *bytes = size_of::(); + info!( + "ADD {}x{}@{} -> target_id={} luid={:08x}:{:08x}", + params.width, params.height, params.refresh, mon.target_id, mon.adapter_luid_high, mon.adapter_luid_low + ); + NTSTATUS::STATUS_SUCCESS +} + +unsafe fn do_remove(request: WDFREQUEST, input_len: usize) -> NTSTATUS { + if input_len < size_of::() { + return NTSTATUS::STATUS_BUFFER_TOO_SMALL; + } + let Some(pin) = (unsafe { input_buf(request, size_of::()) }) else { + return NTSTATUS::STATUS_BUFFER_TOO_SMALL; + }; + let params = unsafe { &*pin.cast::() }; + let guid = guid_key(¶ms.guid); + + let mut lock = MONITOR_MODES.lock().unwrap(); + if let Some(pos) = lock.iter().position(|m| m.guid == guid) { + let mon = lock.remove(pos); + if let Some(obj) = mon.object { + if let Err(e) = unsafe { IddCxMonitorDeparture(obj.as_ptr()) } { + error!("REMOVE: departure failed: {e:?}"); + } + } + info!("REMOVE target_id={}", mon.target_id); + NTSTATUS::STATUS_SUCCESS + } else { + NTSTATUS::STATUS_NOT_FOUND + } +} + +unsafe fn do_set_render_adapter(request: WDFREQUEST, input_len: usize) -> NTSTATUS { + if input_len < size_of::() { + return NTSTATUS::STATUS_BUFFER_TOO_SMALL; + } + let Some(pin) = (unsafe { input_buf(request, size_of::()) }) else { + return NTSTATUS::STATUS_BUFFER_TOO_SMALL; + }; + let params = unsafe { &*pin.cast::() }; + PREFERRED_RENDER_ADAPTER.store( + ((params.luid_high as u32 as u64) << 32) | u64::from(params.luid_low), + Ordering::Relaxed, + ); + if let Some(adapter) = ADAPTER.get() { + let in_args = IDARG_IN_ADAPTERSETRENDERADAPTER { + PreferredRenderAdapter: LUID { + LowPart: params.luid_low, + HighPart: params.luid_high, + }, + }; + if let Err(e) = unsafe { IddCxAdapterSetRenderAdapter(adapter.0.as_ptr(), &in_args) } { + error!("SET_RENDER_ADAPTER failed: {e:?}"); + } + } + NTSTATUS::STATUS_SUCCESS +} + +unsafe fn do_get_watchdog(request: WDFREQUEST, output_len: usize, bytes: &mut usize) -> NTSTATUS { + if output_len < size_of::() { + return NTSTATUS::STATUS_BUFFER_TOO_SMALL; + } + let Some(pout) = (unsafe { output_buf(request, size_of::()) }) else { + return NTSTATUS::STATUS_BUFFER_TOO_SMALL; + }; + let out = WatchdogOut { + timeout: WATCHDOG_TIMEOUT.load(Ordering::Relaxed), + countdown: WATCHDOG_COUNTDOWN.load(Ordering::Relaxed), + }; + unsafe { pout.cast::().write_unaligned(out) }; + *bytes = size_of::(); + NTSTATUS::STATUS_SUCCESS +} + +unsafe fn do_get_version(request: WDFREQUEST, output_len: usize, bytes: &mut usize) -> NTSTATUS { + if output_len < PROTOCOL_VERSION.len() { + return NTSTATUS::STATUS_BUFFER_TOO_SMALL; + } + let Some(pout) = (unsafe { output_buf(request, PROTOCOL_VERSION.len()) }) else { + return NTSTATUS::STATUS_BUFFER_TOO_SMALL; + }; + unsafe { std::ptr::copy_nonoverlapping(PROTOCOL_VERSION.as_ptr(), pout, PROTOCOL_VERSION.len()) }; + *bytes = PROTOCOL_VERSION.len(); + NTSTATUS::STATUS_SUCCESS +} + +/// Tear down every monitor (watchdog expiry — the host is gone). Mirrors SudoVDA's DisconnectAllMonitors. +fn disconnect_all_monitors() { + let mut lock = MONITOR_MODES.lock().unwrap(); + if lock.is_empty() { + return; + } + for mon in lock.drain(..) { + if let Some(obj) = mon.object { + // SAFETY: `obj` is a live IddCx monitor object. + if let Err(e) = unsafe { IddCxMonitorDeparture(obj.as_ptr()) } { + error!("watchdog: monitor departure failed: {e:?}"); + } + } + } +} + +/// Start the watchdog thread (once). The host reads the timeout via GET_WATCHDOG and PINGs every +/// timeout/3; if it stops, the countdown reaches 0 and every monitor is torn down — so a crashed/gone +/// host never leaves a phantom display. Mirrors SudoVDA's RunWatchdog. +pub fn start_watchdog() { + static STARTED: AtomicBool = AtomicBool::new(false); + if STARTED.swap(true, Ordering::Relaxed) { + return; + } + let timeout = WATCHDOG_TIMEOUT.load(Ordering::Relaxed); + if timeout == 0 { + return; + } + WATCHDOG_COUNTDOWN.store(timeout, Ordering::Relaxed); + thread::spawn(|| loop { + thread::sleep(Duration::from_secs(1)); + // Nothing to guard while there are no monitors. + if MONITOR_MODES.lock().unwrap().is_empty() { + continue; + } + let prev = WATCHDOG_COUNTDOWN.load(Ordering::Relaxed); + if prev == 0 { + continue; + } + // Decrement without clobbering a concurrent IOCTL reset (CAS). + if WATCHDOG_COUNTDOWN + .compare_exchange(prev, prev - 1, Ordering::Relaxed, Ordering::Relaxed) + .is_ok() + && prev - 1 == 0 + { + error!("watchdog expired (host stopped pinging) — tearing down all monitors"); + disconnect_all_monitors(); + } + }); +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/direct_3d_device.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/direct_3d_device.rs new file mode 100644 index 0000000..80280aa --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/direct_3d_device.rs @@ -0,0 +1,77 @@ +use windows::{ + core::Error, + Win32::{ + Foundation::LUID, + Graphics::{ + Direct3D::D3D_DRIVER_TYPE_UNKNOWN, + Direct3D11::{ + D3D11CreateDevice, ID3D11Device, ID3D11DeviceContext, + D3D11_CREATE_DEVICE_BGRA_SUPPORT, + D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY, + D3D11_CREATE_DEVICE_SINGLETHREADED, D3D11_SDK_VERSION, + }, + Dxgi::{CreateDXGIFactory2, IDXGIAdapter1, IDXGIFactory5, DXGI_CREATE_FACTORY_FLAGS}, + }, + }, +}; + +#[derive(thiserror::Error, Debug)] +pub enum Direct3DError { + #[error("Direct3DError({0:?})")] + Win32(#[from] Error), + #[error("Direct3DError(\"{0}\")")] + Other(&'static str), +} + +impl From<&'static str> for Direct3DError { + fn from(value: &'static str) -> Self { + Direct3DError::Other(value) + } +} + +#[derive(Debug)] +pub struct Direct3DDevice { + // The following are already refcounted, so they're safe to use directly without additional drop impls + _dxgi_factory: IDXGIFactory5, + _adapter: IDXGIAdapter1, + pub device: ID3D11Device, + _device_context: ID3D11DeviceContext, +} + +impl Direct3DDevice { + pub fn init(adapter_luid: LUID) -> Result { + let dxgi_factory = + unsafe { CreateDXGIFactory2::(DXGI_CREATE_FACTORY_FLAGS(0))? }; + + let adapter = unsafe { dxgi_factory.EnumAdapterByLuid::(adapter_luid)? }; + + let mut device = None; + let mut device_context = None; + + unsafe { + D3D11CreateDevice( + &adapter, + D3D_DRIVER_TYPE_UNKNOWN, + None, + D3D11_CREATE_DEVICE_BGRA_SUPPORT + | D3D11_CREATE_DEVICE_SINGLETHREADED + | D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY, + None, + D3D11_SDK_VERSION, + Some(&mut device), + None, + Some(&mut device_context), + )?; + } + + let device = device.ok_or("ID3D11Device not found")?; + let device_context = device_context.ok_or("ID3D11DeviceContext not found")?; + + Ok(Self { + _dxgi_factory: dxgi_factory, + _adapter: adapter, + device, + _device_context: device_context, + }) + } +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/edid.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/edid.rs new file mode 100644 index 0000000..8387cb4 --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/edid.rs @@ -0,0 +1,114 @@ +use std::{array::TryFromSliceError, ops::Deref}; + +use bytemuck::{Pod, Zeroable}; + +// A clean, self-contained 128-byte EDID carrying punktfunk's own identity — manufacturer ID "PNK" +// (bytes 8-9) and product name "punktfunk" (the 0xFC display-descriptor). Derived from the +// virtual-display-rs base block (a standard, widely-deployed virtual EDID); it deliberately carries NO +// other driver's bytes or branding. The serial-number field (offset 0x0C) encodes the per-monitor +// index, so `parse_monitor_description` can map an EDID the OS hands back to its monitor; +// `generate_with` patches that serial and `gen_checksum` recomputes byte 127 before the EDID reaches +// IddCx. The detailed-timing / range-limit descriptors are placeholders: the modes we actually +// advertise come from the monitor's stored mode list (`monitor.rs` / `callbacks.rs`), not from parsing +// this EDID. +const _EDID: [u8; 128] = [ + 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x41, 0xCB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0x21, 0x01, 0x03, 0x80, 0x32, 0x1F, 0x78, 0x07, 0xEE, 0x95, 0xA3, 0x54, 0x4C, 0x99, 0x26, + 0x0F, 0x50, 0x54, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3A, 0x80, 0x18, 0x71, 0x38, 0x2D, 0x40, 0x58, 0x2C, + 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0xFD, 0x00, 0x17, 0xF0, 0x0F, + 0xFF, 0x0F, 0x00, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x70, + 0x75, 0x6E, 0x6B, 0x74, 0x66, 0x75, 0x6E, 0x6B, 0x0A, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +]; + +const EDID_LEN: usize = _EDID.len(); + +static EDID: AlignedEdid = AlignedEdid { + data: _EDID, + _align: [], +}; + +#[repr(C)] +struct AlignedEdid { + data: [u8; N], + // required to make this type aligned to Edid + _align: [Edid; 0], +} + +impl AlignedEdid { + fn new(data: &[u8]) -> Result { + let data: [u8; N] = data.try_into()?; + Ok(Self { data, _align: [] }) + } +} + +impl Deref for AlignedEdid { + type Target = Edid; + + fn deref(&self) -> &Self::Target { + let header = &self.data[..EDID_SIZE]; + bytemuck::from_bytes(header) + } +} + +const EDID_SIZE: usize = std::mem::size_of::(); + +#[repr(C)] +#[derive(Debug, Copy, Clone, Pod, Zeroable)] +pub struct Edid { + header: [u8; 8], + manufacturer_id: [u8; 2], + product_code: u16, + serial_number: u32, + manufacture_week: u8, + manufacture_year: u8, + version: u8, + revision: u8, +} + +impl Edid { + pub fn generate_with(serial: u32) -> Vec { + // change serial number in the header + let mut header = *EDID; + header.serial_number = serial; + + header.generate() + } + + pub fn get_serial(edid: &[u8]) -> Result { + let edid = AlignedEdid::::new(edid)?; + Ok(edid.serial_number) + } + + fn generate(&self) -> Vec { + let header = bytemuck::bytes_of(self); + + // slice of monitor edid minus header + let data = &EDID.data[EDID_SIZE..]; + + // splice together header and the rest of the EDID + let mut edid: Vec = header.iter().chain(data).copied().collect(); + // regenerate checksum + Self::gen_checksum(&mut edid); + + edid + } + + fn gen_checksum(data: &mut [u8]) { + // important, this is the bare minimum length + assert!(data.len() >= 128); + + // slice to the entire data minus the last checksum byte + let edid_data = &data[..=126]; + + // do checksum calculation + let sum: u32 = edid_data.iter().copied().map(u32::from).sum(); + // this wont ever truncate + #[allow(clippy::cast_possible_truncation)] + let checksum = (256 - (sum % 256)) as u8; + + // update last byte with new checksum + data[127] = checksum; + } +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/entry.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/entry.rs new file mode 100644 index 0000000..93e616e --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/entry.rs @@ -0,0 +1,119 @@ +//! Driver entry + WDF device-add. Adapted from virtual-display-rs (its event-log/boot-retry logger +//! dance is replaced by the `OutputDebugString` logger in `logger.rs`). + +use log::{error, info}; +use wdf_umdf::{ + IddCxDeviceInitConfig, IddCxDeviceInitialize, WdfDeviceCreate, WdfDeviceCreateDeviceInterface, + WdfDeviceInitSetPnpPowerEventCallbacks, WdfDriverCreate, +}; +use wdf_umdf_sys::{ + GUID, IDD_CX_CLIENT_CONFIG, NTSTATUS, WDFDEVICE_INIT, WDFDRIVER__, WDFOBJECT, WDF_DRIVER_CONFIG, + WDF_OBJECT_ATTRIBUTES, WDF_PNPPOWER_EVENT_CALLBACKS, _DRIVER_OBJECT, _UNICODE_STRING, +}; + +use crate::callbacks::{ + adapter_commit_modes, adapter_init_finished, assign_swap_chain, device_d0_entry, + monitor_get_default_modes, monitor_query_modes, parse_monitor_description, unassign_swap_chain, +}; +use crate::context::DeviceContext; +use crate::control::device_io_control; + +// SudoVDA control-interface GUID — the host opens this to drive the ADD/REMOVE/PING IOCTLs. +// {e5bcc234-1e0c-418a-a0d4-ef8b7501414d} +const SUVDA_INTERFACE_GUID: GUID = GUID { + Data1: 0xe5bc_c234, + Data2: 0x1e0c, + Data3: 0x418a, + Data4: [0xa0, 0xd4, 0xef, 0x8b, 0x75, 0x01, 0x41, 0x4d], +}; + +/// Driver entry point (called by the framework via `FxDriverEntryUm`). +#[no_mangle] +extern "C-unwind" fn DriverEntry( + driver_object: *mut _DRIVER_OBJECT, + registry_path: *mut _UNICODE_STRING, +) -> NTSTATUS { + crate::logger::init(); + crate::panic::set_hook(); + info!("pf-vdisplay v{} starting", env!("CARGO_PKG_VERSION")); + + let mut attributes = WDF_OBJECT_ATTRIBUTES::init(); + let mut config = WDF_DRIVER_CONFIG::init(Some(driver_add)); + + unsafe { + WdfDriverCreate( + driver_object, + registry_path, + Some(&mut attributes), + &mut config, + None, + ) + } + .into() +} + +extern "C-unwind" fn driver_add( + _driver: *mut WDFDRIVER__, + mut init: *mut WDFDEVICE_INIT, +) -> NTSTATUS { + let mut callbacks = WDF_PNPPOWER_EVENT_CALLBACKS::init(); + callbacks.EvtDeviceD0Entry = Some(device_d0_entry); + + unsafe { + _ = WdfDeviceInitSetPnpPowerEventCallbacks(init, &mut callbacks); + } + + let Some(mut config) = IDD_CX_CLIENT_CONFIG::init() else { + error!("Failed to create IDD_CX_CLIENT_CONFIG"); + return NTSTATUS::STATUS_NOT_FOUND; + }; + + config.EvtIddCxAdapterInitFinished = Some(adapter_init_finished); + config.EvtIddCxParseMonitorDescription = Some(parse_monitor_description); + config.EvtIddCxMonitorGetDefaultDescriptionModes = Some(monitor_get_default_modes); + config.EvtIddCxMonitorQueryTargetModes = Some(monitor_query_modes); + config.EvtIddCxAdapterCommitModes = Some(adapter_commit_modes); + config.EvtIddCxMonitorAssignSwapChain = Some(assign_swap_chain); + config.EvtIddCxMonitorUnassignSwapChain = Some(unassign_swap_chain); + // IddCx redirects device IOCTLs to this callback — our SudoVDA-compatible control plane. + config.EvtIddCxDeviceIoControl = Some(device_io_control); + + let init_data = unsafe { &mut *init }; + let status = unsafe { IddCxDeviceInitConfig(init_data, &config) }; + if let Err(e) = status { + error!("Failed to init iddcx config: {e:?}"); + return e.into(); + } + + let mut attributes = + WDF_OBJECT_ATTRIBUTES::init_context_type(unsafe { DeviceContext::get_type_info() }); + attributes.EvtCleanupCallback = Some(event_cleanup); + + let mut device = std::ptr::null_mut(); + let status = unsafe { WdfDeviceCreate(&mut init, Some(&mut attributes), &mut device) }; + if let Err(e) = status { + error!("Failed to create device: {e:?}"); + return e.into(); + } + + // Register the SudoVDA control interface so the host can open it + send the control IOCTLs. + let status = + unsafe { WdfDeviceCreateDeviceInterface(device, &SUVDA_INTERFACE_GUID, std::ptr::null()) }; + if let Err(e) = status { + error!("Failed to create control device interface: {e:?}"); + return e.into(); + } + + let status = unsafe { IddCxDeviceInitialize(device) }; + if let Err(e) = status { + error!("Failed to init iddcx device: {e:?}"); + return e.into(); + } + + let context = DeviceContext::new(device); + unsafe { context.init(device as WDFOBJECT).into() } +} + +unsafe extern "C-unwind" fn event_cleanup(wdf_object: WDFOBJECT) { + _ = unsafe { DeviceContext::drop(wdf_object) }; +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/helpers.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/helpers.rs new file mode 100644 index 0000000..dd5e114 --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/helpers.rs @@ -0,0 +1,38 @@ +use std::ops::{Deref, DerefMut}; + +/// An unsafe wrapper to allow sending across threads +/// +/// USE WISELY, IT CAN CAUSE UB OTHERWISE +pub struct Sendable(T); +unsafe impl Send for Sendable {} +unsafe impl Sync for Sendable {} + +impl Sendable { + /// `T` must be Send+Sync safe + pub unsafe fn new(t: T) -> Self { + Sendable(t) + } +} + +impl Deref for Sendable { + type Target = T; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for Sendable { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +#[macro_export] +macro_rules! debug { + ($($tt:tt)*) => { + if cfg!(debug_assertions) { + ::log::debug!($($tt)*); + } + }; +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/lib.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/lib.rs new file mode 100644 index 0000000..4d0f5b1 --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/lib.rs @@ -0,0 +1,33 @@ +//! pf-vdisplay — punktfunk Windows virtual display (IddCx), in Rust. +//! +//! P1: a UMDF2 IddCx virtual display. Adapted from MolotovCherry/virtual-display-rs (MIT) — its +//! named-pipe IPC + serde mode config is replaced by an in-tree `monitor` model (and, next, the +//! SudoVDA-compatible IOCTL control plane our host already speaks). Logging goes to +//! `OutputDebugString` (no `log`-eventlog/`tokio`). See `docs/windows-virtual-display-rust-port.md`. +#![allow(non_snake_case)] + +mod callbacks; +mod context; +mod control; +mod direct_3d_device; +mod edid; +mod entry; +mod helpers; +mod logger; +mod monitor; +mod panic; +mod swap_chain_processor; + +use wdf_umdf_sys::{NTSTATUS, PUNICODE_STRING, PVOID}; + +// The framework entry point. UMDF's reflector calls this; the `+whole-archive` stub forwards to the +// `DriverEntry` symbol exported from `entry.rs`. +#[link(name = "WdfDriverStubUm", kind = "static", modifiers = "+whole-archive")] +extern "C" { + pub fn FxDriverEntryUm( + LoaderInterface: PVOID, + Context: PVOID, + DriverObject: PVOID, + RegistryPath: PUNICODE_STRING, + ) -> NTSTATUS; +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/logger.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/logger.rs new file mode 100644 index 0000000..9e251c2 --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/logger.rs @@ -0,0 +1,34 @@ +//! Minimal `log` backend that writes to `OutputDebugString` — no `driver-logger`/event-log/`tokio`. +//! View with DebugView/WinDbg. Keeping the `log` facade lets the ported callbacks/context use +//! `error!`/`info!`/`debug!` unchanged. + +use log::{LevelFilter, Metadata, Record}; +use windows::core::PCSTR; +use windows::Win32::System::Diagnostics::Debug::OutputDebugStringA; + +struct DbgLogger; + +impl log::Log for DbgLogger { + fn enabled(&self, _metadata: &Metadata) -> bool { + true + } + + fn log(&self, record: &Record) { + let msg = format!("[pf-vdisplay] {:<5} {}\0", record.level(), record.args()); + // SAFETY: `msg` is a NUL-terminated byte string valid for the call. + unsafe { OutputDebugStringA(PCSTR(msg.as_ptr())) }; + } + + fn flush(&self) {} +} + +static LOGGER: DbgLogger = DbgLogger; + +pub fn init() { + let _ = log::set_logger(&LOGGER); + log::set_max_level(if cfg!(debug_assertions) { + LevelFilter::Debug + } else { + LevelFilter::Info + }); +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/monitor.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/monitor.rs new file mode 100644 index 0000000..dad10ab --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/monitor.rs @@ -0,0 +1,103 @@ +//! The monitor + mode model and control-plane state. Replaces virtual-display-rs's `ipc.rs` +//! (named-pipe IPC + serde `driver_ipc` types). Monitors are created on demand by the SudoVDA IOCTL +//! control plane (`control.rs`); each carries the GUID the host keys it by plus the OS target id + +//! render-adapter LUID captured at arrival (the ADD reply). + +use std::ptr::NonNull; +use std::sync::atomic::{AtomicU32, AtomicU64}; +use std::sync::{Mutex, OnceLock}; + +use wdf_umdf_sys::{IDDCX_ADAPTER__, IDDCX_MONITOR__}; + +pub type Dimen = u32; +pub type RefreshRate = u32; + +/// One resolution with the refresh rates it supports. +#[derive(Clone, PartialEq, Eq)] +pub struct Mode { + pub width: Dimen, + pub height: Dimen, + pub refresh_rates: Vec, +} + +/// A monitor's identity (the EDID serial) + advertised modes. +#[derive(Clone)] +pub struct MonitorData { + pub id: u32, + pub modes: Vec, +} + +/// A live (or pending) monitor. +pub struct MonitorObject { + pub object: Option>, + pub data: MonitorData, + /// The full GUID the host keys this monitor by (ADD dedup / REMOVE). + pub guid: u128, + /// OS target id + render-adapter LUID, captured from `IDARG_OUT_MONITORARRIVAL` (the ADD reply). + pub target_id: u32, + pub adapter_luid_low: u32, + pub adapter_luid_high: i32, +} +// SAFETY: the raw IddCx object ptr is framework-managed; access is serialized by MONITOR_MODES. +unsafe impl Send for MonitorObject {} +unsafe impl Sync for MonitorObject {} + +/// The IddCx adapter object, stashed for the control plane (SET_RENDER_ADAPTER). +pub struct AdapterObject(pub NonNull); +// SAFETY: raw ptr managed by the framework. +unsafe impl Send for AdapterObject {} +unsafe impl Sync for AdapterObject {} + +pub static ADAPTER: OnceLock = OnceLock::new(); +pub static MONITOR_MODES: Mutex> = Mutex::new(Vec::new()); + +/// Monitor id / EDID-serial counter (unique per created monitor). +pub static NEXT_ID: AtomicU32 = AtomicU32::new(1); +/// Watchdog (seconds). The host reads the timeout via GET_WATCHDOG and PINGs to keep alive. +pub static WATCHDOG_TIMEOUT: AtomicU32 = AtomicU32::new(3); +pub static WATCHDOG_COUNTDOWN: AtomicU32 = AtomicU32::new(3); +/// The preferred render adapter LUID set via SET_RENDER_ADAPTER, packed `(high<<32)|low`. 0 = none. +pub static PREFERRED_RENDER_ADAPTER: AtomicU64 = AtomicU64::new(0); + +/// Protocol version reported by GET_VERSION: {major, minor, incremental, testbuild} — matches SudoVDA. +pub const PROTOCOL_VERSION: [u8; 4] = [0, 2, 1, 1]; + +/// A single (width, height, refresh) tuple — modes flattened across their refresh rates. +#[derive(Copy, Clone)] +pub struct ModeItem { + pub width: Dimen, + pub height: Dimen, + pub refresh_rate: RefreshRate, +} + +pub trait FlattenModes { + fn flatten(&self) -> impl Iterator; +} + +impl FlattenModes for Vec { + fn flatten(&self) -> impl Iterator { + self.iter().flat_map(|m| { + m.refresh_rates.iter().map(|&rr| ModeItem { + width: m.width, + height: m.height, + refresh_rate: rr, + }) + }) + } +} + +/// Fallback modes appended after the client's requested mode, so a topology change still has options. +pub fn default_modes() -> Vec { + vec![ + Mode { + width: 1920, + height: 1080, + refresh_rates: vec![60, 120], + }, + Mode { + width: 1280, + height: 720, + refresh_rates: vec![60], + }, + ] +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/panic.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/panic.rs new file mode 100644 index 0000000..a5967fa --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/panic.rs @@ -0,0 +1,20 @@ +#[cfg(debug_assertions)] +use std::backtrace::Backtrace; +use std::panic; + +use log::error; + +pub fn set_hook() { + panic::set_hook(Box::new(|v| { + // debug mode, get full backtrace + #[cfg(debug_assertions)] + { + let backtrace = Backtrace::force_capture(); + error!("{v}\n\nstack backtrace:\n{backtrace}"); + } + + // otherwise just print the panic since we don't have a backtrace + #[cfg(not(debug_assertions))] + error!("{v}"); + })); +} diff --git a/packaging/windows/vdisplay-driver/pf-vdisplay/src/swap_chain_processor.rs b/packaging/windows/vdisplay-driver/pf-vdisplay/src/swap_chain_processor.rs new file mode 100644 index 0000000..de038be --- /dev/null +++ b/packaging/windows/vdisplay-driver/pf-vdisplay/src/swap_chain_processor.rs @@ -0,0 +1,158 @@ +use std::{ + sync::{ + atomic::{AtomicBool, Ordering}, + Arc, + }, + thread::{self, JoinHandle}, +}; + +use log::{debug, error}; +use wdf_umdf::{ + IddCxSwapChainFinishedProcessingFrame, IddCxSwapChainReleaseAndAcquireBuffer, + IddCxSwapChainSetDevice, WdfObjectDelete, +}; +use wdf_umdf_sys::{ + HANDLE, IDARG_IN_SWAPCHAINSETDEVICE, IDARG_OUT_RELEASEANDACQUIREBUFFER, IDDCX_SWAPCHAIN, + NTSTATUS, WAIT_TIMEOUT, WDFOBJECT, +}; +use windows::{ + core::{w, Interface}, + Win32::{ + Foundation::HANDLE as WHANDLE, + Graphics::Dxgi::IDXGIDevice, + System::Threading::{ + AvRevertMmThreadCharacteristics, AvSetMmThreadCharacteristicsW, WaitForSingleObject, + }, + }, +}; + +use crate::{direct_3d_device::Direct3DDevice, helpers::Sendable}; + +pub struct SwapChainProcessor { + terminate: Arc, + thread: Option>, +} + +unsafe impl Send for SwapChainProcessor {} +unsafe impl Sync for SwapChainProcessor {} + +impl SwapChainProcessor { + pub fn new() -> Self { + Self { + terminate: Arc::new(AtomicBool::new(false)), + thread: None, + } + } + + pub fn run( + &mut self, + swap_chain: IDDCX_SWAPCHAIN, + device: Direct3DDevice, + available_buffer_event: HANDLE, + ) { + let available_buffer_event = unsafe { Sendable::new(available_buffer_event) }; + let swap_chain = unsafe { Sendable::new(swap_chain) }; + let terminate = self.terminate.clone(); + + let join_handle = thread::spawn(move || { + // It is very important to prioritize this thread by making use of the Multimedia Scheduler Service. + // It will intelligently prioritize the thread for improved throughput in high CPU-load scenarios. + let mut av_task = 0u32; + let res = unsafe { AvSetMmThreadCharacteristicsW(w!("Distribution"), &mut av_task) }; + let Ok(av_handle) = res else { + error!("Failed to prioritize thread: {res:?}"); + return; + }; + + Self::run_core(*swap_chain, &device, *available_buffer_event, &terminate); + + let res = unsafe { WdfObjectDelete(*swap_chain as WDFOBJECT) }; + if let Err(e) = res { + error!("Failed to delete wdf object: {e:?}"); + return; + } + + // Revert the thread to normal once it's done + let res = unsafe { AvRevertMmThreadCharacteristics(av_handle) }; + if let Err(e) = res { + error!("Failed to revert prioritize thread: {e:?}"); + } + }); + + self.thread = Some(join_handle); + } + + fn run_core( + swap_chain: IDDCX_SWAPCHAIN, + device: &Direct3DDevice, + available_buffer_event: HANDLE, + terminate: &AtomicBool, + ) { + let dxgi_device = device.device.cast::(); + let Ok(dxgi_device) = dxgi_device else { + error!("Failed to cast ID3D11Device to IDXGIDevice: {dxgi_device:?}"); + return; + }; + + let set_device = IDARG_IN_SWAPCHAINSETDEVICE { + pDevice: dxgi_device.into_raw().cast(), + }; + + let res = unsafe { IddCxSwapChainSetDevice(swap_chain, &set_device) }; + if res.is_err() { + debug!("Failed to set swapchain device: {res:?}"); + return; + } + + loop { + let mut buffer = IDARG_OUT_RELEASEANDACQUIREBUFFER::default(); + let hr: NTSTATUS = + unsafe { IddCxSwapChainReleaseAndAcquireBuffer(swap_chain, &mut buffer).into() }; + + #[allow(clippy::items_after_statements)] + const E_PENDING: u32 = 0x8000_000A; + if u32::from(hr) == E_PENDING { + let wait_result = + unsafe { WaitForSingleObject(WHANDLE(available_buffer_event.cast()), 16).0 }; + + // thread requested an end + let should_terminate = terminate.load(Ordering::Relaxed); + if should_terminate { + break; + } + + // WAIT_OBJECT_0 | WAIT_TIMEOUT + if matches!(wait_result, 0 | WAIT_TIMEOUT) { + // We have a new buffer, so try the AcquireBuffer again + continue; + } + + // The wait was cancelled or something unexpected happened + break; + } else if hr.is_success() { + // This is the most performance-critical section of code in an IddCx driver. It's important that whatever + // is done with the acquired surface be finished as quickly as possible. + let hr = unsafe { IddCxSwapChainFinishedProcessingFrame(swap_chain) }; + + if hr.is_err() { + break; + } + } else { + // The swap-chain was likely abandoned (e.g. DXGI_ERROR_ACCESS_LOST), so exit the processing loop + break; + } + } + } +} + +impl Drop for SwapChainProcessor { + fn drop(&mut self) { + if let Some(handle) = self.thread.take() { + // send signal to end thread + self.terminate.store(true, Ordering::Relaxed); + + // wait until thread is finished + _ = handle.join(); + } + } +} diff --git a/packaging/windows/vdisplay-driver/rust-toolchain.toml b/packaging/windows/vdisplay-driver/rust-toolchain.toml new file mode 100644 index 0000000..1829850 --- /dev/null +++ b/packaging/windows/vdisplay-driver/rust-toolchain.toml @@ -0,0 +1,4 @@ +[toolchain] +channel = "nightly-2024-07-26" +components = ["rustfmt", "clippy"] +profile = "minimal" diff --git a/packaging/windows/vdisplay-driver/wdf-umdf-sys/Cargo.toml b/packaging/windows/vdisplay-driver/wdf-umdf-sys/Cargo.toml new file mode 100644 index 0000000..d4649fa --- /dev/null +++ b/packaging/windows/vdisplay-driver/wdf-umdf-sys/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "wdf-umdf-sys" +version = "0.1.0" +edition = "2021" + +[lints] +workspace = true + +[dependencies] +paste = "1.0.15" +bytemuck = "1.19.0" +thiserror = "2.0.3" + +[build-dependencies] +bindgen = "0.70.1" +thiserror = "2.0.3" +winreg = "0.52.0" diff --git a/packaging/windows/vdisplay-driver/wdf-umdf-sys/build.rs b/packaging/windows/vdisplay-driver/wdf-umdf-sys/build.rs new file mode 100644 index 0000000..5641363 --- /dev/null +++ b/packaging/windows/vdisplay-driver/wdf-umdf-sys/build.rs @@ -0,0 +1,275 @@ +use std::env; +use std::fmt::{self, Display}; +use std::path::{Path, PathBuf}; + +use bindgen::Abi; +use winreg::enums::HKEY_LOCAL_MACHINE; +use winreg::RegKey; + +const UMDF_V: &str = "2.31"; +const IDDCX_V: &str = "1.4"; + +#[derive(Debug, thiserror::Error)] +enum Error { + #[error(transparent)] + IoError(#[from] std::io::Error), + #[error("cannot find the directory")] + DirectoryNotFound, +} + +/// Retrieves the path to the Windows Kits directory. The default should be +/// `C:\Program Files (x86)\Windows Kits\10`. +/// +/// # Errors +/// Returns IO error if failed +fn get_windows_kits_dir() -> Result { + let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); + let key = r"SOFTWARE\Microsoft\Windows Kits\Installed Roots"; + let dir: String = hklm.open_subkey(key)?.get_value("KitsRoot10")?; + + Ok(dir.into()) +} + +#[derive(Clone, Copy, PartialEq)] +enum DirectoryType { + Include, + Library, +} + +#[derive(Clone, Copy, PartialEq)] +enum Target { + X86_64, + ARM64, +} + +impl Default for Target { + fn default() -> Self { + let target = env::var("CARGO_CFG_TARGET_ARCH").unwrap(); + match &*target { + "x86_64" => Self::X86_64, + "aarch64" => Self::ARM64, + _ => unimplemented!("{target} arch is unsupported"), + } + } +} + +impl Display for Target { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Target::X86_64 => f.write_str("x64"), + Target::ARM64 => f.write_str("arm64"), + } + } +} + +fn get_base_path>(dir_type: DirectoryType, subs: &[S]) -> Result { + let mut dir = get_windows_kits_dir()?.join(match dir_type { + DirectoryType::Include => "Include", + DirectoryType::Library => "Lib", + }); + + dir.extend(subs); + if !dir.is_dir() { + return Err(Error::DirectoryNotFound); + } + + Ok(dir) +} + +fn get_sdk_path>(dir_type: DirectoryType, subs: &[S]) -> Result { + // We first append lib to the path and read the directory.. + let dir = get_windows_kits_dir()? + .join(match dir_type { + DirectoryType::Include => "Include", + DirectoryType::Library => "Lib", + }) + .read_dir()?; + + // In the lib directory we may have one or more directories named after the version of Windows, + // we will be looking for the highest version number. + let mut dir = dir + .filter_map(Result::ok) + .map(|dir| dir.path()) + .filter(|dir| { + let is_sdk = dir + .components() + .last() + .and_then(|c| c.as_os_str().to_str()) + .map_or(false, |c| c.starts_with("10.")); + + let mut sub_dir = dir.clone(); + sub_dir.extend(subs); + + is_sdk && sub_dir.is_dir() + }) + .max() + .ok_or_else(|| Error::DirectoryNotFound)?; + + dir.extend(subs); + if !dir.is_dir() { + return Err(Error::DirectoryNotFound); + } + + // Finally append um to the path to get the path to the user mode libraries. + Ok(dir) +} + +/// Retrieves the path to the user mode libraries. The path may look something like: +/// `C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\um`. +/// +/// # Errors +/// Returns IO error if failed +fn get_um_dir(dir_type: DirectoryType) -> Result { + let target = Target::default().to_string(); + + let binding = &["um", &target]; + let subs: &[&str] = match dir_type { + DirectoryType::Include => &["um"], + DirectoryType::Library => binding, + }; + + let dir = get_sdk_path(dir_type, subs)?; + Ok(dir) +} + +/// # Errors +/// Returns IO error if failed +fn get_umdf_dir(dir_type: DirectoryType) -> Result { + match dir_type { + DirectoryType::Include => get_base_path(dir_type, &["wdf", "umdf", UMDF_V]), + DirectoryType::Library => get_base_path( + dir_type, + &["wdf", "umdf", &Target::default().to_string(), UMDF_V], + ), + } +} + +/// Retrieves the path to the shared headers. The path may look something like: +/// `C:\Program Files (x86)\Windows Kits\10\lib\10.0.18362.0\shared`. +/// +/// # Errors +/// Returns IO error if failed +fn get_shared_dir() -> Result { + let dir = get_sdk_path(DirectoryType::Include, &["shared"])?; + Ok(dir) +} + +fn build_dir() -> PathBuf { + PathBuf::from( + std::env::var_os("OUT_DIR").expect("the environment variable OUT_DIR is undefined"), + ) +} + +fn generate() { + // Find the include directory containing the user headers. + let include_um_dir = get_um_dir(DirectoryType::Include).unwrap(); + let lib_um_dir = get_um_dir(DirectoryType::Library).unwrap(); + let shared = get_shared_dir().unwrap(); + + println!("cargo:rustc-link-search={}", lib_um_dir.display()); + + // Tell Cargo to re-run this if src/wrapper.h gets changed. + println!("cargo:rerun-if-changed=c/wrapper.h"); + + // + // UMDF + // + + let umdf_lib_dir = get_umdf_dir(DirectoryType::Library).unwrap(); + + println!("cargo:rustc-link-search={}", umdf_lib_dir.display()); + + let wdf_include_dir = get_umdf_dir(DirectoryType::Include).unwrap(); + + // need to link to umdf lib + println!("cargo:rustc-link-lib=static=WdfDriverStubUm"); + + // + // IDDCX + // + + // The IddCx import lib lives only under the WDK's SDK version (e.g. 10.0.26100.0); a newer base + // SDK installed alongside it (e.g. 10.0.28000.0) has um\x64 but no iddcx subdir, so picking the + // max um\x64 version (lib_um_dir) misses it. Resolve by the version that actually contains + // iddcx — the same way the IddCx.h header path is resolved below. + let iddcx_lib_dir = get_sdk_path( + DirectoryType::Library, + &["um", &Target::default().to_string(), "iddcx", IDDCX_V], + ) + .unwrap(); + + println!("cargo:rustc-link-search={}", iddcx_lib_dir.display()); + + // need to link to iddcx lib + println!("cargo:rustc-link-lib=static=IddCxStub"); + + // + // REST + // + + // Get the build directory. + let out_path = build_dir(); + + // Generate the bindings + let mut builder = bindgen::Builder::default() + .derive_debug(false) + .layout_tests(false) + .default_enum_style(bindgen::EnumVariation::NewType { + is_bitfield: false, + is_global: false, + }) + .merge_extern_blocks(true) + .header("c/wrapper.h") + .header( + get_sdk_path(DirectoryType::Include, &["um", "iddcx", IDDCX_V]) + .unwrap() + .join("IddCx.h") + .to_string_lossy() + .to_string(), + ) + // general um includes + .clang_arg(format!("-I{}", include_um_dir.display())) + // umdf includes + .clang_arg(format!("-I{}", wdf_include_dir.display())) + .clang_arg(format!("-I{}", shared.display())) + // because aarch64 needs to find excpt.h + .clang_arg(format!( + "-I{}", + get_sdk_path(DirectoryType::Include, &["km", "crt"]) + .unwrap() + .display() + )) + .parse_callbacks(Box::new(bindgen::CargoCallbacks::new())) + .blocklist_type("_?P?IMAGE_TLS_DIRECTORY.*") + // we will use our own custom type + .blocklist_item("NTSTATUS") + .blocklist_item("IddMinimumVersionRequired") + .blocklist_item("WdfMinimumVersionRequired") + .clang_arg("--language=c++") + .clang_arg("-fms-compatibility") + .clang_arg("-fms-extensions") + .override_abi(Abi::CUnwind, ".*") + .generate_cstr(true) + .derive_default(true); + + let defines = match Target::default() { + Target::X86_64 => ["AMD64", "_AMD64_"], + Target::ARM64 => ["ARM64", "_ARM64_"], + }; + + for define in defines { + builder = builder.clang_arg(format!("-D{define}")); + } + + // generate + let umdf = builder.generate().unwrap(); + + // Write the bindings to the $OUT_DIR/bindings.rs file. + umdf.write_to_file(out_path.join("umdf.rs")).unwrap(); +} + +fn main() { + println!("cargo:rerun-if-changed=build.rs"); + + generate(); +} diff --git a/packaging/windows/vdisplay-driver/wdf-umdf-sys/c/wrapper.h b/packaging/windows/vdisplay-driver/wdf-umdf-sys/c/wrapper.h new file mode 100644 index 0000000..4aa00bd --- /dev/null +++ b/packaging/windows/vdisplay-driver/wdf-umdf-sys/c/wrapper.h @@ -0,0 +1,22 @@ +#include + +/** + * + * UMDF + * + */ + +#define WDF_STUB + +#include + +/** + * + * IDCXX + * + */ + +#define IDD_STUB + +// handled in build.rs +// #include diff --git a/packaging/windows/vdisplay-driver/wdf-umdf-sys/src/bindings.rs b/packaging/windows/vdisplay-driver/wdf-umdf-sys/src/bindings.rs new file mode 100644 index 0000000..4778287 --- /dev/null +++ b/packaging/windows/vdisplay-driver/wdf-umdf-sys/src/bindings.rs @@ -0,0 +1,17 @@ +#![allow(unsafe_op_in_unsafe_fn)] +#![allow(clippy::all)] +#![allow(clippy::pedantic)] +#![allow(clippy::restriction)] + +// stand-in type replacing NTSTATUS in the bindings +use crate::NTSTATUS; + +include!(concat!(env!("OUT_DIR"), "/umdf.rs")); + +// required for some macros +unsafe impl Send for _WDF_OBJECT_CONTEXT_TYPE_INFO {} +unsafe impl Sync for _WDF_OBJECT_CONTEXT_TYPE_INFO {} + +// fails to build without this symbol +#[no_mangle] +pub static IddMinimumVersionRequired: ULONG = 4; diff --git a/packaging/windows/vdisplay-driver/wdf-umdf-sys/src/lib.rs b/packaging/windows/vdisplay-driver/wdf-umdf-sys/src/lib.rs new file mode 100644 index 0000000..9840c9e --- /dev/null +++ b/packaging/windows/vdisplay-driver/wdf-umdf-sys/src/lib.rs @@ -0,0 +1,211 @@ +#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, unused)] + +mod bindings; +mod ntstatus; + +use std::fmt::{self, Display}; + +pub use bindings::*; +pub use ntstatus::*; +pub use paste::paste; + +#[macro_export] +macro_rules! WdfIsFunctionAvailable { + ($name:ident) => {{ + // SAFETY: We only ever do read access + let higher = unsafe { $crate::WdfClientVersionHigherThanFramework } != 0; + // SAFETY: We only ever do read access + let fn_count = unsafe { $crate::WdfFunctionCount }; + + // https://github.com/microsoft/Windows-Driver-Frameworks/blob/main/src/publicinc/wdf/umdf/2.33/wdffuncenum.h#L126 + $crate::paste! { + // index is always positive, see + // https://github.com/microsoft/Windows-Driver-Frameworks/blob/main/src/publicinc/wdf/umdf/2.33/wdffuncenum.h + const FN_INDEX: u32 = $crate::WDFFUNCENUM::[<$name TableIndex>].0 as u32; + + FN_INDEX < $crate::WDF_ALWAYS_AVAILABLE_FUNCTION_COUNT + || !higher || FN_INDEX < fn_count + } + }}; +} + +#[macro_export] +macro_rules! WdfIsStructureAvailable { + ($name:ident) => {{ + // SAFETY: We only ever do read access + let higher = unsafe { $crate::WdfClientVersionHigherThanFramework } != 0; + // SAFETY: We only ever do read access + let struct_count = unsafe { $crate::WdfStructureCount }; + + // https://github.com/microsoft/Windows-Driver-Frameworks/blob/main/src/publicinc/wdf/umdf/2.33/wdffuncenum.h#L141 + $crate::paste! { + // index is always positive, see + // https://github.com/microsoft/Windows-Driver-Frameworks/blob/main/src/publicinc/wdf/umdf/2.33/wdffuncenum.h + const STRUCT_INDEX: u32 = $crate::WDFSTRUCTENUM::[].0 as u32; + + !higher || STRUCT_INDEX < struct_count + } + }}; +} + +#[macro_export] +macro_rules! IddCxIsFunctionAvailable { + ($name:ident) => {{ + // SAFETY: We only ever do read access + let higher = unsafe { $crate::IddClientVersionHigherThanFramework } != 0; + // SAFETY: We only ever do read access + let fn_count = unsafe { $crate::IddFunctionCount }; + + $crate::paste! { + const FN_INDEX: u32 = $crate::IDDFUNCENUM::[<$name TableIndex>].0 as u32; + + FN_INDEX < $crate::IDD_ALWAYS_AVAILABLE_FUNCTION_COUNT + || !higher || FN_INDEX < fn_count + } + }}; +} + +#[macro_export] +macro_rules! IddCxIsStructureAvailable { + ($name:ident) => {{ + // SAFETY: We only ever do read access + let higher = unsafe { $crate::IddClientVersionHigherThanFramework } != 0; + // SAFETY: We only ever do read access + let struct_count = unsafe { $crate::IddStructureCount }; + + $crate::paste! { + const STRUCT_INDEX: u32 = $crate::IDDSTRUCTENUM::[].0 as u32; + + !higher || STRUCT_INDEX < struct_count + } + }}; +} + +macro_rules! WDF_STRUCTURE_SIZE { + ($name:ty) => { + u32::try_from(::core::mem::size_of::<$name>()).expect("size is correct") + }; +} + +#[macro_export] +macro_rules! WDF_NO_HANDLE { + () => { + ::core::ptr::null_mut() + }; +} + +#[macro_export] +macro_rules! WDF_NO_OBJECT_ATTRIBUTES { + () => { + ::core::ptr::null_mut() + }; +} + +#[macro_export] +macro_rules! WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE { + ($attr:ident, $context_type:ident) => { + $attr.ContextTypeInfo = $context_type; + }; +} + +impl WDF_OBJECT_ATTRIBUTES { + /// Initializes the [`WDF_OBJECT_ATTRIBUTES`] structure + /// + /// + /// Sets + /// - `ExecutionLevel` to [`WDF_SYNCHRONIZATION_SCOPE::WdfSynchronizationScopeInheritFromParent`] + /// - `SynchronizationScope` to [`WDF_EXECUTION_LEVEL::WdfExecutionLevelInheritFromParent`] + #[must_use] + pub fn init() -> Self { + // SAFETY: All fields are zero-able + let mut attributes: Self = unsafe { ::core::mem::zeroed() }; + + attributes.Size = WDF_STRUCTURE_SIZE!(Self); + attributes.SynchronizationScope = + WDF_SYNCHRONIZATION_SCOPE::WdfSynchronizationScopeInheritFromParent; + attributes.ExecutionLevel = WDF_EXECUTION_LEVEL::WdfExecutionLevelInheritFromParent; + + attributes + } + + #[must_use] + pub fn init_context_type(context_type: &_WDF_OBJECT_CONTEXT_TYPE_INFO) -> Self { + let mut attr = Self::init(); + + WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE!(attr, context_type); + + attr + } +} + +impl WDF_DRIVER_CONFIG { + /// Initializes the [`WDF_DRIVER_CONFIG`] structure + /// + #[must_use] + pub fn init(EvtDriverDeviceAdd: PFN_WDF_DRIVER_DEVICE_ADD) -> Self { + // SAFETY: All fields are zero-able + let mut config: Self = unsafe { core::mem::zeroed() }; + + config.Size = WDF_STRUCTURE_SIZE!(Self); + + config.EvtDriverDeviceAdd = EvtDriverDeviceAdd; + + config + } +} + +impl WDF_PNPPOWER_EVENT_CALLBACKS { + /// Initializes the [`WDF_PNPPOWER_EVENT_CALLBACKS`] structure + /// + #[must_use] + pub fn init() -> Self { + // SAFETY: All fields are zero-able + let mut callbacks: Self = unsafe { core::mem::zeroed() }; + callbacks.Size = WDF_STRUCTURE_SIZE!(Self); + + callbacks + } +} + +/// If this returns None, the struct is NOT available to be used +macro_rules! IDD_STRUCTURE_SIZE { + ($name:ty) => {{ + // SAFETY: We only ever do read access, copy is fine + let higher = unsafe { IddClientVersionHigherThanFramework } != 0; + // SAFETY: We only ever do read access, copy is fine + let struct_count = unsafe { IddStructureCount }; + + if higher { + // as u32 is fine, since there's no way there's > 4 billion structs + const STRUCT_INDEX: u32 = + $crate::paste! { IDDSTRUCTENUM::[].0 as u32 }; + + // SAFETY: A pointer to a [size_t], copying the pointer is ok + let ptr = unsafe { IddStructures }; + + if STRUCT_INDEX < struct_count { + // SAFETY: we validated struct index is able to be accessed + let ptr = unsafe { ptr.add(STRUCT_INDEX as usize) }; + // SAFETY: So it's ok to read + u32::try_from(unsafe { ptr.read() }).ok() + } else { + // struct CANNOT be used + None + } + } else { + u32::try_from(::std::mem::size_of::<$name>()).ok() + } + }}; +} + +impl IDD_CX_CLIENT_CONFIG { + #[must_use] + pub fn init() -> Option { + // SAFETY: All fields are zero-able + let mut config: Self = unsafe { core::mem::zeroed() }; + + config.Size = IDD_STRUCTURE_SIZE!(IDD_CX_CLIENT_CONFIG)?; + + Some(config) + } +} diff --git a/packaging/windows/vdisplay-driver/wdf-umdf-sys/src/ntstatus.rs b/packaging/windows/vdisplay-driver/wdf-umdf-sys/src/ntstatus.rs new file mode 100644 index 0000000..dadd2f3 --- /dev/null +++ b/packaging/windows/vdisplay-driver/wdf-umdf-sys/src/ntstatus.rs @@ -0,0 +1,2789 @@ +use std::fmt::{self, Display}; + +/// A NTSTATUS wrapper that gives information on the value +#[repr(transparent)] +#[derive(Copy, Clone, Debug, PartialEq)] +pub struct NTSTATUS(pub i32); + +impl NTSTATUS { + // + // https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/using-ntstatus-values + // + + // NT_SUCCESS + #[allow(clippy::manual_range_patterns)] + #[must_use] + pub fn is_success(&self) -> bool { + let val = bytemuck::cast::<_, u32>(self.0); + // NT_SUCCESS | NT_INFORMATION + matches!(val, 0..=0x3FFF_FFFF | 0x4000_0000..=0x7FFF_FFFF) + } + + // NT_INFORMATION + #[must_use] + pub fn is_information(&self) -> bool { + let val = bytemuck::cast::<_, u32>(self.0); + matches!(val, 0x4000_0000..=0x7FFF_FFFF) + } + + // NT_WARNING + #[must_use] + pub fn is_warning(&self) -> bool { + let val = bytemuck::cast::<_, u32>(self.0); + matches!(val, 0x8000_0000..=0xBFFF_FFFF) + } + + // NT_ERROR + #[must_use] + pub fn is_error(&self) -> bool { + let val = bytemuck::cast::<_, u32>(self.0); + matches!(val, 0xC000_0000..=0xFFFF_FFFF) + } +} + +impl std::error::Error for NTSTATUS {} + +impl Display for NTSTATUS { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { + write!(f, "0x{:X}", self.0) + } +} + +impl From<()> for NTSTATUS { + fn from(value: ()) -> Self { + Self(Self::STATUS_SUCCESS.0) + } +} + +impl From for NTSTATUS { + fn from(value: i32) -> Self { + Self(value) + } +} + +impl From for NTSTATUS { + fn from(value: u32) -> Self { + let value = bytemuck::cast(value); + Self(value) + } +} + +impl From for u32 { + fn from(value: NTSTATUS) -> Self { + bytemuck::cast(value.0) + } +} + +impl From for i32 { + fn from(value: NTSTATUS) -> Self { + value.0 + } +} + +impl, E: Into> From> for NTSTATUS { + fn from(value: Result) -> Self { + match value { + Ok(r) => r.into(), + Err(e) => e.into(), + } + } +} + +#[rustfmt::skip] +impl NTSTATUS { + pub const STATUS_ABANDONED: NTSTATUS = NTSTATUS(128i32); + pub const STATUS_ABANDONED_WAIT_0: NTSTATUS = NTSTATUS(128i32); + pub const STATUS_ABANDONED_WAIT_63: NTSTATUS = NTSTATUS(191i32); + pub const STATUS_ABANDON_HIBERFILE: NTSTATUS = NTSTATUS(1_073_741_875_i32); + pub const STATUS_ABIOS_INVALID_COMMAND: NTSTATUS = NTSTATUS(-1_073_741_549_i32); + pub const STATUS_ABIOS_INVALID_LID: NTSTATUS = NTSTATUS(-1_073_741_548_i32); + pub const STATUS_ABIOS_INVALID_SELECTOR: NTSTATUS = NTSTATUS(-1_073_741_546_i32); + pub const STATUS_ABIOS_LID_ALREADY_OWNED: NTSTATUS = NTSTATUS(-1_073_741_551_i32); + pub const STATUS_ABIOS_LID_NOT_EXIST: NTSTATUS = NTSTATUS(-1_073_741_552_i32); + pub const STATUS_ABIOS_NOT_LID_OWNER: NTSTATUS = NTSTATUS(-1_073_741_550_i32); + pub const STATUS_ABIOS_NOT_PRESENT: NTSTATUS = NTSTATUS(-1_073_741_553_i32); + pub const STATUS_ABIOS_SELECTOR_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_073_741_547_i32); + pub const STATUS_ACCESS_AUDIT_BY_POLICY: NTSTATUS = NTSTATUS(1_073_741_874_i32); + pub const STATUS_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_073_741_790_i32); + pub const STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT: NTSTATUS = NTSTATUS(-1_073_740_959_i32); + pub const STATUS_ACCESS_DISABLED_BY_POLICY_OTHER: NTSTATUS = NTSTATUS(-1_073_740_956_i32); + pub const STATUS_ACCESS_DISABLED_BY_POLICY_PATH: NTSTATUS = NTSTATUS(-1_073_740_958_i32); + pub const STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER: NTSTATUS = NTSTATUS(-1_073_740_957_i32); + pub const STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY: NTSTATUS = NTSTATUS(-1_073_740_942_i32); + pub const STATUS_ACCESS_VIOLATION: NTSTATUS = NTSTATUS(-1_073_741_819_i32); + pub const STATUS_ACPI_ACQUIRE_GLOBAL_LOCK: NTSTATUS = NTSTATUS(-1_072_431_086_i32); + pub const STATUS_ACPI_ADDRESS_NOT_MAPPED: NTSTATUS = NTSTATUS(-1_072_431_092_i32); + pub const STATUS_ACPI_ALREADY_INITIALIZED: NTSTATUS = NTSTATUS(-1_072_431_085_i32); + pub const STATUS_ACPI_ASSERT_FAILED: NTSTATUS = NTSTATUS(-1_072_431_101_i32); + pub const STATUS_ACPI_FATAL: NTSTATUS = NTSTATUS(-1_072_431_098_i32); + pub const STATUS_ACPI_HANDLER_COLLISION: NTSTATUS = NTSTATUS(-1_072_431_090_i32); + pub const STATUS_ACPI_INCORRECT_ARGUMENT_COUNT: NTSTATUS = NTSTATUS(-1_072_431_093_i32); + pub const STATUS_ACPI_INVALID_ACCESS_SIZE: NTSTATUS = NTSTATUS(-1_072_431_087_i32); + pub const STATUS_ACPI_INVALID_ARGTYPE: NTSTATUS = NTSTATUS(-1_072_431_096_i32); + pub const STATUS_ACPI_INVALID_ARGUMENT: NTSTATUS = NTSTATUS(-1_072_431_099_i32); + pub const STATUS_ACPI_INVALID_DATA: NTSTATUS = NTSTATUS(-1_072_431_089_i32); + pub const STATUS_ACPI_INVALID_EVENTTYPE: NTSTATUS = NTSTATUS(-1_072_431_091_i32); + pub const STATUS_ACPI_INVALID_INDEX: NTSTATUS = NTSTATUS(-1_072_431_100_i32); + pub const STATUS_ACPI_INVALID_MUTEX_LEVEL: NTSTATUS = NTSTATUS(-1_072_431_083_i32); + pub const STATUS_ACPI_INVALID_OBJTYPE: NTSTATUS = NTSTATUS(-1_072_431_095_i32); + pub const STATUS_ACPI_INVALID_OPCODE: NTSTATUS = NTSTATUS(-1_072_431_103_i32); + pub const STATUS_ACPI_INVALID_REGION: NTSTATUS = NTSTATUS(-1_072_431_088_i32); + pub const STATUS_ACPI_INVALID_SUPERNAME: NTSTATUS = NTSTATUS(-1_072_431_097_i32); + pub const STATUS_ACPI_INVALID_TABLE: NTSTATUS = NTSTATUS(-1_072_431_079_i32); + pub const STATUS_ACPI_INVALID_TARGETTYPE: NTSTATUS = NTSTATUS(-1_072_431_094_i32); + pub const STATUS_ACPI_MUTEX_NOT_OWNED: NTSTATUS = NTSTATUS(-1_072_431_082_i32); + pub const STATUS_ACPI_MUTEX_NOT_OWNER: NTSTATUS = NTSTATUS(-1_072_431_081_i32); + pub const STATUS_ACPI_NOT_INITIALIZED: NTSTATUS = NTSTATUS(-1_072_431_084_i32); + pub const STATUS_ACPI_POWER_REQUEST_FAILED: NTSTATUS = NTSTATUS(-1_072_431_071_i32); + pub const STATUS_ACPI_REG_HANDLER_FAILED: NTSTATUS = NTSTATUS(-1_072_431_072_i32); + pub const STATUS_ACPI_RS_ACCESS: NTSTATUS = NTSTATUS(-1_072_431_080_i32); + pub const STATUS_ACPI_STACK_OVERFLOW: NTSTATUS = NTSTATUS(-1_072_431_102_i32); + pub const STATUS_ADAPTER_HARDWARE_ERROR: NTSTATUS = NTSTATUS(-1_073_741_630_i32); + pub const STATUS_ADDRESS_ALREADY_ASSOCIATED: NTSTATUS = NTSTATUS(-1_073_741_256_i32); + pub const STATUS_ADDRESS_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1_073_741_302_i32); + pub const STATUS_ADDRESS_CLOSED: NTSTATUS = NTSTATUS(-1_073_741_301_i32); + pub const STATUS_ADDRESS_NOT_ASSOCIATED: NTSTATUS = NTSTATUS(-1_073_741_255_i32); + pub const STATUS_ADMINLESS_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_073_700_348_i32); + pub const STATUS_ADVANCED_INSTALLER_FAILED: NTSTATUS = NTSTATUS(-1_072_365_536_i32); + pub const STATUS_AGENTS_EXHAUSTED: NTSTATUS = NTSTATUS(-1_073_741_691_i32); + pub const STATUS_ALERTED: NTSTATUS = NTSTATUS(257i32); + pub const STATUS_ALIAS_EXISTS: NTSTATUS = NTSTATUS(-1_073_741_484_i32); + pub const STATUS_ALLOCATE_BUCKET: NTSTATUS = NTSTATUS(-1_073_741_265_i32); + pub const STATUS_ALLOTTED_SPACE_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_671_i32); + pub const STATUS_ALL_SIDS_FILTERED: NTSTATUS = NTSTATUS(-1_073_740_962_i32); + pub const STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_740_798_i32); + pub const STATUS_ALPC_CHECK_COMPLETION_LIST: NTSTATUS = NTSTATUS(1_073_741_872_i32); + pub const STATUS_ALREADY_COMMITTED: NTSTATUS = NTSTATUS(-1_073_741_791_i32); + pub const STATUS_ALREADY_COMPLETE: NTSTATUS = NTSTATUS(255i32); + pub const STATUS_ALREADY_DISCONNECTED: NTSTATUS = NTSTATUS(-2_147_483_611_i32); + pub const STATUS_ALREADY_HAS_STREAM_ID: NTSTATUS = NTSTATUS(-1_073_740_530_i32); + pub const STATUS_ALREADY_INITIALIZED: NTSTATUS = NTSTATUS(-1_073_740_528_i32); + pub const STATUS_ALREADY_REGISTERED: NTSTATUS = NTSTATUS(-1_073_740_008_i32); + pub const STATUS_ALREADY_WIN32: NTSTATUS = NTSTATUS(1_073_741_851_i32); + pub const STATUS_AMBIGUOUS_SYSTEM_DEVICE: NTSTATUS = NTSTATUS(-1_073_740_719_i32); + pub const STATUS_APC_RETURNED_WHILE_IMPERSONATING: NTSTATUS = NTSTATUS(-1_073_740_015_i32); + pub const STATUS_APISET_NOT_HOSTED: NTSTATUS = NTSTATUS(-1_073_740_671_i32); + pub const STATUS_APISET_NOT_PRESENT: NTSTATUS = NTSTATUS(-1_073_740_670_i32); + pub const STATUS_APPEXEC_APP_COMPAT_BLOCK: NTSTATUS = NTSTATUS(-1_058_275_320_i32); + pub const STATUS_APPEXEC_CALLER_WAIT_TIMEOUT: NTSTATUS = NTSTATUS(-1_058_275_319_i32); + pub const STATUS_APPEXEC_CALLER_WAIT_TIMEOUT_LICENSING: NTSTATUS = NTSTATUS(-1_058_275_317_i32); + pub const STATUS_APPEXEC_CALLER_WAIT_TIMEOUT_RESOURCES: NTSTATUS = NTSTATUS(-1_058_275_316_i32); + pub const STATUS_APPEXEC_CALLER_WAIT_TIMEOUT_TERMINATION: NTSTATUS = NTSTATUS(-1_058_275_318_i32); + pub const STATUS_APPEXEC_CONDITION_NOT_SATISFIED: NTSTATUS = NTSTATUS(-1_058_275_328_i32); + pub const STATUS_APPEXEC_HANDLE_INVALIDATED: NTSTATUS = NTSTATUS(-1_058_275_327_i32); + pub const STATUS_APPEXEC_HOST_ID_MISMATCH: NTSTATUS = NTSTATUS(-1_058_275_322_i32); + pub const STATUS_APPEXEC_INVALID_HOST_GENERATION: NTSTATUS = NTSTATUS(-1_058_275_326_i32); + pub const STATUS_APPEXEC_INVALID_HOST_STATE: NTSTATUS = NTSTATUS(-1_058_275_324_i32); + pub const STATUS_APPEXEC_NO_DONOR: NTSTATUS = NTSTATUS(-1_058_275_323_i32); + pub const STATUS_APPEXEC_UNEXPECTED_PROCESS_REGISTRATION: NTSTATUS = NTSTATUS(-1_058_275_325_i32); + pub const STATUS_APPEXEC_UNKNOWN_USER: NTSTATUS = NTSTATUS(-1_058_275_321_i32); + pub const STATUS_APPHELP_BLOCK: NTSTATUS = NTSTATUS(-1_073_740_963_i32); + pub const STATUS_APPX_FILE_NOT_ENCRYPTED: NTSTATUS = NTSTATUS(-1_073_740_634_i32); + pub const STATUS_APPX_INTEGRITY_FAILURE_CLR_NGEN: NTSTATUS = NTSTATUS(-1_073_740_673_i32); + pub const STATUS_APP_DATA_CORRUPT: NTSTATUS = NTSTATUS(-1_073_700_221_i32); + pub const STATUS_APP_DATA_EXPIRED: NTSTATUS = NTSTATUS(-1_073_700_222_i32); + pub const STATUS_APP_DATA_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_700_220_i32); + pub const STATUS_APP_DATA_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_700_223_i32); + pub const STATUS_APP_DATA_REBOOT_REQUIRED: NTSTATUS = NTSTATUS(-1_073_700_219_i32); + pub const STATUS_APP_INIT_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_499_i32); + pub const STATUS_ARBITRATION_UNHANDLED: NTSTATUS = NTSTATUS(1_073_741_862_i32); + pub const STATUS_ARRAY_BOUNDS_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_684_i32); + pub const STATUS_ASSERTION_FAILURE: NTSTATUS = NTSTATUS(-1_073_740_768_i32); + pub const STATUS_ATTACHED_EXECUTABLE_MEMORY_WRITE: NTSTATUS = NTSTATUS(-1_073_739_995_i32); + pub const STATUS_ATTRIBUTE_NOT_PRESENT: NTSTATUS = NTSTATUS(-1_073_740_532_i32); + pub const STATUS_AUDIO_ENGINE_NODE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_069_285_375_i32); + pub const STATUS_AUDITING_DISABLED: NTSTATUS = NTSTATUS(-1_073_740_970_i32); + pub const STATUS_AUDIT_FAILED: NTSTATUS = NTSTATUS(-1_073_741_244_i32); + pub const STATUS_AUTHIP_FAILURE: NTSTATUS = NTSTATUS(-1_073_700_730_i32); + pub const STATUS_AUTH_TAG_MISMATCH: NTSTATUS = NTSTATUS(-1_073_700_862_i32); + pub const STATUS_BACKUP_CONTROLLER: NTSTATUS = NTSTATUS(-1_073_741_433_i32); + pub const STATUS_BAD_BINDINGS: NTSTATUS = NTSTATUS(-1_073_740_965_i32); + pub const STATUS_BAD_CLUSTERS: NTSTATUS = NTSTATUS(-1_073_739_771_i32); + pub const STATUS_BAD_COMPRESSION_BUFFER: NTSTATUS = NTSTATUS(-1_073_741_246_i32); + pub const STATUS_BAD_CURRENT_DIRECTORY: NTSTATUS = NTSTATUS(1_073_741_831_i32); + pub const STATUS_BAD_DATA: NTSTATUS = NTSTATUS(-1_073_739_509_i32); + pub const STATUS_BAD_DESCRIPTOR_FORMAT: NTSTATUS = NTSTATUS(-1_073_741_593_i32); + pub const STATUS_BAD_DEVICE_TYPE: NTSTATUS = NTSTATUS(-1_073_741_621_i32); + pub const STATUS_BAD_DLL_ENTRYPOINT: NTSTATUS = NTSTATUS(-1_073_741_231_i32); + pub const STATUS_BAD_FILE_TYPE: NTSTATUS = NTSTATUS(-1_073_739_517_i32); + pub const STATUS_BAD_FUNCTION_TABLE: NTSTATUS = NTSTATUS(-1_073_741_569_i32); + pub const STATUS_BAD_IMPERSONATION_LEVEL: NTSTATUS = NTSTATUS(-1_073_741_659_i32); + pub const STATUS_BAD_INHERITANCE_ACL: NTSTATUS = NTSTATUS(-1_073_741_699_i32); + pub const STATUS_BAD_INITIAL_PC: NTSTATUS = NTSTATUS(-1_073_741_814_i32); + pub const STATUS_BAD_INITIAL_STACK: NTSTATUS = NTSTATUS(-1_073_741_815_i32); + pub const STATUS_BAD_KEY: NTSTATUS = NTSTATUS(-1_073_739_510_i32); + pub const STATUS_BAD_LOGON_SESSION_STATE: NTSTATUS = NTSTATUS(-1_073_741_564_i32); + pub const STATUS_BAD_MASTER_BOOT_RECORD: NTSTATUS = NTSTATUS(-1_073_741_655_i32); + pub const STATUS_BAD_MCFG_TABLE: NTSTATUS = NTSTATUS(-1_073_739_512_i32); + pub const STATUS_BAD_NETWORK_NAME: NTSTATUS = NTSTATUS(-1_073_741_620_i32); + pub const STATUS_BAD_NETWORK_PATH: NTSTATUS = NTSTATUS(-1_073_741_634_i32); + pub const STATUS_BAD_REMOTE_ADAPTER: NTSTATUS = NTSTATUS(-1_073_741_627_i32); + pub const STATUS_BAD_SERVICE_ENTRYPOINT: NTSTATUS = NTSTATUS(-1_073_741_230_i32); + pub const STATUS_BAD_STACK: NTSTATUS = NTSTATUS(-1_073_741_784_i32); + pub const STATUS_BAD_TOKEN_TYPE: NTSTATUS = NTSTATUS(-1_073_741_656_i32); + pub const STATUS_BAD_VALIDATION_CLASS: NTSTATUS = NTSTATUS(-1_073_741_657_i32); + pub const STATUS_BAD_WORKING_SET_LIMIT: NTSTATUS = NTSTATUS(-1_073_741_748_i32); + pub const STATUS_BCD_NOT_ALL_ENTRIES_IMPORTED: NTSTATUS = NTSTATUS(-2_143_748_095_i32); + pub const STATUS_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED: NTSTATUS = NTSTATUS(-2_143_748_093_i32); + pub const STATUS_BCD_TOO_MANY_ELEMENTS: NTSTATUS = NTSTATUS(-1_070_006_270_i32); + pub const STATUS_BEGINNING_OF_MEDIA: NTSTATUS = NTSTATUS(-2_147_483_617_i32); + pub const STATUS_BEYOND_VDL: NTSTATUS = NTSTATUS(-1_073_740_750_i32); + pub const STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT: NTSTATUS = NTSTATUS(-1_073_741_458_i32); + pub const STATUS_BIZRULES_NOT_ENABLED: NTSTATUS = NTSTATUS(1_073_741_876_i32); + pub const STATUS_BLOCKED_BY_PARENTAL_CONTROLS: NTSTATUS = NTSTATUS(-1_073_740_664_i32); + pub const STATUS_BLOCK_SHARED: NTSTATUS = NTSTATUS(-1_073_739_499_i32); + pub const STATUS_BLOCK_SOURCE_WEAK_REFERENCE_INVALID: NTSTATUS = NTSTATUS(-1_073_739_501_i32); + pub const STATUS_BLOCK_TARGET_WEAK_REFERENCE_INVALID: NTSTATUS = NTSTATUS(-1_073_739_500_i32); + pub const STATUS_BLOCK_TOO_MANY_REFERENCES: NTSTATUS = NTSTATUS(-1_073_740_660_i32); + pub const STATUS_BLOCK_WEAK_REFERENCE_INVALID: NTSTATUS = NTSTATUS(-1_073_739_502_i32); + pub const STATUS_BREAKPOINT: NTSTATUS = NTSTATUS(-2_147_483_645_i32); + pub const STATUS_BTH_ATT_ATTRIBUTE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_069_416_438_i32); + pub const STATUS_BTH_ATT_ATTRIBUTE_NOT_LONG: NTSTATUS = NTSTATUS(-1_069_416_437_i32); + pub const STATUS_BTH_ATT_INSUFFICIENT_AUTHENTICATION: NTSTATUS = NTSTATUS(-1_069_416_443_i32); + pub const STATUS_BTH_ATT_INSUFFICIENT_AUTHORIZATION: NTSTATUS = NTSTATUS(-1_069_416_440_i32); + pub const STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION: NTSTATUS = NTSTATUS(-1_069_416_433_i32); + pub const STATUS_BTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE: NTSTATUS = NTSTATUS(-1_069_416_436_i32); + pub const STATUS_BTH_ATT_INSUFFICIENT_RESOURCES: NTSTATUS = NTSTATUS(-1_069_416_431_i32); + pub const STATUS_BTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH: NTSTATUS = NTSTATUS(-1_069_416_435_i32); + pub const STATUS_BTH_ATT_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1_069_416_447_i32); + pub const STATUS_BTH_ATT_INVALID_OFFSET: NTSTATUS = NTSTATUS(-1_069_416_441_i32); + pub const STATUS_BTH_ATT_INVALID_PDU: NTSTATUS = NTSTATUS(-1_069_416_444_i32); + pub const STATUS_BTH_ATT_PREPARE_QUEUE_FULL: NTSTATUS = NTSTATUS(-1_069_416_439_i32); + pub const STATUS_BTH_ATT_READ_NOT_PERMITTED: NTSTATUS = NTSTATUS(-1_069_416_446_i32); + pub const STATUS_BTH_ATT_REQUEST_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_069_416_442_i32); + pub const STATUS_BTH_ATT_UNKNOWN_ERROR: NTSTATUS = NTSTATUS(-1_069_412_352_i32); + pub const STATUS_BTH_ATT_UNLIKELY: NTSTATUS = NTSTATUS(-1_069_416_434_i32); + pub const STATUS_BTH_ATT_UNSUPPORTED_GROUP_TYPE: NTSTATUS = NTSTATUS(-1_069_416_432_i32); + pub const STATUS_BTH_ATT_WRITE_NOT_PERMITTED: NTSTATUS = NTSTATUS(-1_069_416_445_i32); + pub const STATUS_BUFFER_ALL_ZEROS: NTSTATUS = NTSTATUS(279i32); + pub const STATUS_BUFFER_OVERFLOW: NTSTATUS = NTSTATUS(-2_147_483_643_i32); + pub const STATUS_BUFFER_TOO_SMALL: NTSTATUS = NTSTATUS(-1_073_741_789_i32); + pub const STATUS_BUS_RESET: NTSTATUS = NTSTATUS(-2_147_483_619_i32); + pub const STATUS_BYPASSIO_FLT_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_590_i32); + pub const STATUS_CACHE_PAGE_LOCKED: NTSTATUS = NTSTATUS(277i32); + pub const STATUS_CALLBACK_BYPASS: NTSTATUS = NTSTATUS(-1_073_740_541_i32); + pub const STATUS_CALLBACK_INVOKE_INLINE: NTSTATUS = NTSTATUS(-1_073_740_661_i32); + pub const STATUS_CALLBACK_POP_STACK: NTSTATUS = NTSTATUS(-1_073_740_765_i32); + pub const STATUS_CALLBACK_RETURNED_LANG: NTSTATUS = NTSTATUS(-1_073_740_001_i32); + pub const STATUS_CALLBACK_RETURNED_LDR_LOCK: NTSTATUS = NTSTATUS(-1_073_740_002_i32); + pub const STATUS_CALLBACK_RETURNED_PRI_BACK: NTSTATUS = NTSTATUS(-1_073_740_000_i32); + pub const STATUS_CALLBACK_RETURNED_THREAD_AFFINITY: NTSTATUS = NTSTATUS(-1_073_739_999_i32); + pub const STATUS_CALLBACK_RETURNED_THREAD_PRIORITY: NTSTATUS = NTSTATUS(-1_073_740_005_i32); + pub const STATUS_CALLBACK_RETURNED_TRANSACTION: NTSTATUS = NTSTATUS(-1_073_740_003_i32); + pub const STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING: NTSTATUS = NTSTATUS(-1_073_740_016_i32); + pub const STATUS_CANCELLED: NTSTATUS = NTSTATUS(-1_073_741_536_i32); + pub const STATUS_CANNOT_ABORT_TRANSACTIONS: NTSTATUS = NTSTATUS(-1_072_103_347_i32); + pub const STATUS_CANNOT_ACCEPT_TRANSACTED_WORK: NTSTATUS = NTSTATUS(-1_072_103_348_i32); + pub const STATUS_CANNOT_BREAK_OPLOCK: NTSTATUS = NTSTATUS(-1_073_739_511_i32); + pub const STATUS_CANNOT_DELETE: NTSTATUS = NTSTATUS(-1_073_741_535_i32); + pub const STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1_072_103_356_i32); + pub const STATUS_CANNOT_GRANT_REQUESTED_OPLOCK: NTSTATUS = NTSTATUS(-2_147_483_602_i32); + pub const STATUS_CANNOT_IMPERSONATE: NTSTATUS = NTSTATUS(-1_073_741_555_i32); + pub const STATUS_CANNOT_LOAD_REGISTRY_FILE: NTSTATUS = NTSTATUS(-1_073_741_288_i32); + pub const STATUS_CANNOT_MAKE: NTSTATUS = NTSTATUS(-1_073_741_078_i32); + pub const STATUS_CANNOT_SWITCH_RUNLEVEL: NTSTATUS = NTSTATUS(-1_073_700_543_i32); + pub const STATUS_CANT_ACCESS_DOMAIN_INFO: NTSTATUS = NTSTATUS(-1_073_741_606_i32); + pub const STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY: NTSTATUS = NTSTATUS(-1_072_103_369_i32); + pub const STATUS_CANT_CLEAR_ENCRYPTION_FLAG: NTSTATUS = NTSTATUS(-1_073_740_616_i32); + pub const STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS: NTSTATUS = NTSTATUS(-1_072_103_386_i32); + pub const STATUS_CANT_CROSS_RM_BOUNDARY: NTSTATUS = NTSTATUS(-1_072_103_368_i32); + pub const STATUS_CANT_DISABLE_MANDATORY: NTSTATUS = NTSTATUS(-1_073_741_731_i32); + pub const STATUS_CANT_ENABLE_DENY_ONLY: NTSTATUS = NTSTATUS(-1_073_741_133_i32); + pub const STATUS_CANT_OPEN_ANONYMOUS: NTSTATUS = NTSTATUS(-1_073_741_658_i32); + pub const STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT: NTSTATUS = NTSTATUS(-1_072_103_387_i32); + pub const STATUS_CANT_RECOVER_WITH_HANDLE_OPEN: NTSTATUS = NTSTATUS(-2_145_845_199_i32); + pub const STATUS_CANT_TERMINATE_SELF: NTSTATUS = NTSTATUS(-1_073_741_605_i32); + pub const STATUS_CANT_WAIT: NTSTATUS = NTSTATUS(-1_073_741_608_i32); + pub const STATUS_CARDBUS_NOT_SUPPORTED: NTSTATUS = NTSTATUS(1_073_741_863_i32); + pub const STATUS_CASE_DIFFERING_NAMES_IN_DIR: NTSTATUS = NTSTATUS(-1_073_740_621_i32); + pub const STATUS_CASE_SENSITIVE_PATH: NTSTATUS = NTSTATUS(-1_073_740_614_i32); + pub const STATUS_CC_NEEDS_CALLBACK_SECTION_DRAIN: NTSTATUS = NTSTATUS(-1_073_700_856_i32); + pub const STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE: NTSTATUS = NTSTATUS(-1_073_740_012_i32); + pub const STATUS_CERTIFICATE_VALIDATION_PREFERENCE_CONFLICT: NTSTATUS = NTSTATUS(-1_073_741_387_i32); + pub const STATUS_CHECKING_FILE_SYSTEM: NTSTATUS = NTSTATUS(1_073_741_844_i32); + pub const STATUS_CHECKOUT_REQUIRED: NTSTATUS = NTSTATUS(-1_073_739_518_i32); + pub const STATUS_CHILD_MUST_BE_VOLATILE: NTSTATUS = NTSTATUS(-1_073_741_439_i32); + pub const STATUS_CHILD_PROCESS_BLOCKED: NTSTATUS = NTSTATUS(-1_073_740_643_i32); + pub const STATUS_CIMFS_IMAGE_CORRUPT: NTSTATUS = NTSTATUS(-1_073_692_671_i32); + pub const STATUS_CIMFS_IMAGE_VERSION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_692_670_i32); + pub const STATUS_CLEANER_CARTRIDGE_INSTALLED: NTSTATUS = NTSTATUS(-2_147_483_609_i32); + pub const STATUS_CLIENT_SERVER_PARAMETERS_INVALID: NTSTATUS = NTSTATUS(-1_073_741_277_i32); + pub const STATUS_CLIP_DEVICE_LICENSE_MISSING: NTSTATUS = NTSTATUS(-1_058_406_397_i32); + pub const STATUS_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID: NTSTATUS = NTSTATUS(-1_058_406_395_i32); + pub const STATUS_CLIP_LICENSE_DEVICE_ID_MISMATCH: NTSTATUS = NTSTATUS(-1_058_406_390_i32); + pub const STATUS_CLIP_LICENSE_EXPIRED: NTSTATUS = NTSTATUS(-1_058_406_394_i32); + pub const STATUS_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE: NTSTATUS = NTSTATUS(-1_058_406_391_i32); + pub const STATUS_CLIP_LICENSE_INVALID_SIGNATURE: NTSTATUS = NTSTATUS(-1_058_406_396_i32); + pub const STATUS_CLIP_LICENSE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_058_406_398_i32); + pub const STATUS_CLIP_LICENSE_NOT_SIGNED: NTSTATUS = NTSTATUS(-1_058_406_392_i32); + pub const STATUS_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE: NTSTATUS = NTSTATUS(-1_058_406_393_i32); + pub const STATUS_CLOUD_FILE_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_073_688_808_i32); + pub const STATUS_CLOUD_FILE_ALREADY_CONNECTED: NTSTATUS = NTSTATUS(-1_073_688_823_i32); + pub const STATUS_CLOUD_FILE_AUTHENTICATION_FAILED: NTSTATUS = NTSTATUS(-1_073_688_817_i32); + pub const STATUS_CLOUD_FILE_CONNECTED_PROVIDER_ONLY: NTSTATUS = NTSTATUS(-1_073_688_819_i32); + pub const STATUS_CLOUD_FILE_DEHYDRATION_DISALLOWED: NTSTATUS = NTSTATUS(-1_073_688_800_i32); + pub const STATUS_CLOUD_FILE_INCOMPATIBLE_HARDLINKS: NTSTATUS = NTSTATUS(-1_073_688_807_i32); + pub const STATUS_CLOUD_FILE_INSUFFICIENT_RESOURCES: NTSTATUS = NTSTATUS(-1_073_688_816_i32); + pub const STATUS_CLOUD_FILE_INVALID_REQUEST: NTSTATUS = NTSTATUS(-1_073_688_821_i32); + pub const STATUS_CLOUD_FILE_IN_USE: NTSTATUS = NTSTATUS(-1_073_688_812_i32); + pub const STATUS_CLOUD_FILE_METADATA_CORRUPT: NTSTATUS = NTSTATUS(-1_073_688_830_i32); + pub const STATUS_CLOUD_FILE_METADATA_TOO_LARGE: NTSTATUS = NTSTATUS(-1_073_688_829_i32); + pub const STATUS_CLOUD_FILE_NETWORK_UNAVAILABLE: NTSTATUS = NTSTATUS(-1_073_688_815_i32); + pub const STATUS_CLOUD_FILE_NOT_IN_SYNC: NTSTATUS = NTSTATUS(-1_073_688_824_i32); + pub const STATUS_CLOUD_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_688_822_i32); + pub const STATUS_CLOUD_FILE_NOT_UNDER_SYNC_ROOT: NTSTATUS = NTSTATUS(-1_073_688_813_i32); + pub const STATUS_CLOUD_FILE_PINNED: NTSTATUS = NTSTATUS(-1_073_688_811_i32); + pub const STATUS_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH: NTSTATUS = NTSTATUS(-2_147_430_656_i32); + pub const STATUS_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE: NTSTATUS = NTSTATUS(-2_147_430_652_i32); + pub const STATUS_CLOUD_FILE_PROPERTY_CORRUPT: NTSTATUS = NTSTATUS(-1_073_688_809_i32); + pub const STATUS_CLOUD_FILE_PROPERTY_LOCK_CONFLICT: NTSTATUS = NTSTATUS(-1_073_688_806_i32); + pub const STATUS_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_688_826_i32); + pub const STATUS_CLOUD_FILE_PROVIDER_NOT_RUNNING: NTSTATUS = NTSTATUS(-1_073_688_831_i32); + pub const STATUS_CLOUD_FILE_PROVIDER_TERMINATED: NTSTATUS = NTSTATUS(-1_073_688_803_i32); + pub const STATUS_CLOUD_FILE_READ_ONLY_VOLUME: NTSTATUS = NTSTATUS(-1_073_688_820_i32); + pub const STATUS_CLOUD_FILE_REQUEST_ABORTED: NTSTATUS = NTSTATUS(-1_073_688_810_i32); + pub const STATUS_CLOUD_FILE_REQUEST_CANCELED: NTSTATUS = NTSTATUS(-1_073_688_805_i32); + pub const STATUS_CLOUD_FILE_REQUEST_TIMEOUT: NTSTATUS = NTSTATUS(-1_073_688_801_i32); + pub const STATUS_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT: NTSTATUS = NTSTATUS(-1_073_688_832_i32); + pub const STATUS_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS: NTSTATUS = NTSTATUS(-2_147_430_651_i32); + pub const STATUS_CLOUD_FILE_UNSUCCESSFUL: NTSTATUS = NTSTATUS(-1_073_688_814_i32); + pub const STATUS_CLOUD_FILE_US_MESSAGE_TIMEOUT: NTSTATUS = NTSTATUS(-1_073_688_799_i32); + pub const STATUS_CLOUD_FILE_VALIDATION_FAILED: NTSTATUS = NTSTATUS(-1_073_688_818_i32); + pub const STATUS_CLUSTER_CAM_TICKET_REPLAY_DETECTED: NTSTATUS = NTSTATUS(-1_072_496_591_i32); + pub const STATUS_CLUSTER_CSV_AUTO_PAUSE_ERROR: NTSTATUS = NTSTATUS(-1_072_496_607_i32); + pub const STATUS_CLUSTER_CSV_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1_072_496_599_i32); + pub const STATUS_CLUSTER_CSV_NOT_REDIRECTED: NTSTATUS = NTSTATUS(-1_072_496_605_i32); + pub const STATUS_CLUSTER_CSV_NO_SNAPSHOTS: NTSTATUS = NTSTATUS(-1_072_496_601_i32); + pub const STATUS_CLUSTER_CSV_READ_OPLOCK_BREAK_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_072_496_608_i32); + pub const STATUS_CLUSTER_CSV_REDIRECTED: NTSTATUS = NTSTATUS(-1_072_496_606_i32); + pub const STATUS_CLUSTER_CSV_SNAPSHOT_CREATION_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_072_496_603_i32); + pub const STATUS_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR: NTSTATUS = NTSTATUS(-1_072_496_592_i32); + pub const STATUS_CLUSTER_CSV_VOLUME_DRAINING: NTSTATUS = NTSTATUS(-1_072_496_604_i32); + pub const STATUS_CLUSTER_CSV_VOLUME_DRAINING_SUCCEEDED_DOWNLEVEL: NTSTATUS = NTSTATUS(-1_072_496_602_i32); + pub const STATUS_CLUSTER_CSV_VOLUME_NOT_LOCAL: NTSTATUS = NTSTATUS(-1_072_496_615_i32); + pub const STATUS_CLUSTER_INVALID_NETWORK: NTSTATUS = NTSTATUS(-1_072_496_624_i32); + pub const STATUS_CLUSTER_INVALID_NETWORK_PROVIDER: NTSTATUS = NTSTATUS(-1_072_496_629_i32); + pub const STATUS_CLUSTER_INVALID_NODE: NTSTATUS = NTSTATUS(-1_072_496_639_i32); + pub const STATUS_CLUSTER_INVALID_REQUEST: NTSTATUS = NTSTATUS(-1_072_496_630_i32); + pub const STATUS_CLUSTER_JOIN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_072_496_637_i32); + pub const STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_072_496_625_i32); + pub const STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_496_635_i32); + pub const STATUS_CLUSTER_NETINTERFACE_EXISTS: NTSTATUS = NTSTATUS(-1_072_496_632_i32); + pub const STATUS_CLUSTER_NETINTERFACE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_496_631_i32); + pub const STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE: NTSTATUS = NTSTATUS(-2_146_238_460_i32); + pub const STATUS_CLUSTER_NETWORK_ALREADY_ONLINE: NTSTATUS = NTSTATUS(-2_146_238_461_i32); + pub const STATUS_CLUSTER_NETWORK_EXISTS: NTSTATUS = NTSTATUS(-1_072_496_634_i32); + pub const STATUS_CLUSTER_NETWORK_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_496_633_i32); + pub const STATUS_CLUSTER_NETWORK_NOT_INTERNAL: NTSTATUS = NTSTATUS(-1_072_496_618_i32); + pub const STATUS_CLUSTER_NODE_ALREADY_DOWN: NTSTATUS = NTSTATUS(-2_146_238_462_i32); + pub const STATUS_CLUSTER_NODE_ALREADY_MEMBER: NTSTATUS = NTSTATUS(-2_146_238_459_i32); + pub const STATUS_CLUSTER_NODE_ALREADY_UP: NTSTATUS = NTSTATUS(-2_146_238_463_i32); + pub const STATUS_CLUSTER_NODE_DOWN: NTSTATUS = NTSTATUS(-1_072_496_628_i32); + pub const STATUS_CLUSTER_NODE_EXISTS: NTSTATUS = NTSTATUS(-1_072_496_638_i32); + pub const STATUS_CLUSTER_NODE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_496_636_i32); + pub const STATUS_CLUSTER_NODE_NOT_MEMBER: NTSTATUS = NTSTATUS(-1_072_496_626_i32); + pub const STATUS_CLUSTER_NODE_NOT_PAUSED: NTSTATUS = NTSTATUS(-1_072_496_620_i32); + pub const STATUS_CLUSTER_NODE_PAUSED: NTSTATUS = NTSTATUS(-1_072_496_621_i32); + pub const STATUS_CLUSTER_NODE_UNREACHABLE: NTSTATUS = NTSTATUS(-1_072_496_627_i32); + pub const STATUS_CLUSTER_NODE_UP: NTSTATUS = NTSTATUS(-1_072_496_622_i32); + pub const STATUS_CLUSTER_NON_CSV_PATH: NTSTATUS = NTSTATUS(-1_072_496_616_i32); + pub const STATUS_CLUSTER_NO_NET_ADAPTERS: NTSTATUS = NTSTATUS(-1_072_496_623_i32); + pub const STATUS_CLUSTER_NO_SECURITY_CONTEXT: NTSTATUS = NTSTATUS(-1_072_496_619_i32); + pub const STATUS_CLUSTER_POISONED: NTSTATUS = NTSTATUS(-1_072_496_617_i32); + pub const STATUS_COMMITMENT_LIMIT: NTSTATUS = NTSTATUS(-1_073_741_523_i32); + pub const STATUS_COMMITMENT_MINIMUM: NTSTATUS = NTSTATUS(-1_073_741_112_i32); + pub const STATUS_COMPRESSED_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_677_i32); + pub const STATUS_COMPRESSION_DISABLED: NTSTATUS = NTSTATUS(-1_073_740_762_i32); + pub const STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1_072_103_338_i32); + pub const STATUS_COMPRESSION_NOT_BENEFICIAL: NTSTATUS = NTSTATUS(-1_073_740_689_i32); + pub const STATUS_CONFLICTING_ADDRESSES: NTSTATUS = NTSTATUS(-1_073_741_800_i32); + pub const STATUS_CONNECTION_ABORTED: NTSTATUS = NTSTATUS(-1_073_741_247_i32); + pub const STATUS_CONNECTION_ACTIVE: NTSTATUS = NTSTATUS(-1_073_741_253_i32); + pub const STATUS_CONNECTION_COUNT_LIMIT: NTSTATUS = NTSTATUS(-1_073_741_242_i32); + pub const STATUS_CONNECTION_DISCONNECTED: NTSTATUS = NTSTATUS(-1_073_741_300_i32); + pub const STATUS_CONNECTION_INVALID: NTSTATUS = NTSTATUS(-1_073_741_254_i32); + pub const STATUS_CONNECTION_IN_USE: NTSTATUS = NTSTATUS(-1_073_741_560_i32); + pub const STATUS_CONNECTION_REFUSED: NTSTATUS = NTSTATUS(-1_073_741_258_i32); + pub const STATUS_CONNECTION_RESET: NTSTATUS = NTSTATUS(-1_073_741_299_i32); + pub const STATUS_CONTAINER_ASSIGNED: NTSTATUS = NTSTATUS(-1_073_740_536_i32); + pub const STATUS_CONTENT_BLOCKED: NTSTATUS = NTSTATUS(-1_073_739_772_i32); + pub const STATUS_CONTEXT_MISMATCH: NTSTATUS = NTSTATUS(-1_073_740_007_i32); + pub const STATUS_CONTEXT_STOWED_EXCEPTION: NTSTATUS = NTSTATUS(-1_073_741_188_i32); + pub const STATUS_CONTROL_C_EXIT: NTSTATUS = NTSTATUS(-1_073_741_510_i32); + pub const STATUS_CONTROL_STACK_VIOLATION: NTSTATUS = NTSTATUS(-1_073_741_390_i32); + pub const STATUS_CONVERT_TO_LARGE: NTSTATUS = NTSTATUS(-1_073_741_268_i32); + pub const STATUS_COPY_PROTECTION_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_051_i32); + pub const STATUS_CORRUPT_LOG_CLEARED: NTSTATUS = NTSTATUS(-1_073_739_763_i32); + pub const STATUS_CORRUPT_LOG_CORRUPTED: NTSTATUS = NTSTATUS(-1_073_739_766_i32); + pub const STATUS_CORRUPT_LOG_DELETED_FULL: NTSTATUS = NTSTATUS(-1_073_739_764_i32); + pub const STATUS_CORRUPT_LOG_OVERFULL: NTSTATUS = NTSTATUS(-1_073_739_767_i32); + pub const STATUS_CORRUPT_LOG_UNAVAILABLE: NTSTATUS = NTSTATUS(-1_073_739_765_i32); + pub const STATUS_CORRUPT_LOG_UPLEVEL_RECORDS: NTSTATUS = NTSTATUS(-1_073_739_759_i32); + pub const STATUS_CORRUPT_SYSTEM_FILE: NTSTATUS = NTSTATUS(-1_073_741_116_i32); + pub const STATUS_COULD_NOT_INTERPRET: NTSTATUS = NTSTATUS(-1_073_741_639_i32); + pub const STATUS_COULD_NOT_RESIZE_LOG: NTSTATUS = NTSTATUS(-2_145_845_239_i32); + pub const STATUS_CPU_SET_INVALID: NTSTATUS = NTSTATUS(-1_073_741_393_i32); + pub const STATUS_CRASH_DUMP: NTSTATUS = NTSTATUS(278i32); + pub const STATUS_CRC_ERROR: NTSTATUS = NTSTATUS(-1_073_741_761_i32); + pub const STATUS_CRED_REQUIRES_CONFIRMATION: NTSTATUS = NTSTATUS(-1_073_740_736_i32); + pub const STATUS_CRM_PROTOCOL_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1_072_103_409_i32); + pub const STATUS_CRM_PROTOCOL_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_103_407_i32); + pub const STATUS_CROSSREALM_DELEGATION_FAILURE: NTSTATUS = NTSTATUS(-1_073_740_789_i32); + pub const STATUS_CROSS_PARTITION_VIOLATION: NTSTATUS = NTSTATUS(-1_073_740_277_i32); + pub const STATUS_CRYPTO_SYSTEM_INVALID: NTSTATUS = NTSTATUS(-1_073_741_069_i32); + pub const STATUS_CSS_AUTHENTICATION_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_050_i32); + pub const STATUS_CSS_KEY_NOT_ESTABLISHED: NTSTATUS = NTSTATUS(-1_073_741_048_i32); + pub const STATUS_CSS_KEY_NOT_PRESENT: NTSTATUS = NTSTATUS(-1_073_741_049_i32); + pub const STATUS_CSS_REGION_MISMATCH: NTSTATUS = NTSTATUS(-1_073_741_046_i32); + pub const STATUS_CSS_RESETS_EXHAUSTED: NTSTATUS = NTSTATUS(-1_073_741_045_i32); + pub const STATUS_CSS_SCRAMBLED_SECTOR: NTSTATUS = NTSTATUS(-1_073_741_047_i32); + pub const STATUS_CSV_IO_PAUSE_TIMEOUT: NTSTATUS = NTSTATUS(-1_072_496_600_i32); + pub const STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE: NTSTATUS = NTSTATUS(-1_073_740_733_i32); + pub const STATUS_CS_ENCRYPTION_FILE_NOT_CSE: NTSTATUS = NTSTATUS(-1_073_740_731_i32); + pub const STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE: NTSTATUS = NTSTATUS(-1_073_740_735_i32); + pub const STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE: NTSTATUS = NTSTATUS(-1_073_740_732_i32); + pub const STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER: NTSTATUS = NTSTATUS(-1_073_740_734_i32); + pub const STATUS_CTLOG_INCONSISTENT_TRACKING_FILE: NTSTATUS = NTSTATUS(-1_069_940_700_i32); + pub const STATUS_CTLOG_INVALID_TRACKING_STATE: NTSTATUS = NTSTATUS(-1_069_940_701_i32); + pub const STATUS_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZE: NTSTATUS = NTSTATUS(-1_069_940_703_i32); + pub const STATUS_CTLOG_TRACKING_NOT_INITIALIZED: NTSTATUS = NTSTATUS(-1_069_940_704_i32); + pub const STATUS_CTLOG_VHD_CHANGED_OFFLINE: NTSTATUS = NTSTATUS(-1_069_940_702_i32); + pub const STATUS_CTL_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_741_737_i32); + pub const STATUS_CTX_BAD_VIDEO_MODE: NTSTATUS = NTSTATUS(-1_073_086_440_i32); + pub const STATUS_CTX_CDM_CONNECT: NTSTATUS = NTSTATUS(1_074_397_188_i32); + pub const STATUS_CTX_CDM_DISCONNECT: NTSTATUS = NTSTATUS(1_074_397_189_i32); + pub const STATUS_CTX_CLIENT_LICENSE_IN_USE: NTSTATUS = NTSTATUS(-1_073_086_412_i32); + pub const STATUS_CTX_CLIENT_LICENSE_NOT_SET: NTSTATUS = NTSTATUS(-1_073_086_413_i32); + pub const STATUS_CTX_CLIENT_QUERY_TIMEOUT: NTSTATUS = NTSTATUS(-1_073_086_426_i32); + pub const STATUS_CTX_CLOSE_PENDING: NTSTATUS = NTSTATUS(-1_073_086_458_i32); + pub const STATUS_CTX_CONSOLE_CONNECT: NTSTATUS = NTSTATUS(-1_073_086_424_i32); + pub const STATUS_CTX_CONSOLE_DISCONNECT: NTSTATUS = NTSTATUS(-1_073_086_425_i32); + pub const STATUS_CTX_GRAPHICS_INVALID: NTSTATUS = NTSTATUS(-1_073_086_430_i32); + pub const STATUS_CTX_INVALID_MODEMNAME: NTSTATUS = NTSTATUS(-1_073_086_455_i32); + pub const STATUS_CTX_INVALID_PD: NTSTATUS = NTSTATUS(-1_073_086_462_i32); + pub const STATUS_CTX_INVALID_WD: NTSTATUS = NTSTATUS(-1_073_086_418_i32); + pub const STATUS_CTX_LICENSE_CLIENT_INVALID: NTSTATUS = NTSTATUS(-1_073_086_446_i32); + pub const STATUS_CTX_LICENSE_EXPIRED: NTSTATUS = NTSTATUS(-1_073_086_444_i32); + pub const STATUS_CTX_LICENSE_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_073_086_445_i32); + pub const STATUS_CTX_LOGON_DISABLED: NTSTATUS = NTSTATUS(-1_073_086_409_i32); + pub const STATUS_CTX_MODEM_INF_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_086_456_i32); + pub const STATUS_CTX_MODEM_RESPONSE_BUSY: NTSTATUS = NTSTATUS(-1_073_086_450_i32); + pub const STATUS_CTX_MODEM_RESPONSE_NO_CARRIER: NTSTATUS = NTSTATUS(-1_073_086_452_i32); + pub const STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE: NTSTATUS = NTSTATUS(-1_073_086_451_i32); + pub const STATUS_CTX_MODEM_RESPONSE_TIMEOUT: NTSTATUS = NTSTATUS(-1_073_086_453_i32); + pub const STATUS_CTX_MODEM_RESPONSE_VOICE: NTSTATUS = NTSTATUS(-1_073_086_449_i32); + pub const STATUS_CTX_NOT_CONSOLE: NTSTATUS = NTSTATUS(-1_073_086_428_i32); + pub const STATUS_CTX_NO_OUTBUF: NTSTATUS = NTSTATUS(-1_073_086_457_i32); + pub const STATUS_CTX_PD_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_086_461_i32); + pub const STATUS_CTX_RESPONSE_ERROR: NTSTATUS = NTSTATUS(-1_073_086_454_i32); + pub const STATUS_CTX_SECURITY_LAYER_ERROR: NTSTATUS = NTSTATUS(-1_073_086_408_i32); + pub const STATUS_CTX_SHADOW_DENIED: NTSTATUS = NTSTATUS(-1_073_086_422_i32); + pub const STATUS_CTX_SHADOW_DISABLED: NTSTATUS = NTSTATUS(-1_073_086_415_i32); + pub const STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE: NTSTATUS = NTSTATUS(-1_073_086_411_i32); + pub const STATUS_CTX_SHADOW_INVALID: NTSTATUS = NTSTATUS(-1_073_086_416_i32); + pub const STATUS_CTX_SHADOW_NOT_RUNNING: NTSTATUS = NTSTATUS(-1_073_086_410_i32); + pub const STATUS_CTX_TD_ERROR: NTSTATUS = NTSTATUS(-1_073_086_448_i32); + pub const STATUS_CTX_WD_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_086_417_i32); + pub const STATUS_CTX_WINSTATION_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_073_086_421_i32); + pub const STATUS_CTX_WINSTATION_BUSY: NTSTATUS = NTSTATUS(-1_073_086_441_i32); + pub const STATUS_CTX_WINSTATION_NAME_COLLISION: NTSTATUS = NTSTATUS(-1_073_086_442_i32); + pub const STATUS_CTX_WINSTATION_NAME_INVALID: NTSTATUS = NTSTATUS(-1_073_086_463_i32); + pub const STATUS_CTX_WINSTATION_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_086_443_i32); + pub const STATUS_CURRENT_DOMAIN_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_073_741_079_i32); + pub const STATUS_CURRENT_TRANSACTION_NOT_VALID: NTSTATUS = NTSTATUS(-1_072_103_400_i32); + pub const STATUS_DATATYPE_MISALIGNMENT: NTSTATUS = NTSTATUS(-2_147_483_646_i32); + pub const STATUS_DATATYPE_MISALIGNMENT_ERROR: NTSTATUS = NTSTATUS(-1_073_741_115_i32); + pub const STATUS_DATA_CHECKSUM_ERROR: NTSTATUS = NTSTATUS(-1_073_740_688_i32); + pub const STATUS_DATA_ERROR: NTSTATUS = NTSTATUS(-1_073_741_762_i32); + pub const STATUS_DATA_LATE_ERROR: NTSTATUS = NTSTATUS(-1_073_741_763_i32); + pub const STATUS_DATA_LOST_REPAIR: NTSTATUS = NTSTATUS(-2_147_481_597_i32); + pub const STATUS_DATA_NOT_ACCEPTED: NTSTATUS = NTSTATUS(-1_073_741_285_i32); + pub const STATUS_DATA_OVERRUN: NTSTATUS = NTSTATUS(-1_073_741_764_i32); + pub const STATUS_DATA_OVERWRITTEN: NTSTATUS = NTSTATUS(304i32); + pub const STATUS_DAX_MAPPING_EXISTS: NTSTATUS = NTSTATUS(-1_073_740_644_i32); + pub const STATUS_DEBUGGER_INACTIVE: NTSTATUS = NTSTATUS(-1_073_740_972_i32); + pub const STATUS_DEBUG_ATTACH_FAILED: NTSTATUS = NTSTATUS(-1_073_741_287_i32); + pub const STATUS_DECRYPTION_FAILED: NTSTATUS = NTSTATUS(-1_073_741_173_i32); + pub const STATUS_DELAY_LOAD_FAILED: NTSTATUS = NTSTATUS(-1_073_740_782_i32); + pub const STATUS_DELETE_PENDING: NTSTATUS = NTSTATUS(-1_073_741_738_i32); + pub const STATUS_DESTINATION_ELEMENT_FULL: NTSTATUS = NTSTATUS(-1_073_741_180_i32); + pub const STATUS_DEVICE_ALREADY_ATTACHED: NTSTATUS = NTSTATUS(-1_073_741_768_i32); + pub const STATUS_DEVICE_BUSY: NTSTATUS = NTSTATUS(-2_147_483_631_i32); + pub const STATUS_DEVICE_CONFIGURATION_ERROR: NTSTATUS = NTSTATUS(-1_073_741_438_i32); + pub const STATUS_DEVICE_DATA_ERROR: NTSTATUS = NTSTATUS(-1_073_741_668_i32); + pub const STATUS_DEVICE_DOES_NOT_EXIST: NTSTATUS = NTSTATUS(-1_073_741_632_i32); + pub const STATUS_DEVICE_DOOR_OPEN: NTSTATUS = NTSTATUS(-2_147_482_999_i32); + pub const STATUS_DEVICE_ENUMERATION_ERROR: NTSTATUS = NTSTATUS(-1_073_740_954_i32); + pub const STATUS_DEVICE_FEATURE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_701_i32); + pub const STATUS_DEVICE_HARDWARE_ERROR: NTSTATUS = NTSTATUS(-1_073_740_669_i32); + pub const STATUS_DEVICE_HINT_NAME_BUFFER_TOO_SMALL: NTSTATUS = NTSTATUS(-1_073_740_650_i32); + pub const STATUS_DEVICE_HUNG: NTSTATUS = NTSTATUS(-1_073_740_537_i32); + pub const STATUS_DEVICE_INSUFFICIENT_RESOURCES: NTSTATUS = NTSTATUS(-1_073_740_696_i32); + pub const STATUS_DEVICE_IN_MAINTENANCE: NTSTATUS = NTSTATUS(-1_073_740_647_i32); + pub const STATUS_DEVICE_NOT_CONNECTED: NTSTATUS = NTSTATUS(-1_073_741_667_i32); + pub const STATUS_DEVICE_NOT_PARTITIONED: NTSTATUS = NTSTATUS(-1_073_741_452_i32); + pub const STATUS_DEVICE_NOT_READY: NTSTATUS = NTSTATUS(-1_073_741_661_i32); + pub const STATUS_DEVICE_OFF_LINE: NTSTATUS = NTSTATUS(-2_147_483_632_i32); + pub const STATUS_DEVICE_PAPER_EMPTY: NTSTATUS = NTSTATUS(-2_147_483_634_i32); + pub const STATUS_DEVICE_POWERED_OFF: NTSTATUS = NTSTATUS(-2_147_483_633_i32); + pub const STATUS_DEVICE_POWER_CYCLE_REQUIRED: NTSTATUS = NTSTATUS(-2_147_483_599_i32); + pub const STATUS_DEVICE_POWER_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_666_i32); + pub const STATUS_DEVICE_PROTOCOL_ERROR: NTSTATUS = NTSTATUS(-1_073_741_434_i32); + pub const STATUS_DEVICE_REMOVED: NTSTATUS = NTSTATUS(-1_073_741_130_i32); + pub const STATUS_DEVICE_REQUIRES_CLEANING: NTSTATUS = NTSTATUS(-2_147_483_000_i32); + pub const STATUS_DEVICE_RESET_REQUIRED: NTSTATUS = NTSTATUS(-2_147_483_210_i32); + pub const STATUS_DEVICE_SUPPORT_IN_PROGRESS: NTSTATUS = NTSTATUS(-2_147_483_600_i32); + pub const STATUS_DEVICE_UNREACHABLE: NTSTATUS = NTSTATUS(-1_073_740_700_i32); + pub const STATUS_DEVICE_UNRESPONSIVE: NTSTATUS = NTSTATUS(-1_073_740_534_i32); + pub const STATUS_DFS_EXIT_PATH_FOUND: NTSTATUS = NTSTATUS(-1_073_741_669_i32); + pub const STATUS_DFS_UNAVAILABLE: NTSTATUS = NTSTATUS(-1_073_741_203_i32); + pub const STATUS_DIF_BINDING_API_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_738_625_i32); + pub const STATUS_DIF_IOCALLBACK_NOT_REPLACED: NTSTATUS = NTSTATUS(-1_073_738_634_i32); + pub const STATUS_DIF_LIVEDUMP_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_738_633_i32); + pub const STATUS_DIF_VOLATILE_DRIVER_HOTPATCHED: NTSTATUS = NTSTATUS(-1_073_738_631_i32); + pub const STATUS_DIF_VOLATILE_DRIVER_IS_NOT_RUNNING: NTSTATUS = NTSTATUS(-1_073_738_629_i32); + pub const STATUS_DIF_VOLATILE_INVALID_INFO: NTSTATUS = NTSTATUS(-1_073_738_630_i32); + pub const STATUS_DIF_VOLATILE_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_073_738_626_i32); + pub const STATUS_DIF_VOLATILE_PLUGIN_CHANGE_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_073_738_627_i32); + pub const STATUS_DIF_VOLATILE_PLUGIN_IS_NOT_RUNNING: NTSTATUS = NTSTATUS(-1_073_738_628_i32); + pub const STATUS_DIF_VOLATILE_SECTION_NOT_LOCKED: NTSTATUS = NTSTATUS(-1_073_738_632_i32); + pub const STATUS_DIRECTORY_IS_A_REPARSE_POINT: NTSTATUS = NTSTATUS(-1_073_741_183_i32); + pub const STATUS_DIRECTORY_NOT_EMPTY: NTSTATUS = NTSTATUS(-1_073_741_567_i32); + pub const STATUS_DIRECTORY_NOT_RM: NTSTATUS = NTSTATUS(-1_072_103_416_i32); + pub const STATUS_DIRECTORY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_676_i32); + pub const STATUS_DIRECTORY_SERVICE_REQUIRED: NTSTATUS = NTSTATUS(-1_073_741_135_i32); + pub const STATUS_DISK_CORRUPT_ERROR: NTSTATUS = NTSTATUS(-1_073_741_774_i32); + pub const STATUS_DISK_FULL: NTSTATUS = NTSTATUS(-1_073_741_697_i32); + pub const STATUS_DISK_OPERATION_FAILED: NTSTATUS = NTSTATUS(-1_073_741_462_i32); + pub const STATUS_DISK_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_739_774_i32); + pub const STATUS_DISK_RECALIBRATE_FAILED: NTSTATUS = NTSTATUS(-1_073_741_463_i32); + pub const STATUS_DISK_REPAIR_DISABLED: NTSTATUS = NTSTATUS(-1_073_739_776_i32); + pub const STATUS_DISK_REPAIR_REDIRECTED: NTSTATUS = NTSTATUS(1_073_743_879_i32); + pub const STATUS_DISK_REPAIR_UNSUCCESSFUL: NTSTATUS = NTSTATUS(-1_073_739_768_i32); + pub const STATUS_DISK_RESET_FAILED: NTSTATUS = NTSTATUS(-1_073_741_461_i32); + pub const STATUS_DISK_RESOURCES_EXHAUSTED: NTSTATUS = NTSTATUS(-1_073_740_703_i32); + pub const STATUS_DLL_INIT_FAILED: NTSTATUS = NTSTATUS(-1_073_741_502_i32); + pub const STATUS_DLL_INIT_FAILED_LOGOFF: NTSTATUS = NTSTATUS(-1_073_741_205_i32); + pub const STATUS_DLL_MIGHT_BE_INCOMPATIBLE: NTSTATUS = NTSTATUS(-2_147_483_604_i32); + pub const STATUS_DLL_MIGHT_BE_INSECURE: NTSTATUS = NTSTATUS(-2_147_483_605_i32); + pub const STATUS_DLL_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_515_i32); + pub const STATUS_DM_OPERATION_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1_070_135_808_i32); + pub const STATUS_DOMAIN_CONTROLLER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_261_i32); + pub const STATUS_DOMAIN_CTRLR_CONFIG_ERROR: NTSTATUS = NTSTATUS(-1_073_741_474_i32); + pub const STATUS_DOMAIN_EXISTS: NTSTATUS = NTSTATUS(-1_073_741_600_i32); + pub const STATUS_DOMAIN_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_599_i32); + pub const STATUS_DOMAIN_TRUST_INCONSISTENT: NTSTATUS = NTSTATUS(-1_073_741_413_i32); + pub const STATUS_DRIVERS_LEAKING_LOCKED_PAGES: NTSTATUS = NTSTATUS(1_073_741_869_i32); + pub const STATUS_DRIVER_BLOCKED: NTSTATUS = NTSTATUS(-1_073_740_948_i32); + pub const STATUS_DRIVER_BLOCKED_CRITICAL: NTSTATUS = NTSTATUS(-1_073_740_949_i32); + pub const STATUS_DRIVER_CANCEL_TIMEOUT: NTSTATUS = NTSTATUS(-1_073_741_282_i32); + pub const STATUS_DRIVER_DATABASE_ERROR: NTSTATUS = NTSTATUS(-1_073_740_947_i32); + pub const STATUS_DRIVER_ENTRYPOINT_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_213_i32); + pub const STATUS_DRIVER_FAILED_PRIOR_UNLOAD: NTSTATUS = NTSTATUS(-1_073_740_914_i32); + pub const STATUS_DRIVER_FAILED_SLEEP: NTSTATUS = NTSTATUS(-1_073_741_118_i32); + pub const STATUS_DRIVER_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1_073_741_437_i32); + pub const STATUS_DRIVER_ORDINAL_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_214_i32); + pub const STATUS_DRIVER_PROCESS_TERMINATED: NTSTATUS = NTSTATUS(-1_073_740_720_i32); + pub const STATUS_DRIVER_UNABLE_TO_LOAD: NTSTATUS = NTSTATUS(-1_073_741_204_i32); + pub const STATUS_DS_ADMIN_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_119_i32); + pub const STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER: NTSTATUS = NTSTATUS(-1_073_740_968_i32); + pub const STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS: NTSTATUS = NTSTATUS(-1_073_741_148_i32); + pub const STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED: NTSTATUS = NTSTATUS(-1_073_741_149_i32); + pub const STATUS_DS_BUSY: NTSTATUS = NTSTATUS(-1_073_741_147_i32); + pub const STATUS_DS_CANT_MOD_OBJ_CLASS: NTSTATUS = NTSTATUS(-1_073_741_138_i32); + pub const STATUS_DS_CANT_MOD_PRIMARYGROUPID: NTSTATUS = NTSTATUS(-1_073_741_104_i32); + pub const STATUS_DS_CANT_ON_NON_LEAF: NTSTATUS = NTSTATUS(-1_073_741_140_i32); + pub const STATUS_DS_CANT_ON_RDN: NTSTATUS = NTSTATUS(-1_073_741_139_i32); + pub const STATUS_DS_CANT_START: NTSTATUS = NTSTATUS(-1_073_741_087_i32); + pub const STATUS_DS_CROSS_DOM_MOVE_FAILED: NTSTATUS = NTSTATUS(-1_073_741_137_i32); + pub const STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST: NTSTATUS = NTSTATUS(-1_073_740_774_i32); + pub const STATUS_DS_DOMAIN_RENAME_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_073_739_775_i32); + pub const STATUS_DS_DUPLICATE_ID_FOUND: NTSTATUS = NTSTATUS(-1_073_740_795_i32); + pub const STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST: NTSTATUS = NTSTATUS(-1_073_740_773_i32); + pub const STATUS_DS_GC_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_073_741_136_i32); + pub const STATUS_DS_GC_REQUIRED: NTSTATUS = NTSTATUS(-1_073_741_084_i32); + pub const STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER: NTSTATUS = NTSTATUS(-1_073_741_094_i32); + pub const STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER: NTSTATUS = NTSTATUS(-1_073_741_097_i32); + pub const STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER: NTSTATUS = NTSTATUS(-1_073_741_096_i32); + pub const STATUS_DS_GROUP_CONVERSION_ERROR: NTSTATUS = NTSTATUS(-1_073_740_794_i32); + pub const STATUS_DS_HAVE_PRIMARY_MEMBERS: NTSTATUS = NTSTATUS(-1_073_741_092_i32); + pub const STATUS_DS_INCORRECT_ROLE_OWNER: NTSTATUS = NTSTATUS(-1_073_741_143_i32); + pub const STATUS_DS_INIT_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_086_i32); + pub const STATUS_DS_INIT_FAILURE_CONSOLE: NTSTATUS = NTSTATUS(-1_073_741_076_i32); + pub const STATUS_DS_INVALID_ATTRIBUTE_SYNTAX: NTSTATUS = NTSTATUS(-1_073_741_150_i32); + pub const STATUS_DS_INVALID_GROUP_TYPE: NTSTATUS = NTSTATUS(-1_073_741_100_i32); + pub const STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER: NTSTATUS = NTSTATUS(-1_073_741_093_i32); + pub const STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY: NTSTATUS = NTSTATUS(-1_073_741_083_i32); + pub const STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_081_i32); + pub const STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY: NTSTATUS = NTSTATUS(289i32); + pub const STATUS_DS_NAME_NOT_UNIQUE: NTSTATUS = NTSTATUS(-1_073_740_796_i32); + pub const STATUS_DS_NO_ATTRIBUTE_OR_VALUE: NTSTATUS = NTSTATUS(-1_073_741_151_i32); + pub const STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS: NTSTATUS = NTSTATUS(-1_073_741_082_i32); + pub const STATUS_DS_NO_MORE_RIDS: NTSTATUS = NTSTATUS(-1_073_741_144_i32); + pub const STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN: NTSTATUS = NTSTATUS(-1_073_741_099_i32); + pub const STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN: NTSTATUS = NTSTATUS(-1_073_741_098_i32); + pub const STATUS_DS_NO_RIDS_ALLOCATED: NTSTATUS = NTSTATUS(-1_073_741_145_i32); + pub const STATUS_DS_OBJ_CLASS_VIOLATION: NTSTATUS = NTSTATUS(-1_073_741_141_i32); + pub const STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS: NTSTATUS = NTSTATUS(-1_073_700_729_i32); + pub const STATUS_DS_OID_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_700_728_i32); + pub const STATUS_DS_RIDMGR_DISABLED: NTSTATUS = NTSTATUS(-1_073_741_126_i32); + pub const STATUS_DS_RIDMGR_INIT_ERROR: NTSTATUS = NTSTATUS(-1_073_741_142_i32); + pub const STATUS_DS_SAM_INIT_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_109_i32); + pub const STATUS_DS_SAM_INIT_FAILURE_CONSOLE: NTSTATUS = NTSTATUS(-1_073_741_075_i32); + pub const STATUS_DS_SENSITIVE_GROUP_VIOLATION: NTSTATUS = NTSTATUS(-1_073_741_107_i32); + pub const STATUS_DS_SHUTTING_DOWN: NTSTATUS = NTSTATUS(1_073_742_704_i32); + pub const STATUS_DS_SRC_SID_EXISTS_IN_FOREST: NTSTATUS = NTSTATUS(-1_073_740_775_i32); + pub const STATUS_DS_UNAVAILABLE: NTSTATUS = NTSTATUS(-1_073_741_146_i32); + pub const STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER: NTSTATUS = NTSTATUS(-1_073_741_095_i32); + pub const STATUS_DS_VERSION_CHECK_FAILURE: NTSTATUS = NTSTATUS(-1_073_740_971_i32); + pub const STATUS_DUPLICATE_NAME: NTSTATUS = NTSTATUS(-1_073_741_635_i32); + pub const STATUS_DUPLICATE_OBJECTID: NTSTATUS = NTSTATUS(-1_073_741_270_i32); + pub const STATUS_DUPLICATE_PRIVILEGES: NTSTATUS = NTSTATUS(-1_073_741_402_i32); + pub const STATUS_DYNAMIC_CODE_BLOCKED: NTSTATUS = NTSTATUS(-1_073_740_284_i32); + pub const STATUS_EAS_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_741_745_i32); + pub const STATUS_EA_CORRUPT_ERROR: NTSTATUS = NTSTATUS(-1_073_741_741_i32); + pub const STATUS_EA_LIST_INCONSISTENT: NTSTATUS = NTSTATUS(-2_147_483_628_i32); + pub const STATUS_EA_TOO_LARGE: NTSTATUS = NTSTATUS(-1_073_741_744_i32); + pub const STATUS_EFS_ALG_BLOB_TOO_BIG: NTSTATUS = NTSTATUS(-1_073_740_974_i32); + pub const STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1_072_103_362_i32); + pub const STATUS_ELEVATION_REQUIRED: NTSTATUS = NTSTATUS(-1_073_740_756_i32); + pub const STATUS_EMULATION_BREAKPOINT: NTSTATUS = NTSTATUS(1_073_741_880_i32); + pub const STATUS_EMULATION_SYSCALL: NTSTATUS = NTSTATUS(1_073_741_881_i32); + pub const STATUS_ENCLAVE_FAILURE: NTSTATUS = NTSTATUS(-1_073_740_657_i32); + pub const STATUS_ENCLAVE_IS_TERMINATING: NTSTATUS = NTSTATUS(-1_073_740_526_i32); + pub const STATUS_ENCLAVE_NOT_TERMINATED: NTSTATUS = NTSTATUS(-1_073_740_527_i32); + pub const STATUS_ENCLAVE_VIOLATION: NTSTATUS = NTSTATUS(-1_073_740_638_i32); + pub const STATUS_ENCOUNTERED_WRITE_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_073_740_749_i32); + pub const STATUS_ENCRYPTED_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_605_i32); + pub const STATUS_ENCRYPTED_IO_NOT_POSSIBLE: NTSTATUS = NTSTATUS(-1_073_739_760_i32); + pub const STATUS_ENCRYPTING_METADATA_DISALLOWED: NTSTATUS = NTSTATUS(-1_073_740_617_i32); + pub const STATUS_ENCRYPTION_DISABLED: NTSTATUS = NTSTATUS(-1_073_740_618_i32); + pub const STATUS_ENCRYPTION_FAILED: NTSTATUS = NTSTATUS(-1_073_741_174_i32); + pub const STATUS_END_OF_FILE: NTSTATUS = NTSTATUS(-1_073_741_807_i32); + pub const STATUS_END_OF_MEDIA: NTSTATUS = NTSTATUS(-2_147_483_618_i32); + pub const STATUS_ENLISTMENT_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_103_344_i32); + pub const STATUS_ENLISTMENT_NOT_SUPERIOR: NTSTATUS = NTSTATUS(-1_072_103_373_i32); + pub const STATUS_ENTRYPOINT_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_511_i32); + pub const STATUS_EOF_ON_GHOSTED_RANGE: NTSTATUS = NTSTATUS(-1_073_700_857_i32); + pub const STATUS_EOM_OVERFLOW: NTSTATUS = NTSTATUS(-1_073_741_449_i32); + pub const STATUS_ERROR_PROCESS_NOT_IN_JOB: NTSTATUS = NTSTATUS(-1_073_741_394_i32); + pub const STATUS_EVALUATION_EXPIRATION: NTSTATUS = NTSTATUS(-1_073_741_208_i32); + pub const STATUS_EVENTLOG_CANT_START: NTSTATUS = NTSTATUS(-1_073_741_425_i32); + pub const STATUS_EVENTLOG_FILE_CHANGED: NTSTATUS = NTSTATUS(-1_073_741_417_i32); + pub const STATUS_EVENTLOG_FILE_CORRUPT: NTSTATUS = NTSTATUS(-1_073_741_426_i32); + pub const STATUS_EVENT_DONE: NTSTATUS = NTSTATUS(1_073_741_842_i32); + pub const STATUS_EVENT_PENDING: NTSTATUS = NTSTATUS(1_073_741_843_i32); + pub const STATUS_EXECUTABLE_MEMORY_WRITE: NTSTATUS = NTSTATUS(-1_073_739_997_i32); + pub const STATUS_EXPIRED_HANDLE: NTSTATUS = NTSTATUS(-1_072_103_328_i32); + pub const STATUS_EXTERNAL_BACKING_PROVIDER_UNKNOWN: NTSTATUS = NTSTATUS(-1_073_740_690_i32); + pub const STATUS_EXTERNAL_SYSKEY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_639_i32); + pub const STATUS_EXTRANEOUS_INFORMATION: NTSTATUS = NTSTATUS(-2_147_483_625_i32); + pub const STATUS_FAILED_DRIVER_ENTRY: NTSTATUS = NTSTATUS(-1_073_740_955_i32); + pub const STATUS_FAILED_STACK_SWITCH: NTSTATUS = NTSTATUS(-1_073_740_941_i32); + pub const STATUS_FAIL_CHECK: NTSTATUS = NTSTATUS(-1_073_741_271_i32); + pub const STATUS_FAIL_FAST_EXCEPTION: NTSTATUS = NTSTATUS(-1_073_740_286_i32); + pub const STATUS_FASTPATH_REJECTED: NTSTATUS = NTSTATUS(-1_073_700_844_i32); + pub const STATUS_FATAL_APP_EXIT: NTSTATUS = NTSTATUS(1_073_741_845_i32); + pub const STATUS_FATAL_MEMORY_EXHAUSTION: NTSTATUS = NTSTATUS(-1_073_741_395_i32); + pub const STATUS_FATAL_USER_CALLBACK_EXCEPTION: NTSTATUS = NTSTATUS(-1_073_740_771_i32); + pub const STATUS_FILEMARK_DETECTED: NTSTATUS = NTSTATUS(-2_147_483_621_i32); + pub const STATUS_FILES_OPEN: NTSTATUS = NTSTATUS(-1_073_741_561_i32); + pub const STATUS_FILE_CHECKED_OUT: NTSTATUS = NTSTATUS(-1_073_739_519_i32); + pub const STATUS_FILE_CLOSED: NTSTATUS = NTSTATUS(-1_073_741_528_i32); + pub const STATUS_FILE_CORRUPT_ERROR: NTSTATUS = NTSTATUS(-1_073_741_566_i32); + pub const STATUS_FILE_DELETED: NTSTATUS = NTSTATUS(-1_073_741_533_i32); + pub const STATUS_FILE_ENCRYPTED: NTSTATUS = NTSTATUS(-1_073_741_165_i32); + pub const STATUS_FILE_FORCED_CLOSED: NTSTATUS = NTSTATUS(-1_073_741_642_i32); + pub const STATUS_FILE_HANDLE_REVOKED: NTSTATUS = NTSTATUS(-1_073_739_504_i32); + pub const STATUS_FILE_IDENTITY_NOT_PERSISTENT: NTSTATUS = NTSTATUS(-1_072_103_370_i32); + pub const STATUS_FILE_INVALID: NTSTATUS = NTSTATUS(-1_073_741_672_i32); + pub const STATUS_FILE_IS_A_DIRECTORY: NTSTATUS = NTSTATUS(-1_073_741_638_i32); + pub const STATUS_FILE_IS_OFFLINE: NTSTATUS = NTSTATUS(-1_073_741_209_i32); + pub const STATUS_FILE_LOCKED_WITH_ONLY_READERS: NTSTATUS = NTSTATUS(298i32); + pub const STATUS_FILE_LOCKED_WITH_WRITERS: NTSTATUS = NTSTATUS(299i32); + pub const STATUS_FILE_LOCK_CONFLICT: NTSTATUS = NTSTATUS(-1_073_741_740_i32); + pub const STATUS_FILE_METADATA_OPTIMIZATION_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_073_741_397_i32); + pub const STATUS_FILE_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_073_740_697_i32); + pub const STATUS_FILE_NOT_ENCRYPTED: NTSTATUS = NTSTATUS(-1_073_741_167_i32); + pub const STATUS_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_620_i32); + pub const STATUS_FILE_PROTECTED_UNDER_DPL: NTSTATUS = NTSTATUS(-1_073_740_637_i32); + pub const STATUS_FILE_RENAMED: NTSTATUS = NTSTATUS(-1_073_741_611_i32); + pub const STATUS_FILE_SNAP_INVALID_PARAMETER: NTSTATUS = NTSTATUS(-1_073_679_099_i32); + pub const STATUS_FILE_SNAP_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_073_679_104_i32); + pub const STATUS_FILE_SNAP_IO_NOT_COORDINATED: NTSTATUS = NTSTATUS(-1_073_679_101_i32); + pub const STATUS_FILE_SNAP_MODIFY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_679_102_i32); + pub const STATUS_FILE_SNAP_UNEXPECTED_ERROR: NTSTATUS = NTSTATUS(-1_073_679_100_i32); + pub const STATUS_FILE_SNAP_USER_SECTION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_679_103_i32); + pub const STATUS_FILE_SYSTEM_LIMITATION: NTSTATUS = NTSTATUS(-1_073_740_761_i32); + pub const STATUS_FILE_SYSTEM_VIRTUALIZATION_BUSY: NTSTATUS = NTSTATUS(-1_073_689_085_i32); + pub const STATUS_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION: NTSTATUS = NTSTATUS(-1_073_689_083_i32); + pub const STATUS_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT: NTSTATUS = NTSTATUS(-1_073_689_086_i32); + pub const STATUS_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN: NTSTATUS = NTSTATUS(-1_073_689_084_i32); + pub const STATUS_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE: NTSTATUS = NTSTATUS(-1_073_689_087_i32); + pub const STATUS_FILE_TOO_LARGE: NTSTATUS = NTSTATUS(-1_073_739_516_i32); + pub const STATUS_FIRMWARE_IMAGE_INVALID: NTSTATUS = NTSTATUS(-1_073_740_667_i32); + pub const STATUS_FIRMWARE_SLOT_INVALID: NTSTATUS = NTSTATUS(-1_073_740_668_i32); + pub const STATUS_FIRMWARE_UPDATED: NTSTATUS = NTSTATUS(1_073_741_868_i32); + pub const STATUS_FLOATED_SECTION: NTSTATUS = NTSTATUS(-1_072_103_349_i32); + pub const STATUS_FLOAT_DENORMAL_OPERAND: NTSTATUS = NTSTATUS(-1_073_741_683_i32); + pub const STATUS_FLOAT_DIVIDE_BY_ZERO: NTSTATUS = NTSTATUS(-1_073_741_682_i32); + pub const STATUS_FLOAT_INEXACT_RESULT: NTSTATUS = NTSTATUS(-1_073_741_681_i32); + pub const STATUS_FLOAT_INVALID_OPERATION: NTSTATUS = NTSTATUS(-1_073_741_680_i32); + pub const STATUS_FLOAT_MULTIPLE_FAULTS: NTSTATUS = NTSTATUS(-1_073_741_132_i32); + pub const STATUS_FLOAT_MULTIPLE_TRAPS: NTSTATUS = NTSTATUS(-1_073_741_131_i32); + pub const STATUS_FLOAT_OVERFLOW: NTSTATUS = NTSTATUS(-1_073_741_679_i32); + pub const STATUS_FLOAT_STACK_CHECK: NTSTATUS = NTSTATUS(-1_073_741_678_i32); + pub const STATUS_FLOAT_UNDERFLOW: NTSTATUS = NTSTATUS(-1_073_741_677_i32); + pub const STATUS_FLOPPY_BAD_REGISTERS: NTSTATUS = NTSTATUS(-1_073_741_464_i32); + pub const STATUS_FLOPPY_ID_MARK_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_467_i32); + pub const STATUS_FLOPPY_UNKNOWN_ERROR: NTSTATUS = NTSTATUS(-1_073_741_465_i32); + pub const STATUS_FLOPPY_VOLUME: NTSTATUS = NTSTATUS(-1_073_741_468_i32); + pub const STATUS_FLOPPY_WRONG_CYLINDER: NTSTATUS = NTSTATUS(-1_073_741_466_i32); + pub const STATUS_FLT_ALREADY_ENLISTED: NTSTATUS = NTSTATUS(-1_071_906_789_i32); + pub const STATUS_FLT_BUFFER_TOO_SMALL: NTSTATUS = NTSTATUS(-2_145_648_639_i32); + pub const STATUS_FLT_CBDQ_DISABLED: NTSTATUS = NTSTATUS(-1_071_906_802_i32); + pub const STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_906_794_i32); + pub const STATUS_FLT_CONTEXT_ALREADY_DEFINED: NTSTATUS = NTSTATUS(-1_071_906_814_i32); + pub const STATUS_FLT_CONTEXT_ALREADY_LINKED: NTSTATUS = NTSTATUS(-1_071_906_788_i32); + pub const STATUS_FLT_DELETING_OBJECT: NTSTATUS = NTSTATUS(-1_071_906_805_i32); + pub const STATUS_FLT_DISALLOW_FAST_IO: NTSTATUS = NTSTATUS(-1_071_906_812_i32); + pub const STATUS_FLT_DISALLOW_FSFILTER_IO: i32 = -1_071_906_812_i32; + pub const STATUS_FLT_DO_NOT_ATTACH: NTSTATUS = NTSTATUS(-1_071_906_801_i32); + pub const STATUS_FLT_DO_NOT_DETACH: NTSTATUS = NTSTATUS(-1_071_906_800_i32); + pub const STATUS_FLT_DUPLICATE_ENTRY: NTSTATUS = NTSTATUS(-1_071_906_803_i32); + pub const STATUS_FLT_FILTER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_906_797_i32); + pub const STATUS_FLT_FILTER_NOT_READY: NTSTATUS = NTSTATUS(-1_071_906_808_i32); + pub const STATUS_FLT_INSTANCE_ALTITUDE_COLLISION: NTSTATUS = NTSTATUS(-1_071_906_799_i32); + pub const STATUS_FLT_INSTANCE_NAME_COLLISION: NTSTATUS = NTSTATUS(-1_071_906_798_i32); + pub const STATUS_FLT_INSTANCE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_906_795_i32); + pub const STATUS_FLT_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1_071_906_806_i32); + pub const STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST: NTSTATUS = NTSTATUS(-1_071_906_813_i32); + pub const STATUS_FLT_INVALID_CONTEXT_REGISTRATION: NTSTATUS = NTSTATUS(-1_071_906_793_i32); + pub const STATUS_FLT_INVALID_NAME_REQUEST: NTSTATUS = NTSTATUS(-1_071_906_811_i32); + pub const STATUS_FLT_IO_COMPLETE: NTSTATUS = NTSTATUS(1_835_009_i32); + pub const STATUS_FLT_MUST_BE_NONPAGED_POOL: NTSTATUS = NTSTATUS(-1_071_906_804_i32); + pub const STATUS_FLT_NAME_CACHE_MISS: NTSTATUS = NTSTATUS(-1_071_906_792_i32); + pub const STATUS_FLT_NOT_INITIALIZED: NTSTATUS = NTSTATUS(-1_071_906_809_i32); + pub const STATUS_FLT_NOT_SAFE_TO_POST_OPERATION: NTSTATUS = NTSTATUS(-1_071_906_810_i32); + pub const STATUS_FLT_NO_DEVICE_OBJECT: NTSTATUS = NTSTATUS(-1_071_906_791_i32); + pub const STATUS_FLT_NO_HANDLER_DEFINED: NTSTATUS = NTSTATUS(-1_071_906_815_i32); + pub const STATUS_FLT_NO_WAITER_FOR_REPLY: NTSTATUS = NTSTATUS(-1_071_906_784_i32); + pub const STATUS_FLT_POST_OPERATION_CLEANUP: NTSTATUS = NTSTATUS(-1_071_906_807_i32); + pub const STATUS_FLT_REGISTRATION_BUSY: NTSTATUS = NTSTATUS(-1_071_906_781_i32); + pub const STATUS_FLT_VOLUME_ALREADY_MOUNTED: NTSTATUS = NTSTATUS(-1_071_906_790_i32); + pub const STATUS_FLT_VOLUME_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_906_796_i32); + pub const STATUS_FLT_WCOS_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_906_780_i32); + pub const STATUS_FORMS_AUTH_REQUIRED: NTSTATUS = NTSTATUS(-1_073_739_515_i32); + pub const STATUS_FOUND_OUT_OF_SCOPE: NTSTATUS = NTSTATUS(-1_073_741_266_i32); + pub const STATUS_FREE_SPACE_TOO_FRAGMENTED: NTSTATUS = NTSTATUS(-1_073_740_645_i32); + pub const STATUS_FREE_VM_NOT_AT_BASE: NTSTATUS = NTSTATUS(-1_073_741_665_i32); + pub const STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY: NTSTATUS = NTSTATUS(294i32); + pub const STATUS_FS_DRIVER_REQUIRED: NTSTATUS = NTSTATUS(-1_073_741_412_i32); + pub const STATUS_FS_METADATA_INCONSISTENT: NTSTATUS = NTSTATUS(-1_073_740_520_i32); + pub const STATUS_FT_DI_SCAN_REQUIRED: NTSTATUS = NTSTATUS(-1_073_740_692_i32); + pub const STATUS_FT_MISSING_MEMBER: NTSTATUS = NTSTATUS(-1_073_741_473_i32); + pub const STATUS_FT_ORPHANING: NTSTATUS = NTSTATUS(-1_073_741_459_i32); + pub const STATUS_FT_READ_FAILURE: NTSTATUS = NTSTATUS(-1_073_740_629_i32); + pub const STATUS_FT_READ_FROM_COPY: NTSTATUS = NTSTATUS(1_073_741_877_i32); + pub const STATUS_FT_READ_FROM_COPY_FAILURE: NTSTATUS = NTSTATUS(-1_073_740_609_i32); + pub const STATUS_FT_READ_RECOVERY_FROM_BACKUP: NTSTATUS = NTSTATUS(1_073_741_834_i32); + pub const STATUS_FT_WRITE_FAILURE: NTSTATUS = NTSTATUS(-1_073_740_693_i32); + pub const STATUS_FT_WRITE_RECOVERY: NTSTATUS = NTSTATUS(1_073_741_835_i32); + pub const STATUS_FULLSCREEN_MODE: NTSTATUS = NTSTATUS(-1_073_741_479_i32); + pub const STATUS_FVE_ACTION_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_071_579_127_i32); + pub const STATUS_FVE_AUTH_INVALID_APPLICATION: NTSTATUS = NTSTATUS(-1_071_579_109_i32); + pub const STATUS_FVE_AUTH_INVALID_CONFIG: NTSTATUS = NTSTATUS(-1_071_579_108_i32); + pub const STATUS_FVE_BAD_DATA: NTSTATUS = NTSTATUS(-1_071_579_126_i32); + pub const STATUS_FVE_BAD_INFORMATION: NTSTATUS = NTSTATUS(-1_071_579_134_i32); + pub const STATUS_FVE_BAD_METADATA_POINTER: NTSTATUS = NTSTATUS(-1_071_579_105_i32); + pub const STATUS_FVE_BAD_PARTITION_SIZE: NTSTATUS = NTSTATUS(-1_071_579_131_i32); + pub const STATUS_FVE_CONV_READ_ERROR: NTSTATUS = NTSTATUS(-1_071_579_123_i32); + pub const STATUS_FVE_CONV_RECOVERY_FAILED: NTSTATUS = NTSTATUS(-1_071_579_096_i32); + pub const STATUS_FVE_CONV_WRITE_ERROR: NTSTATUS = NTSTATUS(-1_071_579_122_i32); + pub const STATUS_FVE_DATASET_FULL: NTSTATUS = NTSTATUS(-1_071_579_069_i32); + pub const STATUS_FVE_DEBUGGER_ENABLED: NTSTATUS = NTSTATUS(-1_071_579_107_i32); + pub const STATUS_FVE_DEVICE_LOCKEDOUT: NTSTATUS = NTSTATUS(-1_071_579_077_i32); + pub const STATUS_FVE_DRY_RUN_FAILED: NTSTATUS = NTSTATUS(-1_071_579_106_i32); + pub const STATUS_FVE_EDRIVE_BAND_ENUMERATION_FAILED: NTSTATUS = NTSTATUS(-1_071_579_071_i32); + pub const STATUS_FVE_EDRIVE_DRY_RUN_FAILED: NTSTATUS = NTSTATUS(-1_071_579_080_i32); + pub const STATUS_FVE_ENH_PIN_INVALID: NTSTATUS = NTSTATUS(-1_071_579_087_i32); + pub const STATUS_FVE_FAILED_AUTHENTICATION: NTSTATUS = NTSTATUS(-1_071_579_119_i32); + pub const STATUS_FVE_FAILED_SECTOR_SIZE: NTSTATUS = NTSTATUS(-1_071_579_120_i32); + pub const STATUS_FVE_FAILED_WRONG_FS: NTSTATUS = NTSTATUS(-1_071_579_132_i32); + pub const STATUS_FVE_FS_MOUNTED: NTSTATUS = NTSTATUS(-1_071_579_129_i32); + pub const STATUS_FVE_FS_NOT_EXTENDED: NTSTATUS = NTSTATUS(-1_071_579_130_i32); + pub const STATUS_FVE_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGE: NTSTATUS = NTSTATUS(-1_071_579_086_i32); + pub const STATUS_FVE_INVALID_DATUM_TYPE: NTSTATUS = NTSTATUS(-1_071_579_094_i32); + pub const STATUS_FVE_KEYFILE_INVALID: NTSTATUS = NTSTATUS(-1_071_579_116_i32); + pub const STATUS_FVE_KEYFILE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_579_117_i32); + pub const STATUS_FVE_KEYFILE_NO_VMK: NTSTATUS = NTSTATUS(-1_071_579_115_i32); + pub const STATUS_FVE_LOCKED_VOLUME: NTSTATUS = NTSTATUS(-1_071_579_136_i32); + pub const STATUS_FVE_METADATA_FULL: NTSTATUS = NTSTATUS(-1_071_579_068_i32); + pub const STATUS_FVE_MOR_FAILED: NTSTATUS = NTSTATUS(-1_071_579_099_i32); + pub const STATUS_FVE_NOT_ALLOWED_ON_CLUSTER: NTSTATUS = NTSTATUS(-1_071_579_083_i32); + pub const STATUS_FVE_NOT_ALLOWED_ON_CSV_STACK: NTSTATUS = NTSTATUS(-1_071_579_084_i32); + pub const STATUS_FVE_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTING: NTSTATUS = NTSTATUS(-1_071_579_082_i32); + pub const STATUS_FVE_NOT_DATA_VOLUME: NTSTATUS = NTSTATUS(-1_071_579_124_i32); + pub const STATUS_FVE_NOT_DE_VOLUME: NTSTATUS = NTSTATUS(-1_071_579_075_i32); + pub const STATUS_FVE_NOT_ENCRYPTED: NTSTATUS = NTSTATUS(-1_071_579_135_i32); + pub const STATUS_FVE_NOT_OS_VOLUME: NTSTATUS = NTSTATUS(-1_071_579_118_i32); + pub const STATUS_FVE_NO_AUTOUNLOCK_MASTER_KEY: NTSTATUS = NTSTATUS(-1_071_579_100_i32); + pub const STATUS_FVE_NO_FEATURE_LICENSE: NTSTATUS = NTSTATUS(-1_071_579_098_i32); + pub const STATUS_FVE_NO_LICENSE: NTSTATUS = NTSTATUS(-1_071_579_128_i32); + pub const STATUS_FVE_OLD_METADATA_COPY: NTSTATUS = NTSTATUS(-1_071_579_104_i32); + pub const STATUS_FVE_OSV_KSR_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_071_579_072_i32); + pub const STATUS_FVE_OVERLAPPED_UPDATE: NTSTATUS = NTSTATUS(-1_071_579_121_i32); + pub const STATUS_FVE_PARTIAL_METADATA: NTSTATUS = NTSTATUS(-2_145_320_959_i32); + pub const STATUS_FVE_PIN_INVALID: NTSTATUS = NTSTATUS(-1_071_579_110_i32); + pub const STATUS_FVE_POLICY_ON_RDV_EXCLUSION_LIST: NTSTATUS = NTSTATUS(-1_071_579_070_i32); + pub const STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_071_579_097_i32); + pub const STATUS_FVE_PROTECTION_CANNOT_BE_DISABLED: NTSTATUS = NTSTATUS(-1_071_579_073_i32); + pub const STATUS_FVE_PROTECTION_DISABLED: NTSTATUS = NTSTATUS(-1_071_579_074_i32); + pub const STATUS_FVE_RAW_ACCESS: NTSTATUS = NTSTATUS(-1_071_579_102_i32); + pub const STATUS_FVE_RAW_BLOCKED: NTSTATUS = NTSTATUS(-1_071_579_101_i32); + pub const STATUS_FVE_REBOOT_REQUIRED: NTSTATUS = NTSTATUS(-1_071_579_103_i32); + pub const STATUS_FVE_SECUREBOOT_CONFIG_CHANGE: NTSTATUS = NTSTATUS(-1_071_579_078_i32); + pub const STATUS_FVE_SECUREBOOT_DISABLED: NTSTATUS = NTSTATUS(-1_071_579_079_i32); + pub const STATUS_FVE_TOO_SMALL: NTSTATUS = NTSTATUS(-1_071_579_133_i32); + pub const STATUS_FVE_TPM_DISABLED: NTSTATUS = NTSTATUS(-1_071_579_114_i32); + pub const STATUS_FVE_TPM_INVALID_PCR: NTSTATUS = NTSTATUS(-1_071_579_112_i32); + pub const STATUS_FVE_TPM_NO_VMK: NTSTATUS = NTSTATUS(-1_071_579_111_i32); + pub const STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO: NTSTATUS = NTSTATUS(-1_071_579_113_i32); + pub const STATUS_FVE_TRANSIENT_STATE: NTSTATUS = NTSTATUS(-2_145_320_958_i32); + pub const STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG: NTSTATUS = NTSTATUS(-1_071_579_095_i32); + pub const STATUS_FVE_VOLUME_EXTEND_PREVENTS_EOW_DECRYPT: NTSTATUS = NTSTATUS(-1_071_579_076_i32); + pub const STATUS_FVE_VOLUME_NOT_BOUND: NTSTATUS = NTSTATUS(-1_071_579_125_i32); + pub const STATUS_FVE_VOLUME_TOO_SMALL: NTSTATUS = NTSTATUS(-1_071_579_088_i32); + pub const STATUS_FVE_WIPE_CANCEL_NOT_APPLICABLE: NTSTATUS = NTSTATUS(-1_071_579_081_i32); + pub const STATUS_FVE_WIPE_NOT_ALLOWED_ON_TP_STORAGE: NTSTATUS = NTSTATUS(-1_071_579_085_i32); + pub const STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER: NTSTATUS = NTSTATUS(-1_071_513_556_i32); + pub const STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER: NTSTATUS = NTSTATUS(-1_071_513_555_i32); + pub const STATUS_FWP_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1_071_513_591_i32); + pub const STATUS_FWP_BUILTIN_OBJECT: NTSTATUS = NTSTATUS(-1_071_513_577_i32); + pub const STATUS_FWP_CALLOUT_NOTIFICATION_FAILED: NTSTATUS = NTSTATUS(-1_071_513_545_i32); + pub const STATUS_FWP_CALLOUT_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_513_599_i32); + pub const STATUS_FWP_CANNOT_PEND: NTSTATUS = NTSTATUS(-1_071_513_341_i32); + pub const STATUS_FWP_CONDITION_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_513_598_i32); + pub const STATUS_FWP_CONNECTIONS_DISABLED: NTSTATUS = NTSTATUS(-1_071_513_535_i32); + pub const STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT: NTSTATUS = NTSTATUS(-1_071_513_553_i32); + pub const STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER: NTSTATUS = NTSTATUS(-1_071_513_554_i32); + pub const STATUS_FWP_DROP_NOICMP: NTSTATUS = NTSTATUS(-1_071_513_340_i32); + pub const STATUS_FWP_DUPLICATE_AUTH_METHOD: NTSTATUS = NTSTATUS(-1_071_513_540_i32); + pub const STATUS_FWP_DUPLICATE_CONDITION: NTSTATUS = NTSTATUS(-1_071_513_558_i32); + pub const STATUS_FWP_DUPLICATE_KEYMOD: NTSTATUS = NTSTATUS(-1_071_513_557_i32); + pub const STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_071_513_589_i32); + pub const STATUS_FWP_EM_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_513_550_i32); + pub const STATUS_FWP_FILTER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_513_597_i32); + pub const STATUS_FWP_IKEEXT_NOT_RUNNING: NTSTATUS = NTSTATUS(-1_071_513_532_i32); + pub const STATUS_FWP_INCOMPATIBLE_AUTH_METHOD: NTSTATUS = NTSTATUS(-1_071_513_552_i32); + pub const STATUS_FWP_INCOMPATIBLE_CIPHER_TRANSFORM: NTSTATUS = NTSTATUS(-1_071_513_542_i32); + pub const STATUS_FWP_INCOMPATIBLE_DH_GROUP: NTSTATUS = NTSTATUS(-1_071_513_551_i32); + pub const STATUS_FWP_INCOMPATIBLE_LAYER: NTSTATUS = NTSTATUS(-1_071_513_580_i32); + pub const STATUS_FWP_INCOMPATIBLE_SA_STATE: NTSTATUS = NTSTATUS(-1_071_513_573_i32); + pub const STATUS_FWP_INCOMPATIBLE_TXN: NTSTATUS = NTSTATUS(-1_071_513_583_i32); + pub const STATUS_FWP_INJECT_HANDLE_CLOSING: NTSTATUS = NTSTATUS(-1_071_513_343_i32); + pub const STATUS_FWP_INJECT_HANDLE_STALE: NTSTATUS = NTSTATUS(-1_071_513_342_i32); + pub const STATUS_FWP_INVALID_ACTION_TYPE: NTSTATUS = NTSTATUS(-1_071_513_564_i32); + pub const STATUS_FWP_INVALID_AUTH_TRANSFORM: NTSTATUS = NTSTATUS(-1_071_513_544_i32); + pub const STATUS_FWP_INVALID_CIPHER_TRANSFORM: NTSTATUS = NTSTATUS(-1_071_513_543_i32); + pub const STATUS_FWP_INVALID_DNS_NAME: NTSTATUS = NTSTATUS(-1_071_513_534_i32); + pub const STATUS_FWP_INVALID_ENUMERATOR: NTSTATUS = NTSTATUS(-1_071_513_571_i32); + pub const STATUS_FWP_INVALID_FLAGS: NTSTATUS = NTSTATUS(-1_071_513_570_i32); + pub const STATUS_FWP_INVALID_INTERVAL: NTSTATUS = NTSTATUS(-1_071_513_567_i32); + pub const STATUS_FWP_INVALID_NET_MASK: NTSTATUS = NTSTATUS(-1_071_513_569_i32); + pub const STATUS_FWP_INVALID_PARAMETER: NTSTATUS = NTSTATUS(-1_071_513_547_i32); + pub const STATUS_FWP_INVALID_RANGE: NTSTATUS = NTSTATUS(-1_071_513_568_i32); + pub const STATUS_FWP_INVALID_TRANSFORM_COMBINATION: NTSTATUS = NTSTATUS(-1_071_513_541_i32); + pub const STATUS_FWP_INVALID_TUNNEL_ENDPOINT: NTSTATUS = NTSTATUS(-1_071_513_539_i32); + pub const STATUS_FWP_INVALID_WEIGHT: NTSTATUS = NTSTATUS(-1_071_513_563_i32); + pub const STATUS_FWP_IN_USE: NTSTATUS = NTSTATUS(-1_071_513_590_i32); + pub const STATUS_FWP_KEY_DICTATION_INVALID_KEYING_MATERIAL: NTSTATUS = NTSTATUS(-1_071_513_536_i32); + pub const STATUS_FWP_KEY_DICTATOR_ALREADY_REGISTERED: NTSTATUS = NTSTATUS(-1_071_513_537_i32); + pub const STATUS_FWP_KM_CLIENTS_ONLY: NTSTATUS = NTSTATUS(-1_071_513_579_i32); + pub const STATUS_FWP_L2_DRIVER_NOT_READY: NTSTATUS = NTSTATUS(-1_071_513_538_i32); + pub const STATUS_FWP_LAYER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_513_596_i32); + pub const STATUS_FWP_LIFETIME_MISMATCH: NTSTATUS = NTSTATUS(-1_071_513_578_i32); + pub const STATUS_FWP_MATCH_TYPE_MISMATCH: NTSTATUS = NTSTATUS(-1_071_513_562_i32); + pub const STATUS_FWP_NET_EVENTS_DISABLED: NTSTATUS = NTSTATUS(-1_071_513_581_i32); + pub const STATUS_FWP_NEVER_MATCH: NTSTATUS = NTSTATUS(-1_071_513_549_i32); + pub const STATUS_FWP_NOTIFICATION_DROPPED: NTSTATUS = NTSTATUS(-1_071_513_575_i32); + pub const STATUS_FWP_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_513_592_i32); + pub const STATUS_FWP_NO_TXN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_071_513_587_i32); + pub const STATUS_FWP_NULL_DISPLAY_NAME: NTSTATUS = NTSTATUS(-1_071_513_565_i32); + pub const STATUS_FWP_NULL_POINTER: NTSTATUS = NTSTATUS(-1_071_513_572_i32); + pub const STATUS_FWP_OUT_OF_BOUNDS: NTSTATUS = NTSTATUS(-1_071_513_560_i32); + pub const STATUS_FWP_PROVIDER_CONTEXT_MISMATCH: NTSTATUS = NTSTATUS(-1_071_513_548_i32); + pub const STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_513_594_i32); + pub const STATUS_FWP_PROVIDER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_513_595_i32); + pub const STATUS_FWP_RESERVED: NTSTATUS = NTSTATUS(-1_071_513_559_i32); + pub const STATUS_FWP_SESSION_ABORTED: NTSTATUS = NTSTATUS(-1_071_513_584_i32); + pub const STATUS_FWP_STILL_ON: NTSTATUS = NTSTATUS(-1_071_513_533_i32); + pub const STATUS_FWP_SUBLAYER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_513_593_i32); + pub const STATUS_FWP_TCPIP_NOT_READY: NTSTATUS = NTSTATUS(-1_071_513_344_i32); + pub const STATUS_FWP_TIMEOUT: NTSTATUS = NTSTATUS(-1_071_513_582_i32); + pub const STATUS_FWP_TOO_MANY_CALLOUTS: NTSTATUS = NTSTATUS(-1_071_513_576_i32); + pub const STATUS_FWP_TOO_MANY_SUBLAYERS: NTSTATUS = NTSTATUS(-1_071_513_546_i32); + pub const STATUS_FWP_TRAFFIC_MISMATCH: NTSTATUS = NTSTATUS(-1_071_513_574_i32); + pub const STATUS_FWP_TXN_ABORTED: NTSTATUS = NTSTATUS(-1_071_513_585_i32); + pub const STATUS_FWP_TXN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_071_513_586_i32); + pub const STATUS_FWP_TYPE_MISMATCH: NTSTATUS = NTSTATUS(-1_071_513_561_i32); + pub const STATUS_FWP_WRONG_SESSION: NTSTATUS = NTSTATUS(-1_071_513_588_i32); + pub const STATUS_FWP_ZERO_LENGTH_ARRAY: NTSTATUS = NTSTATUS(-1_071_513_566_i32); + pub const STATUS_GDI_HANDLE_LEAK: NTSTATUS = NTSTATUS(-2_143_354_879_i32); + pub const STATUS_GENERIC_COMMAND_FAILED: NTSTATUS = NTSTATUS(-1_072_365_530_i32); + pub const STATUS_GENERIC_NOT_MAPPED: NTSTATUS = NTSTATUS(-1_073_741_594_i32); + pub const STATUS_GHOSTED: NTSTATUS = NTSTATUS(303i32); + pub const STATUS_GPIO_CLIENT_INFORMATION_INVALID: NTSTATUS = NTSTATUS(-1_073_700_574_i32); + pub const STATUS_GPIO_INCOMPATIBLE_CONNECT_MODE: NTSTATUS = NTSTATUS(-1_073_700_570_i32); + pub const STATUS_GPIO_INTERRUPT_ALREADY_UNMASKED: NTSTATUS = NTSTATUS(-2_147_442_393_i32); + pub const STATUS_GPIO_INVALID_REGISTRATION_PACKET: NTSTATUS = NTSTATUS(-1_073_700_572_i32); + pub const STATUS_GPIO_OPERATION_DENIED: NTSTATUS = NTSTATUS(-1_073_700_571_i32); + pub const STATUS_GPIO_VERSION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_700_573_i32); + pub const STATUS_GRACEFUL_DISCONNECT: NTSTATUS = NTSTATUS(-1_073_741_257_i32); + pub const STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED: NTSTATUS = NTSTATUS(-1_071_774_661_i32); + pub const STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY: NTSTATUS = NTSTATUS(-1_071_774_669_i32); + pub const STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE: NTSTATUS = NTSTATUS(-1_071_774_936_i32); + pub const STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET: NTSTATUS = NTSTATUS(-1_071_774_935_i32); + pub const STATUS_GRAPHICS_ADAPTER_WAS_RESET: NTSTATUS = NTSTATUS(-1_071_775_741_i32); + pub const STATUS_GRAPHICS_ALLOCATION_BUSY: NTSTATUS = NTSTATUS(-1_071_775_486_i32); + pub const STATUS_GRAPHICS_ALLOCATION_CLOSED: NTSTATUS = NTSTATUS(-1_071_775_470_i32); + pub const STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST: NTSTATUS = NTSTATUS(-1_071_775_466_i32); + pub const STATUS_GRAPHICS_ALLOCATION_INVALID: NTSTATUS = NTSTATUS(-1_071_775_482_i32); + pub const STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION: NTSTATUS = NTSTATUS(-1_071_774_886_i32); + pub const STATUS_GRAPHICS_CANNOTCOLORCONVERT: NTSTATUS = NTSTATUS(-1_071_775_736_i32); + pub const STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN: NTSTATUS = NTSTATUS(-1_071_774_909_i32); + pub const STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION: NTSTATUS = NTSTATUS(-1_071_775_479_i32); + pub const STATUS_GRAPHICS_CANT_LOCK_MEMORY: NTSTATUS = NTSTATUS(-1_071_775_487_i32); + pub const STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION: NTSTATUS = NTSTATUS(-1_071_775_471_i32); + pub const STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED: NTSTATUS = NTSTATUS(-1_071_774_670_i32); + pub const STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON: NTSTATUS = NTSTATUS(-1_071_774_667_i32); + pub const STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED: NTSTATUS = NTSTATUS(-1_071_774_668_i32); + pub const STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_719_i32); + pub const STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET: NTSTATUS = NTSTATUS(-1_071_774_884_i32); + pub const STATUS_GRAPHICS_COPP_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_463_i32); + pub const STATUS_GRAPHICS_DATASET_IS_EMPTY: NTSTATUS = NTSTATUS(1_075_708_747_i32); + pub const STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING: NTSTATUS = NTSTATUS(-1_071_774_329_i32); + pub const STATUS_GRAPHICS_DDCCI_INVALID_DATA: NTSTATUS = NTSTATUS(-1_071_774_331_i32); + pub const STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM: NTSTATUS = NTSTATUS(-1_071_774_325_i32); + pub const STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND: NTSTATUS = NTSTATUS(-1_071_774_327_i32); + pub const STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH: NTSTATUS = NTSTATUS(-1_071_774_326_i32); + pub const STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE: NTSTATUS = NTSTATUS(-1_071_774_330_i32); + pub const STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_332_i32); + pub const STATUS_GRAPHICS_DEPENDABLE_CHILD_STATUS: NTSTATUS = NTSTATUS(1_075_708_988_i32); + pub const STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP: NTSTATUS = NTSTATUS(-1_071_774_238_i32); + pub const STATUS_GRAPHICS_DRIVER_MISMATCH: NTSTATUS = NTSTATUS(-1_071_775_735_i32); + pub const STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION: NTSTATUS = NTSTATUS(-1_071_774_939_i32); + pub const STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET: NTSTATUS = NTSTATUS(-1_071_774_945_i32); + pub const STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET: NTSTATUS = NTSTATUS(-1_071_774_947_i32); + pub const STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_904_i32); + pub const STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE: NTSTATUS = NTSTATUS(-1_071_775_232_i32); + pub const STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST: NTSTATUS = NTSTATUS(-1_071_774_335_i32); + pub const STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA: NTSTATUS = NTSTATUS(-1_071_774_333_i32); + pub const STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA: NTSTATUS = NTSTATUS(-1_071_774_334_i32); + pub const STATUS_GRAPHICS_I2C_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_336_i32); + pub const STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT: NTSTATUS = NTSTATUS(-1_071_774_891_i32); + pub const STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE: NTSTATUS = NTSTATUS(-1_071_774_666_i32); + pub const STATUS_GRAPHICS_INDIRECT_DISPLAY_ABANDON_SWAPCHAIN: NTSTATUS = NTSTATUS(-1_071_775_726_i32); + pub const STATUS_GRAPHICS_INDIRECT_DISPLAY_DEVICE_STOPPED: NTSTATUS = NTSTATUS(-1_071_775_725_i32); + pub const STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER: NTSTATUS = NTSTATUS(-1_071_775_743_i32); + pub const STATUS_GRAPHICS_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1_071_774_233_i32); + pub const STATUS_GRAPHICS_INVALID_ACTIVE_REGION: NTSTATUS = NTSTATUS(-1_071_774_965_i32); + pub const STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE: NTSTATUS = NTSTATUS(-1_071_775_468_i32); + pub const STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE: NTSTATUS = NTSTATUS(-1_071_775_469_i32); + pub const STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE: NTSTATUS = NTSTATUS(-1_071_775_472_i32); + pub const STATUS_GRAPHICS_INVALID_CLIENT_TYPE: NTSTATUS = NTSTATUS(-1_071_774_885_i32); + pub const STATUS_GRAPHICS_INVALID_COLORBASIS: NTSTATUS = NTSTATUS(-1_071_774_914_i32); + pub const STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE: NTSTATUS = NTSTATUS(-1_071_774_897_i32); + pub const STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER: NTSTATUS = NTSTATUS(-1_071_775_742_i32); + pub const STATUS_GRAPHICS_INVALID_DRIVER_MODEL: NTSTATUS = NTSTATUS(-1_071_775_740_i32); + pub const STATUS_GRAPHICS_INVALID_FREQUENCY: NTSTATUS = NTSTATUS(-1_071_774_966_i32); + pub const STATUS_GRAPHICS_INVALID_GAMMA_RAMP: NTSTATUS = NTSTATUS(-1_071_774_905_i32); + pub const STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM: NTSTATUS = NTSTATUS(-1_071_774_890_i32); + pub const STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR: NTSTATUS = NTSTATUS(-1_071_774_933_i32); + pub const STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET: NTSTATUS = NTSTATUS(-1_071_774_934_i32); + pub const STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN: NTSTATUS = NTSTATUS(-1_071_774_889_i32); + pub const STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE: NTSTATUS = NTSTATUS(-1_071_774_948_i32); + pub const STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET: NTSTATUS = NTSTATUS(-1_071_774_949_i32); + pub const STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT: NTSTATUS = NTSTATUS(-1_071_774_888_i32); + pub const STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET: NTSTATUS = NTSTATUS(-1_071_774_943_i32); + pub const STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE: NTSTATUS = NTSTATUS(-1_071_774_942_i32); + pub const STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION: NTSTATUS = NTSTATUS(-1_071_774_907_i32); + pub const STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE: NTSTATUS = NTSTATUS(-1_071_774_898_i32); + pub const STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL: NTSTATUS = NTSTATUS(-1_071_774_908_i32); + pub const STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE: NTSTATUS = NTSTATUS(-1_071_774_324_i32); + pub const STATUS_GRAPHICS_INVALID_PIXELFORMAT: NTSTATUS = NTSTATUS(-1_071_774_915_i32); + pub const STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE: NTSTATUS = NTSTATUS(-1_071_774_913_i32); + pub const STATUS_GRAPHICS_INVALID_POINTER: NTSTATUS = NTSTATUS(-1_071_774_236_i32); + pub const STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE: NTSTATUS = NTSTATUS(-1_071_774_918_i32); + pub const STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING: NTSTATUS = NTSTATUS(-1_071_774_894_i32); + pub const STATUS_GRAPHICS_INVALID_STRIDE: NTSTATUS = NTSTATUS(-1_071_774_916_i32); + pub const STATUS_GRAPHICS_INVALID_TOTAL_REGION: NTSTATUS = NTSTATUS(-1_071_774_964_i32); + pub const STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET: NTSTATUS = NTSTATUS(-1_071_774_955_i32); + pub const STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET: NTSTATUS = NTSTATUS(-1_071_774_954_i32); + pub const STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE: NTSTATUS = NTSTATUS(-1_071_774_972_i32); + pub const STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE: NTSTATUS = NTSTATUS(-1_071_774_960_i32); + pub const STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET: NTSTATUS = NTSTATUS(-1_071_774_971_i32); + pub const STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE: NTSTATUS = NTSTATUS(-1_071_774_959_i32); + pub const STATUS_GRAPHICS_INVALID_VIDPN: NTSTATUS = NTSTATUS(-1_071_774_973_i32); + pub const STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH: NTSTATUS = NTSTATUS(-1_071_774_951_i32); + pub const STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET: NTSTATUS = NTSTATUS(-1_071_774_968_i32); + pub const STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET: NTSTATUS = NTSTATUS(-1_071_774_967_i32); + pub const STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE: NTSTATUS = NTSTATUS(-1_071_774_929_i32); + pub const STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY: NTSTATUS = NTSTATUS(-1_071_774_976_i32); + pub const STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON: NTSTATUS = NTSTATUS(-1_071_774_899_i32); + pub const STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE: NTSTATUS = NTSTATUS(-1_071_774_917_i32); + pub const STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED: NTSTATUS = NTSTATUS(-1_071_774_671_i32); + pub const STATUS_GRAPHICS_LEADLINK_START_DEFERRED: NTSTATUS = NTSTATUS(1_075_708_983_i32); + pub const STATUS_GRAPHICS_LINK_CONFIGURATION_IN_PROGRESS: NTSTATUS = NTSTATUS(-2_145_517_568_i32); + pub const STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED: NTSTATUS = NTSTATUS(-1_071_774_887_i32); + pub const STATUS_GRAPHICS_MCA_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1_071_774_328_i32); + pub const STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_237_i32); + pub const STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET: NTSTATUS = NTSTATUS(-1_071_774_956_i32); + pub const STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE: NTSTATUS = NTSTATUS(-1_071_774_940_i32); + pub const STATUS_GRAPHICS_MODE_NOT_IN_MODESET: NTSTATUS = NTSTATUS(-1_071_774_902_i32); + pub const STATUS_GRAPHICS_MODE_NOT_PINNED: NTSTATUS = NTSTATUS(1_075_708_679_i32); + pub const STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET: NTSTATUS = NTSTATUS(-1_071_774_931_i32); + pub const STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE: NTSTATUS = NTSTATUS(-1_071_774_930_i32); + pub const STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET: NTSTATUS = NTSTATUS(-1_071_774_932_i32); + pub const STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER: NTSTATUS = NTSTATUS(-1_071_774_924_i32); + pub const STATUS_GRAPHICS_MONITOR_NOT_CONNECTED: NTSTATUS = NTSTATUS(-1_071_774_920_i32); + pub const STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS: NTSTATUS = NTSTATUS(-1_071_774_323_i32); + pub const STATUS_GRAPHICS_MPO_ALLOCATION_UNPINNED: NTSTATUS = NTSTATUS(-1_071_775_720_i32); + pub const STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_903_i32); + pub const STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER: NTSTATUS = NTSTATUS(-1_071_774_672_i32); + pub const STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER: NTSTATUS = NTSTATUS(-1_071_775_744_i32); + pub const STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER: NTSTATUS = NTSTATUS(-1_071_774_664_i32); + pub const STATUS_GRAPHICS_NO_ACTIVE_VIDPN: NTSTATUS = NTSTATUS(-1_071_774_922_i32); + pub const STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS: NTSTATUS = NTSTATUS(-1_071_774_892_i32); + pub const STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET: NTSTATUS = NTSTATUS(-1_071_774_925_i32); + pub const STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME: NTSTATUS = NTSTATUS(-1_071_774_239_i32); + pub const STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT: NTSTATUS = NTSTATUS(-1_071_774_911_i32); + pub const STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE: NTSTATUS = NTSTATUS(-1_071_774_235_i32); + pub const STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET: NTSTATUS = NTSTATUS(1_075_708_748_i32); + pub const STATUS_GRAPHICS_NO_PREFERRED_MODE: NTSTATUS = NTSTATUS(1_075_708_702_i32); + pub const STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN: NTSTATUS = NTSTATUS(-1_071_774_941_i32); + pub const STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY: NTSTATUS = NTSTATUS(-1_071_774_950_i32); + pub const STATUS_GRAPHICS_NO_VIDEO_MEMORY: NTSTATUS = NTSTATUS(-1_071_775_488_i32); + pub const STATUS_GRAPHICS_NO_VIDPNMGR: NTSTATUS = NTSTATUS(-1_071_774_923_i32); + pub const STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_240_i32); + pub const STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE: NTSTATUS = NTSTATUS(-1_071_774_440_i32); + pub const STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1_071_774_434_i32); + pub const STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET: NTSTATUS = NTSTATUS(-1_071_774_442_i32); + pub const STATUS_GRAPHICS_OPM_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1_071_774_453_i32); + pub const STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST: NTSTATUS = NTSTATUS(-1_071_774_431_i32); + pub const STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS: NTSTATUS = NTSTATUS(-1_071_774_461_i32); + pub const STATUS_GRAPHICS_OPM_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1_071_774_452_i32); + pub const STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST: NTSTATUS = NTSTATUS(-1_071_774_435_i32); + pub const STATUS_GRAPHICS_OPM_INVALID_SRM: NTSTATUS = NTSTATUS(-1_071_774_446_i32); + pub const STATUS_GRAPHICS_OPM_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_464_i32); + pub const STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST: NTSTATUS = NTSTATUS(-1_071_774_459_i32); + pub const STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP: NTSTATUS = NTSTATUS(-1_071_774_444_i32); + pub const STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA: NTSTATUS = NTSTATUS(-1_071_774_443_i32); + pub const STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP: NTSTATUS = NTSTATUS(-1_071_774_445_i32); + pub const STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS: NTSTATUS = NTSTATUS(-1_071_774_436_i32); + pub const STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS: NTSTATUS = NTSTATUS(-1_071_774_433_i32); + pub const STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS: NTSTATUS = NTSTATUS(-1_071_774_438_i32); + pub const STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH: NTSTATUS = NTSTATUS(-1_071_774_441_i32); + pub const STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_432_i32); + pub const STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED: NTSTATUS = NTSTATUS(-1_071_774_449_i32); + pub const STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED: NTSTATUS = NTSTATUS(-1_071_774_448_i32); + pub const STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL: NTSTATUS = NTSTATUS(-1_071_774_234_i32); + pub const STATUS_GRAPHICS_PARTIAL_DATA_POPULATED: NTSTATUS = NTSTATUS(1_075_707_914_i32); + pub const STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY: NTSTATUS = NTSTATUS(-1_071_774_957_i32); + pub const STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED: NTSTATUS = NTSTATUS(1_075_708_753_i32); + pub const STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_906_i32); + pub const STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY: NTSTATUS = NTSTATUS(-1_071_774_937_i32); + pub const STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET: NTSTATUS = NTSTATUS(-1_071_774_958_i32); + pub const STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY: NTSTATUS = NTSTATUS(1_075_708_985_i32); + pub const STATUS_GRAPHICS_PRESENT_BUFFER_NOT_BOUND: NTSTATUS = NTSTATUS(-1_071_775_728_i32); + pub const STATUS_GRAPHICS_PRESENT_DENIED: NTSTATUS = NTSTATUS(-1_071_775_737_i32); + pub const STATUS_GRAPHICS_PRESENT_INVALID_WINDOW: NTSTATUS = NTSTATUS(-1_071_775_729_i32); + pub const STATUS_GRAPHICS_PRESENT_MODE_CHANGED: NTSTATUS = NTSTATUS(-1_071_775_739_i32); + pub const STATUS_GRAPHICS_PRESENT_OCCLUDED: NTSTATUS = NTSTATUS(-1_071_775_738_i32); + pub const STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED: NTSTATUS = NTSTATUS(-1_071_775_733_i32); + pub const STATUS_GRAPHICS_PRESENT_UNOCCLUDED: NTSTATUS = NTSTATUS(-1_071_775_732_i32); + pub const STATUS_GRAPHICS_PVP_HFS_FAILED: NTSTATUS = NTSTATUS(-1_071_774_447_i32); + pub const STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH: NTSTATUS = NTSTATUS(-1_071_774_450_i32); + pub const STATUS_GRAPHICS_RESOURCES_NOT_RELATED: NTSTATUS = NTSTATUS(-1_071_774_928_i32); + pub const STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_071_774_232_i32); + pub const STATUS_GRAPHICS_SKIP_ALLOCATION_PREPARATION: NTSTATUS = NTSTATUS(1_075_708_417_i32); + pub const STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET: NTSTATUS = NTSTATUS(-1_071_774_953_i32); + pub const STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE: NTSTATUS = NTSTATUS(-1_071_774_927_i32); + pub const STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY: NTSTATUS = NTSTATUS(-1_071_774_919_i32); + pub const STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED: NTSTATUS = NTSTATUS(-1_071_774_720_i32); + pub const STATUS_GRAPHICS_STALE_MODESET: NTSTATUS = NTSTATUS(-1_071_774_944_i32); + pub const STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY: NTSTATUS = NTSTATUS(-1_071_774_921_i32); + pub const STATUS_GRAPHICS_START_DEFERRED: NTSTATUS = NTSTATUS(1_075_708_986_i32); + pub const STATUS_GRAPHICS_TARGET_ALREADY_IN_SET: NTSTATUS = NTSTATUS(-1_071_774_952_i32); + pub const STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE: NTSTATUS = NTSTATUS(-1_071_774_926_i32); + pub const STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY: NTSTATUS = NTSTATUS(-1_071_774_912_i32); + pub const STATUS_GRAPHICS_TOO_MANY_REFERENCES: NTSTATUS = NTSTATUS(-1_071_775_485_i32); + pub const STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_071_774_893_i32); + pub const STATUS_GRAPHICS_TRY_AGAIN_LATER: NTSTATUS = NTSTATUS(-1_071_775_484_i32); + pub const STATUS_GRAPHICS_TRY_AGAIN_NOW: NTSTATUS = NTSTATUS(-1_071_775_483_i32); + pub const STATUS_GRAPHICS_UAB_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_462_i32); + pub const STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1_071_774_896_i32); + pub const STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS: NTSTATUS = NTSTATUS(1_075_708_975_i32); + pub const STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE: NTSTATUS = NTSTATUS(-1_071_775_481_i32); + pub const STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED: NTSTATUS = NTSTATUS(-1_071_775_480_i32); + pub const STATUS_GRAPHICS_VAIL_STATE_CHANGED: NTSTATUS = NTSTATUS(-1_071_775_727_i32); + pub const STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES: NTSTATUS = NTSTATUS(-1_071_774_938_i32); + pub const STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_970_i32); + pub const STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE: NTSTATUS = NTSTATUS(-1_071_774_910_i32); + pub const STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_974_i32); + pub const STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_774_975_i32); + pub const STATUS_GRAPHICS_WINDOWDC_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_071_775_731_i32); + pub const STATUS_GRAPHICS_WINDOWLESS_PRESENT_DISABLED: NTSTATUS = NTSTATUS(-1_071_775_730_i32); + pub const STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE: NTSTATUS = NTSTATUS(-1_071_775_467_i32); + pub const STATUS_GROUP_EXISTS: NTSTATUS = NTSTATUS(-1_073_741_723_i32); + pub const STATUS_GUARD_PAGE_VIOLATION: NTSTATUS = NTSTATUS(-2_147_483_647_i32); + pub const STATUS_GUIDS_EXHAUSTED: NTSTATUS = NTSTATUS(-1_073_741_693_i32); + pub const STATUS_GUID_SUBSTITUTION_MADE: NTSTATUS = NTSTATUS(-2_147_483_636_i32); + pub const STATUS_HANDLES_CLOSED: NTSTATUS = NTSTATUS(-2_147_483_638_i32); + pub const STATUS_HANDLE_NOT_CLOSABLE: NTSTATUS = NTSTATUS(-1_073_741_259_i32); + pub const STATUS_HANDLE_NO_LONGER_VALID: NTSTATUS = NTSTATUS(-1_072_103_384_i32); + pub const STATUS_HANDLE_REVOKED: NTSTATUS = NTSTATUS(-1_073_700_858_i32); + pub const STATUS_HARDWARE_MEMORY_ERROR: NTSTATUS = NTSTATUS(-1_073_740_023_i32); + pub const STATUS_HASH_NOT_PRESENT: NTSTATUS = NTSTATUS(-1_073_700_607_i32); + pub const STATUS_HASH_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_700_608_i32); + pub const STATUS_HAS_SYSTEM_CRITICAL_FILES: NTSTATUS = NTSTATUS(-1_073_740_611_i32); + pub const STATUS_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_069_285_373_i32); + pub const STATUS_HDAUDIO_EMPTY_CONNECTION_LIST: NTSTATUS = NTSTATUS(-1_069_285_374_i32); + pub const STATUS_HDAUDIO_NO_LOGICAL_DEVICES_CREATED: NTSTATUS = NTSTATUS(-1_069_285_372_i32); + pub const STATUS_HDAUDIO_NULL_LINKED_LIST_ENTRY: NTSTATUS = NTSTATUS(-1_069_285_371_i32); + pub const STATUS_HEAP_CORRUPTION: NTSTATUS = NTSTATUS(-1_073_740_940_i32); + pub const STATUS_HEURISTIC_DAMAGE_POSSIBLE: NTSTATUS = NTSTATUS(1_075_380_225_i32); + pub const STATUS_HIBERNATED: NTSTATUS = NTSTATUS(1_073_741_866_i32); + pub const STATUS_HIBERNATION_FAILURE: NTSTATUS = NTSTATUS(-1_073_740_783_i32); + pub const STATUS_HIVE_UNLOADED: NTSTATUS = NTSTATUS(-1_073_740_763_i32); + pub const STATUS_HMAC_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_700_863_i32); + pub const STATUS_HOPLIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_700_846_i32); + pub const STATUS_HOST_DOWN: NTSTATUS = NTSTATUS(-1_073_740_976_i32); + pub const STATUS_HOST_UNREACHABLE: NTSTATUS = NTSTATUS(-1_073_741_251_i32); + pub const STATUS_HUNG_DISPLAY_DRIVER_THREAD: NTSTATUS = NTSTATUS(-1_073_740_779_i32); + pub const STATUS_HV_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_070_268_410_i32); + pub const STATUS_HV_ACKNOWLEDGED: NTSTATUS = NTSTATUS(-1_070_268_394_i32); + pub const STATUS_HV_CALL_PENDING: NTSTATUS = NTSTATUS(-1_070_268_295_i32); + pub const STATUS_HV_CPUID_FEATURE_VALIDATION_ERROR: NTSTATUS = NTSTATUS(-1_070_268_356_i32); + pub const STATUS_HV_CPUID_XSAVE_FEATURE_VALIDATION_ERROR: NTSTATUS = NTSTATUS(-1_070_268_355_i32); + pub const STATUS_HV_DEVICE_NOT_IN_DOMAIN: NTSTATUS = NTSTATUS(-1_070_268_298_i32); + pub const STATUS_HV_EVENT_BUFFER_ALREADY_FREED: NTSTATUS = NTSTATUS(-1_070_268_300_i32); + pub const STATUS_HV_FEATURE_UNAVAILABLE: NTSTATUS = NTSTATUS(-1_070_268_386_i32); + pub const STATUS_HV_INACTIVE: NTSTATUS = NTSTATUS(-1_070_268_388_i32); + pub const STATUS_HV_INSUFFICIENT_BUFFER: NTSTATUS = NTSTATUS(-1_070_268_365_i32); + pub const STATUS_HV_INSUFFICIENT_BUFFERS: NTSTATUS = NTSTATUS(-1_070_268_397_i32); + pub const STATUS_HV_INSUFFICIENT_CONTIGUOUS_MEMORY: NTSTATUS = NTSTATUS(-1_070_268_299_i32); + pub const STATUS_HV_INSUFFICIENT_CONTIGUOUS_MEMORY_MIRRORING: NTSTATUS = NTSTATUS(-1_070_268_286_i32); + pub const STATUS_HV_INSUFFICIENT_CONTIGUOUS_ROOT_MEMORY: NTSTATUS = NTSTATUS(-1_070_268_285_i32); + pub const STATUS_HV_INSUFFICIENT_CONTIGUOUS_ROOT_MEMORY_MIRRORING: NTSTATUS = NTSTATUS(-1_070_268_283_i32); + pub const STATUS_HV_INSUFFICIENT_DEVICE_DOMAINS: NTSTATUS = NTSTATUS(-1_070_268_360_i32); + pub const STATUS_HV_INSUFFICIENT_MEMORY: NTSTATUS = NTSTATUS(-1_070_268_405_i32); + pub const STATUS_HV_INSUFFICIENT_MEMORY_MIRRORING: NTSTATUS = NTSTATUS(-1_070_268_287_i32); + pub const STATUS_HV_INSUFFICIENT_ROOT_MEMORY: NTSTATUS = NTSTATUS(-1_070_268_301_i32); + pub const STATUS_HV_INSUFFICIENT_ROOT_MEMORY_MIRRORING: NTSTATUS = NTSTATUS(-1_070_268_284_i32); + pub const STATUS_HV_INVALID_ALIGNMENT: NTSTATUS = NTSTATUS(-1_070_268_412_i32); + pub const STATUS_HV_INVALID_CONNECTION_ID: NTSTATUS = NTSTATUS(-1_070_268_398_i32); + pub const STATUS_HV_INVALID_CPU_GROUP_ID: NTSTATUS = NTSTATUS(-1_070_268_305_i32); + pub const STATUS_HV_INVALID_CPU_GROUP_STATE: NTSTATUS = NTSTATUS(-1_070_268_304_i32); + pub const STATUS_HV_INVALID_DEVICE_ID: NTSTATUS = NTSTATUS(-1_070_268_329_i32); + pub const STATUS_HV_INVALID_DEVICE_STATE: NTSTATUS = NTSTATUS(-1_070_268_328_i32); + pub const STATUS_HV_INVALID_HYPERCALL_CODE: NTSTATUS = NTSTATUS(-1_070_268_414_i32); + pub const STATUS_HV_INVALID_HYPERCALL_INPUT: NTSTATUS = NTSTATUS(-1_070_268_413_i32); + pub const STATUS_HV_INVALID_LP_INDEX: NTSTATUS = NTSTATUS(-1_070_268_351_i32); + pub const STATUS_HV_INVALID_PARAMETER: NTSTATUS = NTSTATUS(-1_070_268_411_i32); + pub const STATUS_HV_INVALID_PARTITION_ID: NTSTATUS = NTSTATUS(-1_070_268_403_i32); + pub const STATUS_HV_INVALID_PARTITION_STATE: NTSTATUS = NTSTATUS(-1_070_268_409_i32); + pub const STATUS_HV_INVALID_PORT_ID: NTSTATUS = NTSTATUS(-1_070_268_399_i32); + pub const STATUS_HV_INVALID_PROXIMITY_DOMAIN_INFO: NTSTATUS = NTSTATUS(-1_070_268_390_i32); + pub const STATUS_HV_INVALID_REGISTER_VALUE: NTSTATUS = NTSTATUS(-1_070_268_336_i32); + pub const STATUS_HV_INVALID_SAVE_RESTORE_STATE: NTSTATUS = NTSTATUS(-1_070_268_393_i32); + pub const STATUS_HV_INVALID_SYNIC_STATE: NTSTATUS = NTSTATUS(-1_070_268_392_i32); + pub const STATUS_HV_INVALID_VP_INDEX: NTSTATUS = NTSTATUS(-1_070_268_402_i32); + pub const STATUS_HV_INVALID_VP_STATE: NTSTATUS = NTSTATUS(-1_070_268_395_i32); + pub const STATUS_HV_INVALID_VTL_STATE: NTSTATUS = NTSTATUS(-1_070_268_335_i32); + pub const STATUS_HV_MSR_ACCESS_FAILED: NTSTATUS = NTSTATUS(-1_070_268_288_i32); + pub const STATUS_HV_NESTED_VM_EXIT: NTSTATUS = NTSTATUS(-1_070_268_297_i32); + pub const STATUS_HV_NOT_ACKNOWLEDGED: NTSTATUS = NTSTATUS(-1_070_268_396_i32); + pub const STATUS_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE: NTSTATUS = NTSTATUS(-1_070_268_302_i32); + pub const STATUS_HV_NOT_PRESENT: NTSTATUS = NTSTATUS(-1_070_264_320_i32); + pub const STATUS_HV_NO_DATA: NTSTATUS = NTSTATUS(-1_070_268_389_i32); + pub const STATUS_HV_NO_RESOURCES: NTSTATUS = NTSTATUS(-1_070_268_387_i32); + pub const STATUS_HV_NX_NOT_DETECTED: NTSTATUS = NTSTATUS(-1_070_268_331_i32); + pub const STATUS_HV_OBJECT_IN_USE: NTSTATUS = NTSTATUS(-1_070_268_391_i32); + pub const STATUS_HV_OPERATION_DENIED: NTSTATUS = NTSTATUS(-1_070_268_408_i32); + pub const STATUS_HV_OPERATION_FAILED: NTSTATUS = NTSTATUS(-1_070_268_303_i32); + pub const STATUS_HV_PAGE_REQUEST_INVALID: NTSTATUS = NTSTATUS(-1_070_268_320_i32); + pub const STATUS_HV_PARTITION_TOO_DEEP: NTSTATUS = NTSTATUS(-1_070_268_404_i32); + pub const STATUS_HV_PENDING_PAGE_REQUESTS: NTSTATUS = NTSTATUS(3_473_497_i32); + pub const STATUS_HV_PROCESSOR_STARTUP_TIMEOUT: NTSTATUS = NTSTATUS(-1_070_268_354_i32); + pub const STATUS_HV_PROPERTY_VALUE_OUT_OF_RANGE: NTSTATUS = NTSTATUS(-1_070_268_406_i32); + pub const STATUS_HV_SMX_ENABLED: NTSTATUS = NTSTATUS(-1_070_268_353_i32); + pub const STATUS_HV_UNKNOWN_PROPERTY: NTSTATUS = NTSTATUS(-1_070_268_407_i32); + pub const STATUS_ILLEGAL_CHARACTER: NTSTATUS = NTSTATUS(-1_073_741_471_i32); + pub const STATUS_ILLEGAL_DLL_RELOCATION: NTSTATUS = NTSTATUS(-1_073_741_207_i32); + pub const STATUS_ILLEGAL_ELEMENT_ADDRESS: NTSTATUS = NTSTATUS(-1_073_741_179_i32); + pub const STATUS_ILLEGAL_FLOAT_CONTEXT: NTSTATUS = NTSTATUS(-1_073_741_494_i32); + pub const STATUS_ILLEGAL_FUNCTION: NTSTATUS = NTSTATUS(-1_073_741_649_i32); + pub const STATUS_ILLEGAL_INSTRUCTION: NTSTATUS = NTSTATUS(-1_073_741_795_i32); + pub const STATUS_ILL_FORMED_PASSWORD: NTSTATUS = NTSTATUS(-1_073_741_717_i32); + pub const STATUS_ILL_FORMED_SERVICE_ENTRY: NTSTATUS = NTSTATUS(-1_073_741_472_i32); + pub const STATUS_IMAGE_ALREADY_LOADED: NTSTATUS = NTSTATUS(-1_073_741_554_i32); + pub const STATUS_IMAGE_ALREADY_LOADED_AS_DLL: NTSTATUS = NTSTATUS(-1_073_741_411_i32); + pub const STATUS_IMAGE_AT_DIFFERENT_BASE: NTSTATUS = NTSTATUS(1_073_741_878_i32); + pub const STATUS_IMAGE_CERT_EXPIRED: NTSTATUS = NTSTATUS(-1_073_740_283_i32); + pub const STATUS_IMAGE_CERT_REVOKED: NTSTATUS = NTSTATUS(-1_073_740_285_i32); + pub const STATUS_IMAGE_CHECKSUM_MISMATCH: NTSTATUS = NTSTATUS(-1_073_741_279_i32); + pub const STATUS_IMAGE_LOADED_AS_PATCH_IMAGE: NTSTATUS = NTSTATUS(-1_073_740_608_i32); + pub const STATUS_IMAGE_MACHINE_TYPE_MISMATCH: NTSTATUS = NTSTATUS(1_073_741_838_i32); + pub const STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE: NTSTATUS = NTSTATUS(1_073_741_859_i32); + pub const STATUS_IMAGE_MP_UP_MISMATCH: NTSTATUS = NTSTATUS(-1_073_741_239_i32); + pub const STATUS_IMAGE_NOT_AT_BASE: NTSTATUS = NTSTATUS(1_073_741_827_i32); + pub const STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT: NTSTATUS = NTSTATUS(-1_073_741_405_i32); + pub const STATUS_IMPLEMENTATION_LIMIT: NTSTATUS = NTSTATUS(-1_073_740_757_i32); + pub const STATUS_INCOMPATIBLE_DRIVER_BLOCKED: NTSTATUS = NTSTATUS(-1_073_740_764_i32); + pub const STATUS_INCOMPATIBLE_FILE_MAP: NTSTATUS = NTSTATUS(-1_073_741_747_i32); + pub const STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING: NTSTATUS = NTSTATUS(-1_073_741_410_i32); + pub const STATUS_INCORRECT_ACCOUNT_TYPE: NTSTATUS = NTSTATUS(-1_073_700_727_i32); + pub const STATUS_INDEX_OUT_OF_BOUNDS: NTSTATUS = NTSTATUS(-1_073_740_591_i32); + pub const STATUS_INDOUBT_TRANSACTIONS_EXIST: NTSTATUS = NTSTATUS(-1_072_103_366_i32); + pub const STATUS_INFO_LENGTH_MISMATCH: NTSTATUS = NTSTATUS(-1_073_741_820_i32); + pub const STATUS_INSTANCE_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_073_741_653_i32); + pub const STATUS_INSTRUCTION_MISALIGNMENT: NTSTATUS = NTSTATUS(-1_073_741_654_i32); + pub const STATUS_INSUFFICIENT_LOGON_INFO: NTSTATUS = NTSTATUS(-1_073_741_232_i32); + pub const STATUS_INSUFFICIENT_NVRAM_RESOURCES: NTSTATUS = NTSTATUS(-1_073_740_716_i32); + pub const STATUS_INSUFFICIENT_POWER: NTSTATUS = NTSTATUS(-1_073_741_090_i32); + pub const STATUS_INSUFFICIENT_RESOURCES: NTSTATUS = NTSTATUS(-1_073_741_670_i32); + pub const STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE: NTSTATUS = NTSTATUS(-1_073_740_778_i32); + pub const STATUS_INSUFFICIENT_VIRTUAL_ADDR_RESOURCES: NTSTATUS = NTSTATUS(-1_073_740_606_i32); + pub const STATUS_INSUFF_SERVER_RESOURCES: NTSTATUS = NTSTATUS(-1_073_741_307_i32); + pub const STATUS_INTEGER_DIVIDE_BY_ZERO: NTSTATUS = NTSTATUS(-1_073_741_676_i32); + pub const STATUS_INTEGER_OVERFLOW: NTSTATUS = NTSTATUS(-1_073_741_675_i32); + pub const STATUS_INTERMIXED_KERNEL_EA_OPERATION: NTSTATUS = NTSTATUS(-1_073_740_687_i32); + pub const STATUS_INTERNAL_DB_CORRUPTION: NTSTATUS = NTSTATUS(-1_073_741_596_i32); + pub const STATUS_INTERNAL_DB_ERROR: NTSTATUS = NTSTATUS(-1_073_741_480_i32); + pub const STATUS_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1_073_741_595_i32); + pub const STATUS_INTERRUPTED: NTSTATUS = NTSTATUS(-1_073_740_523_i32); + pub const STATUS_INTERRUPT_STILL_CONNECTED: NTSTATUS = NTSTATUS(296i32); + pub const STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED: NTSTATUS = NTSTATUS(295i32); + pub const STATUS_INVALID_ACCOUNT_NAME: NTSTATUS = NTSTATUS(-1_073_741_726_i32); + pub const STATUS_INVALID_ACE_CONDITION: NTSTATUS = NTSTATUS(-1_073_741_406_i32); + pub const STATUS_INVALID_ACL: NTSTATUS = NTSTATUS(-1_073_741_705_i32); + pub const STATUS_INVALID_ADDRESS: NTSTATUS = NTSTATUS(-1_073_741_503_i32); + pub const STATUS_INVALID_ADDRESS_COMPONENT: NTSTATUS = NTSTATUS(-1_073_741_305_i32); + pub const STATUS_INVALID_ADDRESS_WILDCARD: NTSTATUS = NTSTATUS(-1_073_741_304_i32); + pub const STATUS_INVALID_BLOCK_LENGTH: NTSTATUS = NTSTATUS(-1_073_741_453_i32); + pub const STATUS_INVALID_BUFFER_SIZE: NTSTATUS = NTSTATUS(-1_073_741_306_i32); + pub const STATUS_INVALID_CAP: NTSTATUS = NTSTATUS(-1_073_740_539_i32); + pub const STATUS_INVALID_CID: NTSTATUS = NTSTATUS(-1_073_741_813_i32); + pub const STATUS_INVALID_COMPUTER_NAME: NTSTATUS = NTSTATUS(-1_073_741_534_i32); + pub const STATUS_INVALID_CONNECTION: NTSTATUS = NTSTATUS(-1_073_741_504_i32); + pub const STATUS_INVALID_CRUNTIME_PARAMETER: NTSTATUS = NTSTATUS(-1_073_740_777_i32); + pub const STATUS_INVALID_DEVICE_OBJECT_PARAMETER: NTSTATUS = NTSTATUS(-1_073_740_951_i32); + pub const STATUS_INVALID_DEVICE_REQUEST: NTSTATUS = NTSTATUS(-1_073_741_808_i32); + pub const STATUS_INVALID_DEVICE_STATE: NTSTATUS = NTSTATUS(-1_073_741_436_i32); + pub const STATUS_INVALID_DISPOSITION: NTSTATUS = NTSTATUS(-1_073_741_786_i32); + pub const STATUS_INVALID_DOMAIN_ROLE: NTSTATUS = NTSTATUS(-1_073_741_602_i32); + pub const STATUS_INVALID_DOMAIN_STATE: NTSTATUS = NTSTATUS(-1_073_741_603_i32); + pub const STATUS_INVALID_EA_FLAG: NTSTATUS = NTSTATUS(-2_147_483_627_i32); + pub const STATUS_INVALID_EA_NAME: NTSTATUS = NTSTATUS(-2_147_483_629_i32); + pub const STATUS_INVALID_EXCEPTION_HANDLER: NTSTATUS = NTSTATUS(-1_073_741_403_i32); + pub const STATUS_INVALID_FIELD_IN_PARAMETER_LIST: NTSTATUS = NTSTATUS(-1_073_740_683_i32); + pub const STATUS_INVALID_FILE_FOR_SECTION: NTSTATUS = NTSTATUS(-1_073_741_792_i32); + pub const STATUS_INVALID_GROUP_ATTRIBUTES: NTSTATUS = NTSTATUS(-1_073_741_660_i32); + pub const STATUS_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1_073_741_816_i32); + pub const STATUS_INVALID_HW_PROFILE: NTSTATUS = NTSTATUS(-1_073_741_216_i32); + pub const STATUS_INVALID_IDN_NORMALIZATION: NTSTATUS = NTSTATUS(-1_073_740_010_i32); + pub const STATUS_INVALID_ID_AUTHORITY: NTSTATUS = NTSTATUS(-1_073_741_692_i32); + pub const STATUS_INVALID_IMAGE_FORMAT: NTSTATUS = NTSTATUS(-1_073_741_701_i32); + pub const STATUS_INVALID_IMAGE_HASH: NTSTATUS = NTSTATUS(-1_073_740_760_i32); + pub const STATUS_INVALID_IMAGE_LE_FORMAT: NTSTATUS = NTSTATUS(-1_073_741_522_i32); + pub const STATUS_INVALID_IMAGE_NE_FORMAT: NTSTATUS = NTSTATUS(-1_073_741_541_i32); + pub const STATUS_INVALID_IMAGE_NOT_MZ: NTSTATUS = NTSTATUS(-1_073_741_521_i32); + pub const STATUS_INVALID_IMAGE_PROTECT: NTSTATUS = NTSTATUS(-1_073_741_520_i32); + pub const STATUS_INVALID_IMAGE_WIN_16: NTSTATUS = NTSTATUS(-1_073_741_519_i32); + pub const STATUS_INVALID_IMAGE_WIN_32: NTSTATUS = NTSTATUS(-1_073_740_967_i32); + pub const STATUS_INVALID_IMAGE_WIN_64: NTSTATUS = NTSTATUS(-1_073_740_966_i32); + pub const STATUS_INVALID_IMPORT_OF_NON_DLL: NTSTATUS = NTSTATUS(-1_073_740_945_i32); + pub const STATUS_INVALID_INFO_CLASS: NTSTATUS = NTSTATUS(-1_073_741_821_i32); + pub const STATUS_INVALID_INITIATOR_TARGET_PATH: NTSTATUS = NTSTATUS(-1_073_740_681_i32); + pub const STATUS_INVALID_KERNEL_INFO_VERSION: NTSTATUS = NTSTATUS(-1_073_700_860_i32); + pub const STATUS_INVALID_LABEL: NTSTATUS = NTSTATUS(-1_073_740_730_i32); + pub const STATUS_INVALID_LDT_DESCRIPTOR: NTSTATUS = NTSTATUS(-1_073_741_542_i32); + pub const STATUS_INVALID_LDT_OFFSET: NTSTATUS = NTSTATUS(-1_073_741_543_i32); + pub const STATUS_INVALID_LDT_SIZE: NTSTATUS = NTSTATUS(-1_073_741_544_i32); + pub const STATUS_INVALID_LEVEL: NTSTATUS = NTSTATUS(-1_073_741_496_i32); + pub const STATUS_INVALID_LOCK_RANGE: NTSTATUS = NTSTATUS(-1_073_741_407_i32); + pub const STATUS_INVALID_LOCK_SEQUENCE: NTSTATUS = NTSTATUS(-1_073_741_794_i32); + pub const STATUS_INVALID_LOGON_HOURS: NTSTATUS = NTSTATUS(-1_073_741_713_i32); + pub const STATUS_INVALID_LOGON_TYPE: NTSTATUS = NTSTATUS(-1_073_741_557_i32); + pub const STATUS_INVALID_MEMBER: NTSTATUS = NTSTATUS(-1_073_741_445_i32); + pub const STATUS_INVALID_MESSAGE: NTSTATUS = NTSTATUS(-1_073_740_030_i32); + pub const STATUS_INVALID_NETWORK_RESPONSE: NTSTATUS = NTSTATUS(-1_073_741_629_i32); + pub const STATUS_INVALID_OFFSET_ALIGNMENT: NTSTATUS = NTSTATUS(-1_073_740_684_i32); + pub const STATUS_INVALID_OPLOCK_PROTOCOL: NTSTATUS = NTSTATUS(-1_073_741_597_i32); + pub const STATUS_INVALID_OWNER: NTSTATUS = NTSTATUS(-1_073_741_734_i32); + pub const STATUS_INVALID_PACKAGE_SID_LENGTH: NTSTATUS = NTSTATUS(-1_073_700_350_i32); + pub const STATUS_INVALID_PAGE_PROTECTION: NTSTATUS = NTSTATUS(-1_073_741_755_i32); + pub const STATUS_INVALID_PARAMETER: NTSTATUS = NTSTATUS(-1_073_741_811_i32); + pub const STATUS_INVALID_PARAMETER_1: NTSTATUS = NTSTATUS(-1_073_741_585_i32); + pub const STATUS_INVALID_PARAMETER_10: NTSTATUS = NTSTATUS(-1_073_741_576_i32); + pub const STATUS_INVALID_PARAMETER_11: NTSTATUS = NTSTATUS(-1_073_741_575_i32); + pub const STATUS_INVALID_PARAMETER_12: NTSTATUS = NTSTATUS(-1_073_741_574_i32); + pub const STATUS_INVALID_PARAMETER_2: NTSTATUS = NTSTATUS(-1_073_741_584_i32); + pub const STATUS_INVALID_PARAMETER_3: NTSTATUS = NTSTATUS(-1_073_741_583_i32); + pub const STATUS_INVALID_PARAMETER_4: NTSTATUS = NTSTATUS(-1_073_741_582_i32); + pub const STATUS_INVALID_PARAMETER_5: NTSTATUS = NTSTATUS(-1_073_741_581_i32); + pub const STATUS_INVALID_PARAMETER_6: NTSTATUS = NTSTATUS(-1_073_741_580_i32); + pub const STATUS_INVALID_PARAMETER_7: NTSTATUS = NTSTATUS(-1_073_741_579_i32); + pub const STATUS_INVALID_PARAMETER_8: NTSTATUS = NTSTATUS(-1_073_741_578_i32); + pub const STATUS_INVALID_PARAMETER_9: NTSTATUS = NTSTATUS(-1_073_741_577_i32); + pub const STATUS_INVALID_PARAMETER_MIX: NTSTATUS = NTSTATUS(-1_073_741_776_i32); + pub const STATUS_INVALID_PEP_INFO_VERSION: NTSTATUS = NTSTATUS(-1_073_700_859_i32); + pub const STATUS_INVALID_PIPE_STATE: NTSTATUS = NTSTATUS(-1_073_741_651_i32); + pub const STATUS_INVALID_PLUGPLAY_DEVICE_PATH: NTSTATUS = NTSTATUS(-1_073_741_215_i32); + pub const STATUS_INVALID_PORT_ATTRIBUTES: NTSTATUS = NTSTATUS(-1_073_741_778_i32); + pub const STATUS_INVALID_PORT_HANDLE: NTSTATUS = NTSTATUS(-1_073_741_758_i32); + pub const STATUS_INVALID_PRIMARY_GROUP: NTSTATUS = NTSTATUS(-1_073_741_733_i32); + pub const STATUS_INVALID_QUOTA_LOWER: NTSTATUS = NTSTATUS(-1_073_741_775_i32); + pub const STATUS_INVALID_READ_MODE: NTSTATUS = NTSTATUS(-1_073_741_644_i32); + pub const STATUS_INVALID_RUNLEVEL_SETTING: NTSTATUS = NTSTATUS(-1_073_700_542_i32); + pub const STATUS_INVALID_SECURITY_DESCR: NTSTATUS = NTSTATUS(-1_073_741_703_i32); + pub const STATUS_INVALID_SERVER_STATE: NTSTATUS = NTSTATUS(-1_073_741_604_i32); + pub const STATUS_INVALID_SESSION: NTSTATUS = NTSTATUS(-1_073_740_715_i32); + pub const STATUS_INVALID_SID: NTSTATUS = NTSTATUS(-1_073_741_704_i32); + pub const STATUS_INVALID_SIGNATURE: NTSTATUS = NTSTATUS(-1_073_700_864_i32); + pub const STATUS_INVALID_STATE_TRANSITION: NTSTATUS = NTSTATUS(-1_073_700_861_i32); + pub const STATUS_INVALID_SUB_AUTHORITY: NTSTATUS = NTSTATUS(-1_073_741_706_i32); + pub const STATUS_INVALID_SYSTEM_SERVICE: NTSTATUS = NTSTATUS(-1_073_741_796_i32); + pub const STATUS_INVALID_TASK_INDEX: NTSTATUS = NTSTATUS(-1_073_740_543_i32); + pub const STATUS_INVALID_TASK_NAME: NTSTATUS = NTSTATUS(-1_073_740_544_i32); + pub const STATUS_INVALID_THREAD: NTSTATUS = NTSTATUS(-1_073_740_004_i32); + pub const STATUS_INVALID_TOKEN: NTSTATUS = NTSTATUS(-1_073_740_699_i32); + pub const STATUS_INVALID_TRANSACTION: NTSTATUS = NTSTATUS(-1_072_103_422_i32); + pub const STATUS_INVALID_UNWIND_TARGET: NTSTATUS = NTSTATUS(-1_073_741_783_i32); + pub const STATUS_INVALID_USER_BUFFER: NTSTATUS = NTSTATUS(-1_073_741_592_i32); + pub const STATUS_INVALID_USER_PRINCIPAL_NAME: NTSTATUS = NTSTATUS(-1_073_740_772_i32); + pub const STATUS_INVALID_VARIANT: NTSTATUS = NTSTATUS(-1_073_741_262_i32); + pub const STATUS_INVALID_VIEW_SIZE: NTSTATUS = NTSTATUS(-1_073_741_793_i32); + pub const STATUS_INVALID_VOLUME_LABEL: NTSTATUS = NTSTATUS(-1_073_741_690_i32); + pub const STATUS_INVALID_WEIGHT: NTSTATUS = NTSTATUS(-1_073_740_712_i32); + pub const STATUS_INVALID_WORKSTATION: NTSTATUS = NTSTATUS(-1_073_741_712_i32); + pub const STATUS_IN_PAGE_ERROR: NTSTATUS = NTSTATUS(-1_073_741_818_i32); + pub const STATUS_IORING_COMPLETION_QUEUE_TOO_BIG: NTSTATUS = NTSTATUS(-1_069_154_299_i32); + pub const STATUS_IORING_COMPLETION_QUEUE_TOO_FULL: NTSTATUS = NTSTATUS(-1_069_154_296_i32); + pub const STATUS_IORING_CORRUPT: NTSTATUS = NTSTATUS(-1_069_154_297_i32); + pub const STATUS_IORING_REQUIRED_FLAG_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_069_154_303_i32); + pub const STATUS_IORING_SUBMISSION_QUEUE_FULL: NTSTATUS = NTSTATUS(-1_069_154_302_i32); + pub const STATUS_IORING_SUBMISSION_QUEUE_TOO_BIG: NTSTATUS = NTSTATUS(-1_069_154_300_i32); + pub const STATUS_IORING_SUBMIT_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_069_154_298_i32); + pub const STATUS_IORING_VERSION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_069_154_301_i32); + pub const STATUS_IO_DEVICE_ERROR: NTSTATUS = NTSTATUS(-1_073_741_435_i32); + pub const STATUS_IO_DEVICE_INVALID_DATA: NTSTATUS = NTSTATUS(-1_073_741_392_i32); + pub const STATUS_IO_OPERATION_TIMEOUT: NTSTATUS = NTSTATUS(-1_073_740_675_i32); + pub const STATUS_IO_PREEMPTED: NTSTATUS = NTSTATUS(-1_068_433_407_i32); + pub const STATUS_IO_PRIVILEGE_FAILED: NTSTATUS = NTSTATUS(-1_073_741_513_i32); + pub const STATUS_IO_REISSUE_AS_CACHED: NTSTATUS = NTSTATUS(-1_073_479_623_i32); + pub const STATUS_IO_REPARSE_DATA_INVALID: NTSTATUS = NTSTATUS(-1_073_741_192_i32); + pub const STATUS_IO_REPARSE_TAG_INVALID: NTSTATUS = NTSTATUS(-1_073_741_194_i32); + pub const STATUS_IO_REPARSE_TAG_MISMATCH: NTSTATUS = NTSTATUS(-1_073_741_193_i32); + pub const STATUS_IO_REPARSE_TAG_NOT_HANDLED: NTSTATUS = NTSTATUS(-1_073_741_191_i32); + pub const STATUS_IO_TIMEOUT: NTSTATUS = NTSTATUS(-1_073_741_643_i32); + pub const STATUS_IO_UNALIGNED_WRITE: NTSTATUS = NTSTATUS(-1_073_741_391_i32); + pub const STATUS_IPSEC_AUTH_FIREWALL_DROP: NTSTATUS = NTSTATUS(-1_070_202_872_i32); + pub const STATUS_IPSEC_BAD_SPI: NTSTATUS = NTSTATUS(-1_070_202_879_i32); + pub const STATUS_IPSEC_CLEAR_TEXT_DROP: NTSTATUS = NTSTATUS(-1_070_202_873_i32); + pub const STATUS_IPSEC_DOSP_BLOCK: NTSTATUS = NTSTATUS(-1_070_170_112_i32); + pub const STATUS_IPSEC_DOSP_INVALID_PACKET: NTSTATUS = NTSTATUS(-1_070_170_110_i32); + pub const STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_070_170_107_i32); + pub const STATUS_IPSEC_DOSP_MAX_ENTRIES: NTSTATUS = NTSTATUS(-1_070_170_108_i32); + pub const STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES: NTSTATUS = NTSTATUS(-1_070_170_106_i32); + pub const STATUS_IPSEC_DOSP_RECEIVED_MULTICAST: NTSTATUS = NTSTATUS(-1_070_170_111_i32); + pub const STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED: NTSTATUS = NTSTATUS(-1_070_170_109_i32); + pub const STATUS_IPSEC_INTEGRITY_CHECK_FAILED: NTSTATUS = NTSTATUS(-1_070_202_874_i32); + pub const STATUS_IPSEC_INVALID_PACKET: NTSTATUS = NTSTATUS(-1_070_202_875_i32); + pub const STATUS_IPSEC_QUEUE_OVERFLOW: NTSTATUS = NTSTATUS(-1_073_700_848_i32); + pub const STATUS_IPSEC_REPLAY_CHECK_FAILED: NTSTATUS = NTSTATUS(-1_070_202_876_i32); + pub const STATUS_IPSEC_SA_LIFETIME_EXPIRED: NTSTATUS = NTSTATUS(-1_070_202_878_i32); + pub const STATUS_IPSEC_THROTTLE_DROP: NTSTATUS = NTSTATUS(-1_070_202_871_i32); + pub const STATUS_IPSEC_WRONG_SA: NTSTATUS = NTSTATUS(-1_070_202_877_i32); + pub const STATUS_IP_ADDRESS_CONFLICT1: NTSTATUS = NTSTATUS(-1_073_741_228_i32); + pub const STATUS_IP_ADDRESS_CONFLICT2: NTSTATUS = NTSTATUS(-1_073_741_227_i32); + pub const STATUS_ISSUING_CA_UNTRUSTED: NTSTATUS = NTSTATUS(-1_073_740_918_i32); + pub const STATUS_ISSUING_CA_UNTRUSTED_KDC: NTSTATUS = NTSTATUS(-1_073_740_787_i32); + pub const STATUS_JOB_NOT_EMPTY: NTSTATUS = NTSTATUS(-1_073_740_529_i32); + pub const STATUS_JOB_NO_CONTAINER: NTSTATUS = NTSTATUS(-1_073_740_535_i32); + pub const STATUS_JOURNAL_DELETE_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_073_741_129_i32); + pub const STATUS_JOURNAL_ENTRY_DELETED: NTSTATUS = NTSTATUS(-1_073_741_105_i32); + pub const STATUS_JOURNAL_NOT_ACTIVE: NTSTATUS = NTSTATUS(-1_073_741_128_i32); + pub const STATUS_KDC_CERT_EXPIRED: NTSTATUS = NTSTATUS(-1_073_740_786_i32); + pub const STATUS_KDC_CERT_REVOKED: NTSTATUS = NTSTATUS(-1_073_740_785_i32); + pub const STATUS_KDC_INVALID_REQUEST: NTSTATUS = NTSTATUS(-1_073_741_061_i32); + pub const STATUS_KDC_UNABLE_TO_REFER: NTSTATUS = NTSTATUS(-1_073_741_060_i32); + pub const STATUS_KDC_UNKNOWN_ETYPE: NTSTATUS = NTSTATUS(-1_073_741_059_i32); + pub const STATUS_KERNEL_APC: NTSTATUS = NTSTATUS(256i32); + pub const STATUS_KERNEL_EXECUTABLE_MEMORY_WRITE: NTSTATUS = NTSTATUS(-1_073_739_996_i32); + pub const STATUS_KEY_DELETED: NTSTATUS = NTSTATUS(-1_073_741_444_i32); + pub const STATUS_KEY_HAS_CHILDREN: NTSTATUS = NTSTATUS(-1_073_741_440_i32); + pub const STATUS_LAST_ADMIN: NTSTATUS = NTSTATUS(-1_073_741_719_i32); + pub const STATUS_LICENSE_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_223_i32); + pub const STATUS_LICENSE_VIOLATION: NTSTATUS = NTSTATUS(-1_073_741_206_i32); + pub const STATUS_LINK_FAILED: NTSTATUS = NTSTATUS(-1_073_741_506_i32); + pub const STATUS_LINK_TIMEOUT: NTSTATUS = NTSTATUS(-1_073_741_505_i32); + pub const STATUS_LM_CROSS_ENCRYPTION_REQUIRED: NTSTATUS = NTSTATUS(-1_073_741_441_i32); + pub const STATUS_LOCAL_DISCONNECT: NTSTATUS = NTSTATUS(-1_073_741_509_i32); + pub const STATUS_LOCAL_POLICY_MODIFICATION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_700_726_i32); + pub const STATUS_LOCAL_USER_SESSION_KEY: NTSTATUS = NTSTATUS(1_073_741_830_i32); + pub const STATUS_LOCK_NOT_GRANTED: NTSTATUS = NTSTATUS(-1_073_741_739_i32); + pub const STATUS_LOGIN_TIME_RESTRICTION: NTSTATUS = NTSTATUS(-1_073_741_241_i32); + pub const STATUS_LOGIN_WKSTA_RESTRICTION: NTSTATUS = NTSTATUS(-1_073_741_240_i32); + pub const STATUS_LOGON_NOT_GRANTED: NTSTATUS = NTSTATUS(-1_073_741_483_i32); + pub const STATUS_LOGON_SERVER_CONFLICT: NTSTATUS = NTSTATUS(-1_073_741_518_i32); + pub const STATUS_LOGON_SESSION_COLLISION: NTSTATUS = NTSTATUS(-1_073_741_563_i32); + pub const STATUS_LOGON_SESSION_EXISTS: NTSTATUS = NTSTATUS(-1_073_741_586_i32); + pub const STATUS_LOG_APPENDED_FLUSH_FAILED: NTSTATUS = NTSTATUS(-1_072_037_841_i32); + pub const STATUS_LOG_ARCHIVE_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_072_037_855_i32); + pub const STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_072_037_856_i32); + pub const STATUS_LOG_BLOCKS_EXHAUSTED: NTSTATUS = NTSTATUS(-1_072_037_882_i32); + pub const STATUS_LOG_BLOCK_INCOMPLETE: NTSTATUS = NTSTATUS(-1_072_037_884_i32); + pub const STATUS_LOG_BLOCK_INVALID: NTSTATUS = NTSTATUS(-1_072_037_878_i32); + pub const STATUS_LOG_BLOCK_VERSION: NTSTATUS = NTSTATUS(-1_072_037_879_i32); + pub const STATUS_LOG_CANT_DELETE: NTSTATUS = NTSTATUS(-1_072_037_871_i32); + pub const STATUS_LOG_CLIENT_ALREADY_REGISTERED: NTSTATUS = NTSTATUS(-1_072_037_852_i32); + pub const STATUS_LOG_CLIENT_NOT_REGISTERED: NTSTATUS = NTSTATUS(-1_072_037_851_i32); + pub const STATUS_LOG_CONTAINER_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1_072_037_870_i32); + pub const STATUS_LOG_CONTAINER_OPEN_FAILED: NTSTATUS = NTSTATUS(-1_072_037_847_i32); + pub const STATUS_LOG_CONTAINER_READ_FAILED: NTSTATUS = NTSTATUS(-1_072_037_849_i32); + pub const STATUS_LOG_CONTAINER_STATE_INVALID: NTSTATUS = NTSTATUS(-1_072_037_846_i32); + pub const STATUS_LOG_CONTAINER_WRITE_FAILED: NTSTATUS = NTSTATUS(-1_072_037_848_i32); + pub const STATUS_LOG_CORRUPTION_DETECTED: NTSTATUS = NTSTATUS(-1_072_103_376_i32); + pub const STATUS_LOG_DEDICATED: NTSTATUS = NTSTATUS(-1_072_037_857_i32); + pub const STATUS_LOG_EPHEMERAL: NTSTATUS = NTSTATUS(-1_072_037_854_i32); + pub const STATUS_LOG_FILE_FULL: NTSTATUS = NTSTATUS(-1_073_741_432_i32); + pub const STATUS_LOG_FULL: NTSTATUS = NTSTATUS(-1_072_037_859_i32); + pub const STATUS_LOG_FULL_HANDLER_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_072_037_850_i32); + pub const STATUS_LOG_GROWTH_FAILED: NTSTATUS = NTSTATUS(-1_072_103_399_i32); + pub const STATUS_LOG_HARD_ERROR: NTSTATUS = NTSTATUS(1_073_741_850_i32); + pub const STATUS_LOG_INCONSISTENT_SECURITY: NTSTATUS = NTSTATUS(-1_072_037_842_i32); + pub const STATUS_LOG_INVALID_RANGE: NTSTATUS = NTSTATUS(-1_072_037_883_i32); + pub const STATUS_LOG_METADATA_CORRUPT: NTSTATUS = NTSTATUS(-1_072_037_875_i32); + pub const STATUS_LOG_METADATA_FLUSH_FAILED: NTSTATUS = NTSTATUS(-1_072_037_843_i32); + pub const STATUS_LOG_METADATA_INCONSISTENT: NTSTATUS = NTSTATUS(-1_072_037_873_i32); + pub const STATUS_LOG_METADATA_INVALID: NTSTATUS = NTSTATUS(-1_072_037_874_i32); + pub const STATUS_LOG_MULTIPLEXED: NTSTATUS = NTSTATUS(-1_072_037_858_i32); + pub const STATUS_LOG_NOT_ENOUGH_CONTAINERS: NTSTATUS = NTSTATUS(-1_072_037_853_i32); + pub const STATUS_LOG_NO_RESTART: NTSTATUS = NTSTATUS(1_075_445_772_i32); + pub const STATUS_LOG_PINNED: NTSTATUS = NTSTATUS(-1_072_037_844_i32); + pub const STATUS_LOG_PINNED_ARCHIVE_TAIL: NTSTATUS = NTSTATUS(-1_072_037_864_i32); + pub const STATUS_LOG_PINNED_RESERVATION: NTSTATUS = NTSTATUS(-1_072_037_840_i32); + pub const STATUS_LOG_POLICY_ALREADY_INSTALLED: NTSTATUS = NTSTATUS(-1_072_037_868_i32); + pub const STATUS_LOG_POLICY_CONFLICT: NTSTATUS = NTSTATUS(-1_072_037_865_i32); + pub const STATUS_LOG_POLICY_INVALID: NTSTATUS = NTSTATUS(-1_072_037_866_i32); + pub const STATUS_LOG_POLICY_NOT_INSTALLED: NTSTATUS = NTSTATUS(-1_072_037_867_i32); + pub const STATUS_LOG_READ_CONTEXT_INVALID: NTSTATUS = NTSTATUS(-1_072_037_881_i32); + pub const STATUS_LOG_READ_MODE_INVALID: NTSTATUS = NTSTATUS(-1_072_037_877_i32); + pub const STATUS_LOG_RECORDS_RESERVED_INVALID: NTSTATUS = NTSTATUS(-1_072_037_862_i32); + pub const STATUS_LOG_RECORD_NONEXISTENT: NTSTATUS = NTSTATUS(-1_072_037_863_i32); + pub const STATUS_LOG_RESERVATION_INVALID: NTSTATUS = NTSTATUS(-1_072_037_872_i32); + pub const STATUS_LOG_RESIZE_INVALID_SIZE: NTSTATUS = NTSTATUS(-1_072_103_413_i32); + pub const STATUS_LOG_RESTART_INVALID: NTSTATUS = NTSTATUS(-1_072_037_880_i32); + pub const STATUS_LOG_SECTOR_INVALID: NTSTATUS = NTSTATUS(-1_072_037_887_i32); + pub const STATUS_LOG_SECTOR_PARITY_INVALID: NTSTATUS = NTSTATUS(-1_072_037_886_i32); + pub const STATUS_LOG_SECTOR_REMAPPED: NTSTATUS = NTSTATUS(-1_072_037_885_i32); + pub const STATUS_LOG_SPACE_RESERVED_INVALID: NTSTATUS = NTSTATUS(-1_072_037_861_i32); + pub const STATUS_LOG_START_OF_LOG: NTSTATUS = NTSTATUS(-1_072_037_869_i32); + pub const STATUS_LOG_STATE_INVALID: NTSTATUS = NTSTATUS(-1_072_037_845_i32); + pub const STATUS_LOG_TAIL_INVALID: NTSTATUS = NTSTATUS(-1_072_037_860_i32); + pub const STATUS_LONGJUMP: NTSTATUS = NTSTATUS(-2_147_483_610_i32); + pub const STATUS_LOST_MODE_LOGON_RESTRICTION: NTSTATUS = NTSTATUS(-1_073_741_043_i32); + pub const STATUS_LOST_WRITEBEHIND_DATA: NTSTATUS = NTSTATUS(-1_073_741_278_i32); + pub const STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR: NTSTATUS = NTSTATUS(-1_073_700_734_i32); + pub const STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED: NTSTATUS = NTSTATUS(-1_073_700_736_i32); + pub const STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR: NTSTATUS = NTSTATUS(-1_073_700_735_i32); + pub const STATUS_LPAC_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_073_700_349_i32); + pub const STATUS_LPC_HANDLE_COUNT_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_739_998_i32); + pub const STATUS_LPC_INVALID_CONNECTION_USAGE: NTSTATUS = NTSTATUS(-1_073_740_026_i32); + pub const STATUS_LPC_RECEIVE_BUFFER_EXPECTED: NTSTATUS = NTSTATUS(-1_073_740_027_i32); + pub const STATUS_LPC_REPLY_LOST: NTSTATUS = NTSTATUS(-1_073_741_229_i32); + pub const STATUS_LPC_REQUESTS_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_073_740_025_i32); + pub const STATUS_LUIDS_EXHAUSTED: NTSTATUS = NTSTATUS(-1_073_741_707_i32); + pub const STATUS_MAGAZINE_NOT_PRESENT: NTSTATUS = NTSTATUS(-1_073_741_178_i32); + pub const STATUS_MAPPED_ALIGNMENT: NTSTATUS = NTSTATUS(-1_073_741_280_i32); + pub const STATUS_MAPPED_FILE_SIZE_ZERO: NTSTATUS = NTSTATUS(-1_073_741_538_i32); + pub const STATUS_MARKED_TO_DISALLOW_WRITES: NTSTATUS = NTSTATUS(-1_073_740_659_i32); + pub const STATUS_MARSHALL_OVERFLOW: NTSTATUS = NTSTATUS(-1_073_741_263_i32); + pub const STATUS_MAX_REFERRALS_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_068_i32); + pub const STATUS_MCA_EXCEPTION: NTSTATUS = NTSTATUS(-1_073_740_013_i32); + pub const STATUS_MCA_OCCURED: NTSTATUS = NTSTATUS(-1_073_740_950_i32); + pub const STATUS_MEDIA_CHANGED: NTSTATUS = NTSTATUS(-2_147_483_620_i32); + pub const STATUS_MEDIA_CHECK: NTSTATUS = NTSTATUS(-2_147_483_616_i32); + pub const STATUS_MEDIA_WRITE_PROTECTED: NTSTATUS = NTSTATUS(-1_073_741_662_i32); + pub const STATUS_MEMBERS_PRIMARY_GROUP: NTSTATUS = NTSTATUS(-1_073_741_529_i32); + pub const STATUS_MEMBER_IN_ALIAS: NTSTATUS = NTSTATUS(-1_073_741_485_i32); + pub const STATUS_MEMBER_IN_GROUP: NTSTATUS = NTSTATUS(-1_073_741_721_i32); + pub const STATUS_MEMBER_NOT_IN_ALIAS: NTSTATUS = NTSTATUS(-1_073_741_486_i32); + pub const STATUS_MEMBER_NOT_IN_GROUP: NTSTATUS = NTSTATUS(-1_073_741_720_i32); + pub const STATUS_MEMORY_NOT_ALLOCATED: NTSTATUS = NTSTATUS(-1_073_741_664_i32); + pub const STATUS_MESSAGE_LOST: NTSTATUS = NTSTATUS(-1_073_740_031_i32); + pub const STATUS_MESSAGE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_559_i32); + pub const STATUS_MESSAGE_RETRIEVED: NTSTATUS = NTSTATUS(1_073_741_870_i32); + pub const STATUS_MFT_TOO_FRAGMENTED: NTSTATUS = NTSTATUS(-1_073_741_052_i32); + pub const STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION: NTSTATUS = NTSTATUS(-1_072_103_388_i32); + pub const STATUS_MISSING_SYSTEMFILE: NTSTATUS = NTSTATUS(-1_073_741_501_i32); + pub const STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM: NTSTATUS = NTSTATUS(-1_071_841_277_i32); + pub const STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK: NTSTATUS = NTSTATUS(-1_071_841_271_i32); + pub const STATUS_MONITOR_INVALID_MANUFACTURE_DATE: NTSTATUS = NTSTATUS(-1_071_841_270_i32); + pub const STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK: NTSTATUS = NTSTATUS(-1_071_841_274_i32); + pub const STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK: NTSTATUS = NTSTATUS(-1_071_841_276_i32); + pub const STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK: NTSTATUS = NTSTATUS(-1_071_841_273_i32); + pub const STATUS_MONITOR_NO_DESCRIPTOR: NTSTATUS = NTSTATUS(-1_071_841_279_i32); + pub const STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA: NTSTATUS = NTSTATUS(-1_071_841_272_i32); + pub const STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT: NTSTATUS = NTSTATUS(-1_071_841_278_i32); + pub const STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED: NTSTATUS = NTSTATUS(-1_071_841_275_i32); + pub const STATUS_MORE_ENTRIES: NTSTATUS = NTSTATUS(261i32); + pub const STATUS_MORE_PROCESSING_REQUIRED: NTSTATUS = NTSTATUS(-1_073_741_802_i32); + pub const STATUS_MOUNT_POINT_NOT_RESOLVED: NTSTATUS = NTSTATUS(-1_073_740_952_i32); + pub const STATUS_MP_PROCESSOR_MISMATCH: NTSTATUS = NTSTATUS(1_073_741_865_i32); + pub const STATUS_MUI_FILE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_020_927_i32); + pub const STATUS_MUI_FILE_NOT_LOADED: NTSTATUS = NTSTATUS(-1_073_020_922_i32); + pub const STATUS_MUI_INVALID_FILE: NTSTATUS = NTSTATUS(-1_073_020_926_i32); + pub const STATUS_MUI_INVALID_LOCALE_NAME: NTSTATUS = NTSTATUS(-1_073_020_924_i32); + pub const STATUS_MUI_INVALID_RC_CONFIG: NTSTATUS = NTSTATUS(-1_073_020_925_i32); + pub const STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME: NTSTATUS = NTSTATUS(-1_073_020_923_i32); + pub const STATUS_MULTIPLE_FAULT_VIOLATION: NTSTATUS = NTSTATUS(-1_073_741_080_i32); + pub const STATUS_MUST_BE_KDC: NTSTATUS = NTSTATUS(-1_073_741_067_i32); + pub const STATUS_MUTANT_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_423_i32); + pub const STATUS_MUTANT_NOT_OWNED: NTSTATUS = NTSTATUS(-1_073_741_754_i32); + pub const STATUS_MUTUAL_AUTHENTICATION_FAILED: NTSTATUS = NTSTATUS(-1_073_741_117_i32); + pub const STATUS_NAME_TOO_LONG: NTSTATUS = NTSTATUS(-1_073_741_562_i32); + pub const STATUS_NDIS_ADAPTER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_448_058_i32); + pub const STATUS_NDIS_ADAPTER_NOT_READY: NTSTATUS = NTSTATUS(-1_071_448_047_i32); + pub const STATUS_NDIS_ADAPTER_REMOVED: NTSTATUS = NTSTATUS(-1_071_448_040_i32); + pub const STATUS_NDIS_ALREADY_MAPPED: NTSTATUS = NTSTATUS(-1_071_448_035_i32); + pub const STATUS_NDIS_BAD_CHARACTERISTICS: NTSTATUS = NTSTATUS(-1_071_448_059_i32); + pub const STATUS_NDIS_BAD_VERSION: NTSTATUS = NTSTATUS(-1_071_448_060_i32); + pub const STATUS_NDIS_BUFFER_TOO_SHORT: NTSTATUS = NTSTATUS(-1_071_448_042_i32); + pub const STATUS_NDIS_CLOSING: NTSTATUS = NTSTATUS(-1_071_448_062_i32); + pub const STATUS_NDIS_DEVICE_FAILED: NTSTATUS = NTSTATUS(-1_071_448_056_i32); + pub const STATUS_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_071_439_866_i32); + pub const STATUS_NDIS_DOT11_AP_BAND_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_071_439_864_i32); + pub const STATUS_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_071_439_867_i32); + pub const STATUS_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_071_439_865_i32); + pub const STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED: NTSTATUS = NTSTATUS(-1_071_439_872_i32); + pub const STATUS_NDIS_DOT11_MEDIA_IN_USE: NTSTATUS = NTSTATUS(-1_071_439_871_i32); + pub const STATUS_NDIS_DOT11_POWER_STATE_INVALID: NTSTATUS = NTSTATUS(-1_071_439_870_i32); + pub const STATUS_NDIS_ERROR_READING_FILE: NTSTATUS = NTSTATUS(-1_071_448_036_i32); + pub const STATUS_NDIS_FILE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_448_037_i32); + pub const STATUS_NDIS_GROUP_ADDRESS_IN_USE: NTSTATUS = NTSTATUS(-1_071_448_038_i32); + pub const STATUS_NDIS_INDICATION_REQUIRED: NTSTATUS = NTSTATUS(1_076_035_585_i32); + pub const STATUS_NDIS_INTERFACE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_448_021_i32); + pub const STATUS_NDIS_INVALID_ADDRESS: NTSTATUS = NTSTATUS(-1_071_448_030_i32); + pub const STATUS_NDIS_INVALID_DATA: NTSTATUS = NTSTATUS(-1_071_448_043_i32); + pub const STATUS_NDIS_INVALID_DEVICE_REQUEST: NTSTATUS = NTSTATUS(-1_071_448_048_i32); + pub const STATUS_NDIS_INVALID_LENGTH: NTSTATUS = NTSTATUS(-1_071_448_044_i32); + pub const STATUS_NDIS_INVALID_OID: NTSTATUS = NTSTATUS(-1_071_448_041_i32); + pub const STATUS_NDIS_INVALID_PACKET: NTSTATUS = NTSTATUS(-1_071_448_049_i32); + pub const STATUS_NDIS_INVALID_PORT: NTSTATUS = NTSTATUS(-1_071_448_019_i32); + pub const STATUS_NDIS_INVALID_PORT_STATE: NTSTATUS = NTSTATUS(-1_071_448_018_i32); + pub const STATUS_NDIS_LOW_POWER_STATE: NTSTATUS = NTSTATUS(-1_071_448_017_i32); + pub const STATUS_NDIS_MEDIA_DISCONNECTED: NTSTATUS = NTSTATUS(-1_071_448_033_i32); + pub const STATUS_NDIS_MULTICAST_EXISTS: NTSTATUS = NTSTATUS(-1_071_448_054_i32); + pub const STATUS_NDIS_MULTICAST_FULL: NTSTATUS = NTSTATUS(-1_071_448_055_i32); + pub const STATUS_NDIS_MULTICAST_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_448_053_i32); + pub const STATUS_NDIS_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_447_877_i32); + pub const STATUS_NDIS_NO_QUEUES: NTSTATUS = NTSTATUS(-1_071_448_015_i32); + pub const STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED: NTSTATUS = NTSTATUS(-1_071_443_950_i32); + pub const STATUS_NDIS_OFFLOAD_PATH_REJECTED: NTSTATUS = NTSTATUS(-1_071_443_949_i32); + pub const STATUS_NDIS_OFFLOAD_POLICY: NTSTATUS = NTSTATUS(-1_071_443_953_i32); + pub const STATUS_NDIS_OPEN_FAILED: NTSTATUS = NTSTATUS(-1_071_448_057_i32); + pub const STATUS_NDIS_PAUSED: NTSTATUS = NTSTATUS(-1_071_448_022_i32); + pub const STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL: NTSTATUS = NTSTATUS(-1_071_439_868_i32); + pub const STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL: NTSTATUS = NTSTATUS(-1_071_439_869_i32); + pub const STATUS_NDIS_REINIT_REQUIRED: NTSTATUS = NTSTATUS(-1_071_448_016_i32); + pub const STATUS_NDIS_REQUEST_ABORTED: NTSTATUS = NTSTATUS(-1_071_448_052_i32); + pub const STATUS_NDIS_RESET_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_071_448_051_i32); + pub const STATUS_NDIS_RESOURCE_CONFLICT: NTSTATUS = NTSTATUS(-1_071_448_034_i32); + pub const STATUS_NDIS_UNSUPPORTED_MEDIA: NTSTATUS = NTSTATUS(-1_071_448_039_i32); + pub const STATUS_NDIS_UNSUPPORTED_REVISION: NTSTATUS = NTSTATUS(-1_071_448_020_i32); + pub const STATUS_ND_QUEUE_OVERFLOW: NTSTATUS = NTSTATUS(-1_073_700_847_i32); + pub const STATUS_NEEDS_REGISTRATION: NTSTATUS = NTSTATUS(-1_073_740_663_i32); + pub const STATUS_NEEDS_REMEDIATION: NTSTATUS = NTSTATUS(-1_073_740_702_i32); + pub const STATUS_NETLOGON_NOT_STARTED: NTSTATUS = NTSTATUS(-1_073_741_422_i32); + pub const STATUS_NETWORK_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_073_741_622_i32); + pub const STATUS_NETWORK_ACCESS_DENIED_EDP: NTSTATUS = NTSTATUS(-1_073_740_658_i32); + pub const STATUS_NETWORK_AUTHENTICATION_PROMPT_CANCELED: NTSTATUS = NTSTATUS(-1_067_646_972_i32); + pub const STATUS_NETWORK_BUSY: NTSTATUS = NTSTATUS(-1_073_741_633_i32); + pub const STATUS_NETWORK_CREDENTIAL_CONFLICT: NTSTATUS = NTSTATUS(-1_073_741_419_i32); + pub const STATUS_NETWORK_NAME_DELETED: NTSTATUS = NTSTATUS(-1_073_741_623_i32); + pub const STATUS_NETWORK_OPEN_RESTRICTION: NTSTATUS = NTSTATUS(-1_073_741_311_i32); + pub const STATUS_NETWORK_SESSION_EXPIRED: NTSTATUS = NTSTATUS(-1_073_740_964_i32); + pub const STATUS_NETWORK_UNREACHABLE: NTSTATUS = NTSTATUS(-1_073_741_252_i32); + pub const STATUS_NET_WRITE_FAULT: NTSTATUS = NTSTATUS(-1_073_741_614_i32); + pub const STATUS_NOINTERFACE: NTSTATUS = NTSTATUS(-1_073_741_127_i32); + pub const STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT: NTSTATUS = NTSTATUS(-1_073_741_416_i32); + pub const STATUS_NOLOGON_SERVER_TRUST_ACCOUNT: NTSTATUS = NTSTATUS(-1_073_741_414_i32); + pub const STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT: NTSTATUS = NTSTATUS(-1_073_741_415_i32); + pub const STATUS_NONCONTINUABLE_EXCEPTION: NTSTATUS = NTSTATUS(-1_073_741_787_i32); + pub const STATUS_NONEXISTENT_EA_ENTRY: NTSTATUS = NTSTATUS(-1_073_741_743_i32); + pub const STATUS_NONEXISTENT_SECTOR: NTSTATUS = NTSTATUS(-1_073_741_803_i32); + pub const STATUS_NONE_MAPPED: NTSTATUS = NTSTATUS(-1_073_741_709_i32); + pub const STATUS_NOTHING_TO_TERMINATE: NTSTATUS = NTSTATUS(290i32); + pub const STATUS_NOTIFICATION_GUID_ALREADY_DEFINED: NTSTATUS = NTSTATUS(-1_073_741_404_i32); + pub const STATUS_NOTIFY_CLEANUP: NTSTATUS = NTSTATUS(267i32); + pub const STATUS_NOTIFY_ENUM_DIR: NTSTATUS = NTSTATUS(268i32); + pub const STATUS_NOT_ALLOWED_ON_SYSTEM_FILE: NTSTATUS = NTSTATUS(-1_073_741_401_i32); + pub const STATUS_NOT_ALL_ASSIGNED: NTSTATUS = NTSTATUS(262i32); + pub const STATUS_NOT_APPCONTAINER: NTSTATUS = NTSTATUS(-1_073_700_352_i32); + pub const STATUS_NOT_A_CLOUD_FILE: NTSTATUS = NTSTATUS(-1_073_688_825_i32); + pub const STATUS_NOT_A_CLOUD_SYNC_ROOT: NTSTATUS = NTSTATUS(-1_073_688_802_i32); + pub const STATUS_NOT_A_DAX_VOLUME: NTSTATUS = NTSTATUS(-1_073_740_623_i32); + pub const STATUS_NOT_A_DIRECTORY: NTSTATUS = NTSTATUS(-1_073_741_565_i32); + pub const STATUS_NOT_A_REPARSE_POINT: NTSTATUS = NTSTATUS(-1_073_741_195_i32); + pub const STATUS_NOT_A_TIERED_VOLUME: NTSTATUS = NTSTATUS(-1_073_740_531_i32); + pub const STATUS_NOT_CAPABLE: NTSTATUS = NTSTATUS(-1_073_740_759_i32); + pub const STATUS_NOT_CLIENT_SESSION: NTSTATUS = NTSTATUS(-1_073_741_289_i32); + pub const STATUS_NOT_COMMITTED: NTSTATUS = NTSTATUS(-1_073_741_779_i32); + pub const STATUS_NOT_DAX_MAPPABLE: NTSTATUS = NTSTATUS(-1_073_740_622_i32); + pub const STATUS_NOT_EXPORT_FORMAT: NTSTATUS = NTSTATUS(-1_073_741_166_i32); + pub const STATUS_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_275_i32); + pub const STATUS_NOT_GUI_PROCESS: NTSTATUS = NTSTATUS(-1_073_740_538_i32); + pub const STATUS_NOT_IMPLEMENTED: NTSTATUS = NTSTATUS(-1_073_741_822_i32); + pub const STATUS_NOT_LOCKED: NTSTATUS = NTSTATUS(-1_073_741_782_i32); + pub const STATUS_NOT_LOGON_PROCESS: NTSTATUS = NTSTATUS(-1_073_741_587_i32); + pub const STATUS_NOT_MAPPED_DATA: NTSTATUS = NTSTATUS(-1_073_741_688_i32); + pub const STATUS_NOT_MAPPED_VIEW: NTSTATUS = NTSTATUS(-1_073_741_799_i32); + pub const STATUS_NOT_READ_FROM_COPY: NTSTATUS = NTSTATUS(-1_073_740_694_i32); + pub const STATUS_NOT_REDUNDANT_STORAGE: NTSTATUS = NTSTATUS(-1_073_740_679_i32); + pub const STATUS_NOT_REGISTRY_FILE: NTSTATUS = NTSTATUS(-1_073_741_476_i32); + pub const STATUS_NOT_SAFE_MODE_DRIVER: NTSTATUS = NTSTATUS(-1_073_740_961_i32); + pub const STATUS_NOT_SAME_DEVICE: NTSTATUS = NTSTATUS(-1_073_741_612_i32); + pub const STATUS_NOT_SAME_OBJECT: NTSTATUS = NTSTATUS(-1_073_741_396_i32); + pub const STATUS_NOT_SERVER_SESSION: NTSTATUS = NTSTATUS(-1_073_741_290_i32); + pub const STATUS_NOT_SNAPSHOT_VOLUME: NTSTATUS = NTSTATUS(-1_072_103_353_i32); + pub const STATUS_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_741_637_i32); + pub const STATUS_NOT_SUPPORTED_IN_APPCONTAINER: NTSTATUS = NTSTATUS(-1_073_700_351_i32); + pub const STATUS_NOT_SUPPORTED_ON_DAX: NTSTATUS = NTSTATUS(-1_073_740_646_i32); + pub const STATUS_NOT_SUPPORTED_ON_SBS: NTSTATUS = NTSTATUS(-1_073_741_056_i32); + pub const STATUS_NOT_SUPPORTED_WITH_AUDITING: NTSTATUS = NTSTATUS(-1_073_740_595_i32); + pub const STATUS_NOT_SUPPORTED_WITH_BTT: NTSTATUS = NTSTATUS(-1_073_740_619_i32); + pub const STATUS_NOT_SUPPORTED_WITH_BYPASSIO: NTSTATUS = NTSTATUS(-1_073_740_601_i32); + pub const STATUS_NOT_SUPPORTED_WITH_CACHED_HANDLE: NTSTATUS = NTSTATUS(-1_073_740_587_i32); + pub const STATUS_NOT_SUPPORTED_WITH_COMPRESSION: NTSTATUS = NTSTATUS(-1_073_740_598_i32); + pub const STATUS_NOT_SUPPORTED_WITH_DEDUPLICATION: NTSTATUS = NTSTATUS(-1_073_740_596_i32); + pub const STATUS_NOT_SUPPORTED_WITH_ENCRYPTION: NTSTATUS = NTSTATUS(-1_073_740_599_i32); + pub const STATUS_NOT_SUPPORTED_WITH_MONITORING: NTSTATUS = NTSTATUS(-1_073_740_594_i32); + pub const STATUS_NOT_SUPPORTED_WITH_REPLICATION: NTSTATUS = NTSTATUS(-1_073_740_597_i32); + pub const STATUS_NOT_SUPPORTED_WITH_SNAPSHOT: NTSTATUS = NTSTATUS(-1_073_740_593_i32); + pub const STATUS_NOT_SUPPORTED_WITH_VIRTUALIZATION: NTSTATUS = NTSTATUS(-1_073_740_592_i32); + pub const STATUS_NOT_TINY_STREAM: NTSTATUS = NTSTATUS(-1_073_741_274_i32); + pub const STATUS_NO_ACE_CONDITION: NTSTATUS = NTSTATUS(-2_147_483_601_i32); + pub const STATUS_NO_APPLICABLE_APP_LICENSES_FOUND: NTSTATUS = NTSTATUS(-1_058_406_399_i32); + pub const STATUS_NO_APPLICATION_PACKAGE: NTSTATUS = NTSTATUS(-1_073_741_398_i32); + pub const STATUS_NO_BROWSER_SERVERS_FOUND: NTSTATUS = NTSTATUS(-1_073_741_284_i32); + pub const STATUS_NO_BYPASSIO_DRIVER_SUPPORT: NTSTATUS = NTSTATUS(-1_073_740_600_i32); + pub const STATUS_NO_CALLBACK_ACTIVE: NTSTATUS = NTSTATUS(-1_073_741_224_i32); + pub const STATUS_NO_DATA_DETECTED: NTSTATUS = NTSTATUS(-2_147_483_614_i32); + pub const STATUS_NO_EAS_ON_FILE: NTSTATUS = NTSTATUS(-1_073_741_742_i32); + pub const STATUS_NO_EFS: NTSTATUS = NTSTATUS(-1_073_741_170_i32); + pub const STATUS_NO_EVENT_PAIR: NTSTATUS = NTSTATUS(-1_073_741_490_i32); + pub const STATUS_NO_GUID_TRANSLATION: NTSTATUS = NTSTATUS(-1_073_741_556_i32); + pub const STATUS_NO_IMPERSONATION_TOKEN: NTSTATUS = NTSTATUS(-1_073_741_732_i32); + pub const STATUS_NO_INHERITANCE: NTSTATUS = NTSTATUS(-2_147_483_637_i32); + pub const STATUS_NO_IP_ADDRESSES: NTSTATUS = NTSTATUS(-1_073_741_071_i32); + pub const STATUS_NO_KERB_KEY: NTSTATUS = NTSTATUS(-1_073_741_022_i32); + pub const STATUS_NO_KEY: NTSTATUS = NTSTATUS(-1_073_739_508_i32); + pub const STATUS_NO_LDT: NTSTATUS = NTSTATUS(-1_073_741_545_i32); + pub const STATUS_NO_LINK_TRACKING_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1_072_103_335_i32); + pub const STATUS_NO_LOGON_SERVERS: NTSTATUS = NTSTATUS(-1_073_741_730_i32); + pub const STATUS_NO_LOG_SPACE: NTSTATUS = NTSTATUS(-1_073_741_443_i32); + pub const STATUS_NO_MATCH: NTSTATUS = NTSTATUS(-1_073_741_198_i32); + pub const STATUS_NO_MEDIA: NTSTATUS = NTSTATUS(-1_073_741_448_i32); + pub const STATUS_NO_MEDIA_IN_DEVICE: NTSTATUS = NTSTATUS(-1_073_741_805_i32); + pub const STATUS_NO_MEMORY: NTSTATUS = NTSTATUS(-1_073_741_801_i32); + pub const STATUS_NO_MORE_EAS: NTSTATUS = NTSTATUS(-2_147_483_630_i32); + pub const STATUS_NO_MORE_ENTRIES: NTSTATUS = NTSTATUS(-2_147_483_622_i32); + pub const STATUS_NO_MORE_FILES: NTSTATUS = NTSTATUS(-2_147_483_642_i32); + pub const STATUS_NO_MORE_MATCHES: NTSTATUS = NTSTATUS(-1_073_741_197_i32); + pub const STATUS_NO_PAGEFILE: NTSTATUS = NTSTATUS(-1_073_741_497_i32); + pub const STATUS_NO_PA_DATA: NTSTATUS = NTSTATUS(-1_073_741_064_i32); + pub const STATUS_NO_PHYSICALLY_ALIGNED_FREE_SPACE_FOUND: NTSTATUS = NTSTATUS(-1_073_740_635_i32); + pub const STATUS_NO_QUOTAS_FOR_ACCOUNT: NTSTATUS = NTSTATUS(269i32); + pub const STATUS_NO_RANGES_PROCESSED: NTSTATUS = NTSTATUS(-1_073_740_704_i32); + pub const STATUS_NO_RECOVERY_POLICY: NTSTATUS = NTSTATUS(-1_073_741_171_i32); + pub const STATUS_NO_S4U_PROT_SUPPORT: NTSTATUS = NTSTATUS(-1_073_740_790_i32); + pub const STATUS_NO_SAVEPOINT_WITH_OPEN_FILES: NTSTATUS = NTSTATUS(-1_072_103_352_i32); + pub const STATUS_NO_SECRETS: NTSTATUS = NTSTATUS(-1_073_740_943_i32); + pub const STATUS_NO_SECURITY_CONTEXT: NTSTATUS = NTSTATUS(-1_073_740_755_i32); + pub const STATUS_NO_SECURITY_ON_OBJECT: NTSTATUS = NTSTATUS(-1_073_741_609_i32); + pub const STATUS_NO_SPOOL_SPACE: NTSTATUS = NTSTATUS(-1_073_741_625_i32); + pub const STATUS_NO_SUCH_ALIAS: NTSTATUS = NTSTATUS(-1_073_741_487_i32); + pub const STATUS_NO_SUCH_DEVICE: NTSTATUS = NTSTATUS(-1_073_741_810_i32); + pub const STATUS_NO_SUCH_DOMAIN: NTSTATUS = NTSTATUS(-1_073_741_601_i32); + pub const STATUS_NO_SUCH_FILE: NTSTATUS = NTSTATUS(-1_073_741_809_i32); + pub const STATUS_NO_SUCH_GROUP: NTSTATUS = NTSTATUS(-1_073_741_722_i32); + pub const STATUS_NO_SUCH_MEMBER: NTSTATUS = NTSTATUS(-1_073_741_446_i32); + pub const STATUS_NO_SUCH_PACKAGE: NTSTATUS = NTSTATUS(-1_073_741_570_i32); + pub const STATUS_NO_SUCH_PRIVILEGE: NTSTATUS = NTSTATUS(-1_073_741_728_i32); + pub const STATUS_NO_TGT_REPLY: NTSTATUS = NTSTATUS(-1_073_741_073_i32); + pub const STATUS_NO_TOKEN: NTSTATUS = NTSTATUS(-1_073_741_700_i32); + pub const STATUS_NO_TRACKING_SERVICE: NTSTATUS = NTSTATUS(-1_073_741_153_i32); + pub const STATUS_NO_TRUST_LSA_SECRET: NTSTATUS = NTSTATUS(-1_073_741_430_i32); + pub const STATUS_NO_TRUST_SAM_ACCOUNT: NTSTATUS = NTSTATUS(-1_073_741_429_i32); + pub const STATUS_NO_TXF_METADATA: NTSTATUS = NTSTATUS(-2_145_845_207_i32); + pub const STATUS_NO_UNICODE_TRANSLATION: NTSTATUS = NTSTATUS(-1_073_740_009_i32); + pub const STATUS_NO_USER_KEYS: NTSTATUS = NTSTATUS(-1_073_741_168_i32); + pub const STATUS_NO_USER_SESSION_KEY: NTSTATUS = NTSTATUS(-1_073_741_310_i32); + pub const STATUS_NO_WORK_DONE: NTSTATUS = NTSTATUS(-2_147_483_598_i32); + pub const STATUS_NO_YIELD_PERFORMED: NTSTATUS = NTSTATUS(1_073_741_860_i32); + pub const STATUS_NTLM_BLOCKED: NTSTATUS = NTSTATUS(-1_073_740_776_i32); + pub const STATUS_NT_CROSS_ENCRYPTION_REQUIRED: NTSTATUS = NTSTATUS(-1_073_741_475_i32); + pub const STATUS_NULL_LM_PASSWORD: NTSTATUS = NTSTATUS(1_073_741_837_i32); + pub const STATUS_OBJECTID_EXISTS: NTSTATUS = NTSTATUS(-1_073_741_269_i32); + pub const STATUS_OBJECTID_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_072_i32); + pub const STATUS_OBJECT_IS_IMMUTABLE: NTSTATUS = NTSTATUS(-1_073_740_610_i32); + pub const STATUS_OBJECT_NAME_COLLISION: NTSTATUS = NTSTATUS(-1_073_741_771_i32); + pub const STATUS_OBJECT_NAME_EXISTS: NTSTATUS = NTSTATUS(1_073_741_824_i32); + pub const STATUS_OBJECT_NAME_INVALID: NTSTATUS = NTSTATUS(-1_073_741_773_i32); + pub const STATUS_OBJECT_NAME_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_772_i32); + pub const STATUS_OBJECT_NOT_EXTERNALLY_BACKED: NTSTATUS = NTSTATUS(-1_073_740_691_i32); + pub const STATUS_OBJECT_NO_LONGER_EXISTS: NTSTATUS = NTSTATUS(-1_072_103_391_i32); + pub const STATUS_OBJECT_PATH_INVALID: NTSTATUS = NTSTATUS(-1_073_741_767_i32); + pub const STATUS_OBJECT_PATH_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_766_i32); + pub const STATUS_OBJECT_PATH_SYNTAX_BAD: NTSTATUS = NTSTATUS(-1_073_741_765_i32); + pub const STATUS_OBJECT_TYPE_MISMATCH: NTSTATUS = NTSTATUS(-1_073_741_788_i32); + pub const STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_700_189_i32); + pub const STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_700_191_i32); + pub const STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_700_188_i32); + pub const STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_700_190_i32); + pub const STATUS_ONLY_IF_CONNECTED: NTSTATUS = NTSTATUS(-1_073_741_108_i32); + pub const STATUS_OPEN_FAILED: NTSTATUS = NTSTATUS(-1_073_741_514_i32); + pub const STATUS_OPERATION_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_073_740_682_i32); + pub const STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1_072_103_334_i32); + pub const STATUS_OPLOCK_BREAK_IN_PROGRESS: NTSTATUS = NTSTATUS(264i32); + pub const STATUS_OPLOCK_HANDLE_CLOSED: NTSTATUS = NTSTATUS(534i32); + pub const STATUS_OPLOCK_NOT_GRANTED: NTSTATUS = NTSTATUS(-1_073_741_598_i32); + pub const STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE: NTSTATUS = NTSTATUS(533i32); + pub const STATUS_ORDINAL_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_512_i32); + pub const STATUS_ORPHAN_NAME_EXHAUSTED: NTSTATUS = NTSTATUS(-1_073_739_762_i32); + pub const STATUS_PACKAGE_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_073_740_649_i32); + pub const STATUS_PACKAGE_UPDATING: NTSTATUS = NTSTATUS(-1_073_740_695_i32); + pub const STATUS_PAGEFILE_CREATE_FAILED: NTSTATUS = NTSTATUS(-1_073_741_498_i32); + pub const STATUS_PAGEFILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_603_i32); + pub const STATUS_PAGEFILE_QUOTA: NTSTATUS = NTSTATUS(-1_073_741_817_i32); + pub const STATUS_PAGEFILE_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_524_i32); + pub const STATUS_PAGE_FAULT_COPY_ON_WRITE: NTSTATUS = NTSTATUS(274i32); + pub const STATUS_PAGE_FAULT_DEMAND_ZERO: NTSTATUS = NTSTATUS(273i32); + pub const STATUS_PAGE_FAULT_GUARD_PAGE: NTSTATUS = NTSTATUS(275i32); + pub const STATUS_PAGE_FAULT_PAGING_FILE: NTSTATUS = NTSTATUS(276i32); + pub const STATUS_PAGE_FAULT_RETRY: NTSTATUS = NTSTATUS(873i32); + pub const STATUS_PAGE_FAULT_TRANSITION: NTSTATUS = NTSTATUS(272i32); + pub const STATUS_PARAMETER_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_740_784_i32); + pub const STATUS_PARITY_ERROR: NTSTATUS = NTSTATUS(-1_073_741_781_i32); + pub const STATUS_PARTIAL_COPY: NTSTATUS = NTSTATUS(-2_147_483_635_i32); + pub const STATUS_PARTITION_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_454_i32); + pub const STATUS_PARTITION_TERMINATING: NTSTATUS = NTSTATUS(-1_073_740_640_i32); + pub const STATUS_PASSWORD_CHANGE_REQUIRED: NTSTATUS = NTSTATUS(-1_073_741_044_i32); + pub const STATUS_PASSWORD_RESTRICTION: NTSTATUS = NTSTATUS(-1_073_741_716_i32); + pub const STATUS_PATCH_CONFLICT: NTSTATUS = NTSTATUS(-1_073_740_628_i32); + pub const STATUS_PATCH_DEFERRED: NTSTATUS = NTSTATUS(1_073_741_879_i32); + pub const STATUS_PATCH_NOT_REGISTERED: NTSTATUS = NTSTATUS(-1_073_740_588_i32); + pub const STATUS_PATH_NOT_COVERED: NTSTATUS = NTSTATUS(-1_073_741_225_i32); + pub const STATUS_PCP_ATTESTATION_CHALLENGE_NOT_SET: NTSTATUS = NTSTATUS(-1_071_046_638_i32); + pub const STATUS_PCP_AUTHENTICATION_FAILED: NTSTATUS = NTSTATUS(-1_071_046_648_i32); + pub const STATUS_PCP_AUTHENTICATION_IGNORED: NTSTATUS = NTSTATUS(-1_071_046_647_i32); + pub const STATUS_PCP_BUFFER_LENGTH_MISMATCH: NTSTATUS = NTSTATUS(-1_071_046_626_i32); + pub const STATUS_PCP_BUFFER_TOO_SMALL: NTSTATUS = NTSTATUS(-1_071_046_650_i32); + pub const STATUS_PCP_CLAIM_TYPE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_046_628_i32); + pub const STATUS_PCP_DEVICE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_046_643_i32); + pub const STATUS_PCP_DEVICE_NOT_READY: NTSTATUS = NTSTATUS(-1_071_046_655_i32); + pub const STATUS_PCP_ERROR_MASK: NTSTATUS = NTSTATUS(-1_071_046_656_i32); + pub const STATUS_PCP_FLAG_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_046_652_i32); + pub const STATUS_PCP_IFX_RSA_KEY_CREATION_BLOCKED: NTSTATUS = NTSTATUS(-1_071_046_625_i32); + pub const STATUS_PCP_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1_071_046_649_i32); + pub const STATUS_PCP_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1_071_046_654_i32); + pub const STATUS_PCP_INVALID_PARAMETER: NTSTATUS = NTSTATUS(-1_071_046_653_i32); + pub const STATUS_PCP_KEY_ALREADY_FINALIZED: NTSTATUS = NTSTATUS(-1_071_046_636_i32); + pub const STATUS_PCP_KEY_HANDLE_INVALIDATED: NTSTATUS = NTSTATUS(-1_071_046_622_i32); + pub const STATUS_PCP_KEY_NOT_AIK: NTSTATUS = NTSTATUS(-1_071_046_631_i32); + pub const STATUS_PCP_KEY_NOT_AUTHENTICATED: NTSTATUS = NTSTATUS(-1_071_046_632_i32); + pub const STATUS_PCP_KEY_NOT_FINALIZED: NTSTATUS = NTSTATUS(-1_071_046_639_i32); + pub const STATUS_PCP_KEY_NOT_LOADED: NTSTATUS = NTSTATUS(-1_071_046_641_i32); + pub const STATUS_PCP_KEY_NOT_SIGNING_KEY: NTSTATUS = NTSTATUS(-1_071_046_630_i32); + pub const STATUS_PCP_KEY_USAGE_POLICY_INVALID: NTSTATUS = NTSTATUS(-1_071_046_634_i32); + pub const STATUS_PCP_KEY_USAGE_POLICY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_046_635_i32); + pub const STATUS_PCP_LOCKED_OUT: NTSTATUS = NTSTATUS(-1_071_046_629_i32); + pub const STATUS_PCP_NOT_PCR_BOUND: NTSTATUS = NTSTATUS(-1_071_046_637_i32); + pub const STATUS_PCP_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_046_651_i32); + pub const STATUS_PCP_NO_KEY_CERTIFICATION: NTSTATUS = NTSTATUS(-1_071_046_640_i32); + pub const STATUS_PCP_POLICY_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_046_646_i32); + pub const STATUS_PCP_PROFILE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_046_645_i32); + pub const STATUS_PCP_RAW_POLICY_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_046_623_i32); + pub const STATUS_PCP_SOFT_KEY_ERROR: NTSTATUS = NTSTATUS(-1_071_046_633_i32); + pub const STATUS_PCP_TICKET_MISSING: NTSTATUS = NTSTATUS(-1_071_046_624_i32); + pub const STATUS_PCP_TPM_VERSION_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_071_046_627_i32); + pub const STATUS_PCP_UNSUPPORTED_PSS_SALT: NTSTATUS = NTSTATUS(1_076_437_027_i32); + pub const STATUS_PCP_VALIDATION_FAILED: NTSTATUS = NTSTATUS(-1_071_046_644_i32); + pub const STATUS_PCP_WRONG_PARENT: NTSTATUS = NTSTATUS(-1_071_046_642_i32); + pub const STATUS_PENDING: NTSTATUS = NTSTATUS(259i32); + pub const STATUS_PER_USER_TRUST_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_740_799_i32); + pub const STATUS_PIPE_BROKEN: NTSTATUS = NTSTATUS(-1_073_741_493_i32); + pub const STATUS_PIPE_BUSY: NTSTATUS = NTSTATUS(-1_073_741_650_i32); + pub const STATUS_PIPE_CLOSING: NTSTATUS = NTSTATUS(-1_073_741_647_i32); + pub const STATUS_PIPE_CONNECTED: NTSTATUS = NTSTATUS(-1_073_741_646_i32); + pub const STATUS_PIPE_DISCONNECTED: NTSTATUS = NTSTATUS(-1_073_741_648_i32); + pub const STATUS_PIPE_EMPTY: NTSTATUS = NTSTATUS(-1_073_741_607_i32); + pub const STATUS_PIPE_LISTENING: NTSTATUS = NTSTATUS(-1_073_741_645_i32); + pub const STATUS_PIPE_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_073_741_652_i32); + pub const STATUS_PKINIT_CLIENT_FAILURE: NTSTATUS = NTSTATUS(-1_073_740_916_i32); + pub const STATUS_PKINIT_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_024_i32); + pub const STATUS_PKINIT_NAME_MISMATCH: NTSTATUS = NTSTATUS(-1_073_741_063_i32); + pub const STATUS_PKU2U_CERT_FAILURE: NTSTATUS = NTSTATUS(-1_073_740_753_i32); + pub const STATUS_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND: NTSTATUS = NTSTATUS(-1_058_340_859_i32); + pub const STATUS_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED: NTSTATUS = NTSTATUS(-1_058_340_860_i32); + pub const STATUS_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED: NTSTATUS = NTSTATUS(-1_058_340_861_i32); + pub const STATUS_PLATFORM_MANIFEST_INVALID: NTSTATUS = NTSTATUS(-1_058_340_862_i32); + pub const STATUS_PLATFORM_MANIFEST_NOT_ACTIVE: NTSTATUS = NTSTATUS(-1_058_340_858_i32); + pub const STATUS_PLATFORM_MANIFEST_NOT_AUTHORIZED: NTSTATUS = NTSTATUS(-1_058_340_863_i32); + pub const STATUS_PLATFORM_MANIFEST_NOT_SIGNED: NTSTATUS = NTSTATUS(-1_058_340_857_i32); + pub const STATUS_PLUGPLAY_NO_DEVICE: NTSTATUS = NTSTATUS(-1_073_741_218_i32); + pub const STATUS_PLUGPLAY_QUERY_VETOED: NTSTATUS = NTSTATUS(-2_147_483_608_i32); + pub const STATUS_PNP_BAD_MPS_TABLE: NTSTATUS = NTSTATUS(-1_073_479_627_i32); + pub const STATUS_PNP_DEVICE_CONFIGURATION_PENDING: NTSTATUS = NTSTATUS(-1_073_740_651_i32); + pub const STATUS_PNP_DRIVER_CONFIGURATION_INCOMPLETE: NTSTATUS = NTSTATUS(-1_073_740_653_i32); + pub const STATUS_PNP_DRIVER_CONFIGURATION_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_740_654_i32); + pub const STATUS_PNP_DRIVER_PACKAGE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_740_655_i32); + pub const STATUS_PNP_FUNCTION_DRIVER_REQUIRED: NTSTATUS = NTSTATUS(-1_073_740_652_i32); + pub const STATUS_PNP_INVALID_ID: NTSTATUS = NTSTATUS(-1_073_479_624_i32); + pub const STATUS_PNP_IRQ_TRANSLATION_FAILED: NTSTATUS = NTSTATUS(-1_073_479_625_i32); + pub const STATUS_PNP_NO_COMPAT_DRIVERS: NTSTATUS = NTSTATUS(-1_073_740_656_i32); + pub const STATUS_PNP_REBOOT_REQUIRED: NTSTATUS = NTSTATUS(-1_073_741_102_i32); + pub const STATUS_PNP_RESTART_ENUMERATION: NTSTATUS = NTSTATUS(-1_073_741_106_i32); + pub const STATUS_PNP_TRANSLATION_FAILED: NTSTATUS = NTSTATUS(-1_073_479_626_i32); + pub const STATUS_POLICY_OBJECT_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_158_i32); + pub const STATUS_POLICY_ONLY_IN_DS: NTSTATUS = NTSTATUS(-1_073_741_157_i32); + pub const STATUS_PORT_ALREADY_HAS_COMPLETION_LIST: NTSTATUS = NTSTATUS(-1_073_740_006_i32); + pub const STATUS_PORT_ALREADY_SET: NTSTATUS = NTSTATUS(-1_073_741_752_i32); + pub const STATUS_PORT_CLOSED: NTSTATUS = NTSTATUS(-1_073_740_032_i32); + pub const STATUS_PORT_CONNECTION_REFUSED: NTSTATUS = NTSTATUS(-1_073_741_759_i32); + pub const STATUS_PORT_DISCONNECTED: NTSTATUS = NTSTATUS(-1_073_741_769_i32); + pub const STATUS_PORT_DO_NOT_DISTURB: NTSTATUS = NTSTATUS(-1_073_741_770_i32); + pub const STATUS_PORT_MESSAGE_TOO_LONG: NTSTATUS = NTSTATUS(-1_073_741_777_i32); + pub const STATUS_PORT_NOT_SET: NTSTATUS = NTSTATUS(-1_073_740_973_i32); + pub const STATUS_PORT_UNREACHABLE: NTSTATUS = NTSTATUS(-1_073_741_249_i32); + pub const STATUS_POSSIBLE_DEADLOCK: NTSTATUS = NTSTATUS(-1_073_741_420_i32); + pub const STATUS_POWER_STATE_INVALID: NTSTATUS = NTSTATUS(-1_073_741_101_i32); + pub const STATUS_PREDEFINED_HANDLE: NTSTATUS = NTSTATUS(1_073_741_846_i32); + pub const STATUS_PRENT4_MACHINE_ACCOUNT: NTSTATUS = NTSTATUS(-1_073_740_969_i32); + pub const STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED: NTSTATUS = NTSTATUS(270i32); + pub const STATUS_PRINT_CANCELLED: NTSTATUS = NTSTATUS(-1_073_741_624_i32); + pub const STATUS_PRINT_QUEUE_FULL: NTSTATUS = NTSTATUS(-1_073_741_626_i32); + pub const STATUS_PRIVILEGED_INSTRUCTION: NTSTATUS = NTSTATUS(-1_073_741_674_i32); + pub const STATUS_PRIVILEGE_NOT_HELD: NTSTATUS = NTSTATUS(-1_073_741_727_i32); + pub const STATUS_PROACTIVE_SCAN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_073_739_761_i32); + pub const STATUS_PROCEDURE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_702_i32); + pub const STATUS_PROCESS_CLONED: NTSTATUS = NTSTATUS(297i32); + pub const STATUS_PROCESS_IN_JOB: NTSTATUS = NTSTATUS(292i32); + pub const STATUS_PROCESS_IS_PROTECTED: NTSTATUS = NTSTATUS(-1_073_740_014_i32); + pub const STATUS_PROCESS_IS_TERMINATING: NTSTATUS = NTSTATUS(-1_073_741_558_i32); + pub const STATUS_PROCESS_NOT_IN_JOB: NTSTATUS = NTSTATUS(291i32); + pub const STATUS_PROFILING_AT_LIMIT: NTSTATUS = NTSTATUS(-1_073_741_613_i32); + pub const STATUS_PROFILING_NOT_STARTED: NTSTATUS = NTSTATUS(-1_073_741_641_i32); + pub const STATUS_PROFILING_NOT_STOPPED: NTSTATUS = NTSTATUS(-1_073_741_640_i32); + pub const STATUS_PROPSET_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_264_i32); + pub const STATUS_PROTOCOL_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_700_845_i32); + pub const STATUS_PROTOCOL_UNREACHABLE: NTSTATUS = NTSTATUS(-1_073_741_250_i32); + pub const STATUS_PTE_CHANGED: NTSTATUS = NTSTATUS(-1_073_740_748_i32); + pub const STATUS_PURGE_FAILED: NTSTATUS = NTSTATUS(-1_073_740_747_i32); + pub const STATUS_PWD_HISTORY_CONFLICT: NTSTATUS = NTSTATUS(-1_073_741_220_i32); + pub const STATUS_PWD_TOO_LONG: NTSTATUS = NTSTATUS(-1_073_741_190_i32); + pub const STATUS_PWD_TOO_RECENT: NTSTATUS = NTSTATUS(-1_073_741_221_i32); + pub const STATUS_PWD_TOO_SHORT: NTSTATUS = NTSTATUS(-1_073_741_222_i32); + pub const STATUS_QUERY_STORAGE_ERROR: NTSTATUS = NTSTATUS(-2_143_682_559_i32); + pub const STATUS_QUIC_ALPN_NEG_FAILURE: NTSTATUS = NTSTATUS(-1_071_382_521_i32); + pub const STATUS_QUIC_CONNECTION_IDLE: NTSTATUS = NTSTATUS(-1_071_382_523_i32); + pub const STATUS_QUIC_CONNECTION_TIMEOUT: NTSTATUS = NTSTATUS(-1_071_382_522_i32); + pub const STATUS_QUIC_HANDSHAKE_FAILURE: NTSTATUS = NTSTATUS(-1_071_382_528_i32); + pub const STATUS_QUIC_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1_071_382_525_i32); + pub const STATUS_QUIC_PROTOCOL_VIOLATION: NTSTATUS = NTSTATUS(-1_071_382_524_i32); + pub const STATUS_QUIC_USER_CANCELED: NTSTATUS = NTSTATUS(-1_071_382_526_i32); + pub const STATUS_QUIC_VER_NEG_FAILURE: NTSTATUS = NTSTATUS(-1_071_382_527_i32); + pub const STATUS_QUOTA_ACTIVITY: NTSTATUS = NTSTATUS(-1_073_740_662_i32); + pub const STATUS_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_756_i32); + pub const STATUS_QUOTA_LIST_INCONSISTENT: NTSTATUS = NTSTATUS(-1_073_741_210_i32); + pub const STATUS_QUOTA_NOT_ENABLED: NTSTATUS = NTSTATUS(-1_073_741_399_i32); + pub const STATUS_RANGE_LIST_CONFLICT: NTSTATUS = NTSTATUS(-1_073_741_182_i32); + pub const STATUS_RANGE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_172_i32); + pub const STATUS_RANGE_NOT_LOCKED: NTSTATUS = NTSTATUS(-1_073_741_698_i32); + pub const STATUS_RDBSS_CONTINUE_OPERATION: NTSTATUS = NTSTATUS(-1_069_481_982_i32); + pub const STATUS_RDBSS_POST_OPERATION: NTSTATUS = NTSTATUS(-1_069_481_981_i32); + pub const STATUS_RDBSS_RESTART_OPERATION: NTSTATUS = NTSTATUS(-1_069_481_983_i32); + pub const STATUS_RDBSS_RETRY_LOOKUP: NTSTATUS = NTSTATUS(-1_069_481_980_i32); + pub const STATUS_RDP_PROTOCOL_ERROR: NTSTATUS = NTSTATUS(-1_073_086_414_i32); + pub const STATUS_RECEIVE_EXPEDITED: NTSTATUS = NTSTATUS(1_073_741_840_i32); + pub const STATUS_RECEIVE_PARTIAL: NTSTATUS = NTSTATUS(1_073_741_839_i32); + pub const STATUS_RECEIVE_PARTIAL_EXPEDITED: NTSTATUS = NTSTATUS(1_073_741_841_i32); + pub const STATUS_RECOVERABLE_BUGCHECK: NTSTATUS = NTSTATUS(-2_147_483_596_i32); + pub const STATUS_RECOVERY_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_273_i32); + pub const STATUS_RECOVERY_NOT_NEEDED: NTSTATUS = NTSTATUS(1_075_380_276_i32); + pub const STATUS_RECURSIVE_DISPATCH: NTSTATUS = NTSTATUS(-1_073_740_028_i32); + pub const STATUS_REDIRECTOR_HAS_OPEN_HANDLES: NTSTATUS = NTSTATUS(-2_147_483_613_i32); + pub const STATUS_REDIRECTOR_NOT_STARTED: NTSTATUS = NTSTATUS(-1_073_741_573_i32); + pub const STATUS_REDIRECTOR_PAUSED: NTSTATUS = NTSTATUS(-1_073_741_615_i32); + pub const STATUS_REDIRECTOR_STARTED: NTSTATUS = NTSTATUS(-1_073_741_572_i32); + pub const STATUS_REGISTRY_CORRUPT: NTSTATUS = NTSTATUS(-1_073_741_492_i32); + pub const STATUS_REGISTRY_HIVE_RECOVERED: NTSTATUS = NTSTATUS(-2_147_483_606_i32); + pub const STATUS_REGISTRY_IO_FAILED: NTSTATUS = NTSTATUS(-1_073_741_491_i32); + pub const STATUS_REGISTRY_QUOTA_LIMIT: NTSTATUS = NTSTATUS(-1_073_741_226_i32); + pub const STATUS_REGISTRY_RECOVERED: NTSTATUS = NTSTATUS(1_073_741_833_i32); + pub const STATUS_REG_NAT_CONSUMPTION: NTSTATUS = NTSTATUS(-1_073_741_111_i32); + pub const STATUS_REINITIALIZATION_NEEDED: NTSTATUS = NTSTATUS(-1_073_741_177_i32); + pub const STATUS_REMOTE_DISCONNECT: NTSTATUS = NTSTATUS(-1_073_741_508_i32); + pub const STATUS_REMOTE_FILE_VERSION_MISMATCH: NTSTATUS = NTSTATUS(-1_072_103_412_i32); + pub const STATUS_REMOTE_NOT_LISTENING: NTSTATUS = NTSTATUS(-1_073_741_636_i32); + pub const STATUS_REMOTE_RESOURCES: NTSTATUS = NTSTATUS(-1_073_741_507_i32); + pub const STATUS_REMOTE_SESSION_LIMIT: NTSTATUS = NTSTATUS(-1_073_741_418_i32); + pub const STATUS_REMOTE_STORAGE_MEDIA_ERROR: NTSTATUS = NTSTATUS(-1_073_741_154_i32); + pub const STATUS_REMOTE_STORAGE_NOT_ACTIVE: NTSTATUS = NTSTATUS(-1_073_741_155_i32); + pub const STATUS_REPAIR_NEEDED: NTSTATUS = NTSTATUS(-1_073_741_400_i32); + pub const STATUS_REPARSE: NTSTATUS = NTSTATUS(260i32); + pub const STATUS_REPARSE_ATTRIBUTE_CONFLICT: NTSTATUS = NTSTATUS(-1_073_741_134_i32); + pub const STATUS_REPARSE_GLOBAL: NTSTATUS = NTSTATUS(872i32); + pub const STATUS_REPARSE_OBJECT: NTSTATUS = NTSTATUS(280i32); + pub const STATUS_REPARSE_POINT_ENCOUNTERED: NTSTATUS = NTSTATUS(-1_073_740_533_i32); + pub const STATUS_REPARSE_POINT_NOT_RESOLVED: NTSTATUS = NTSTATUS(-1_073_741_184_i32); + pub const STATUS_REPLY_MESSAGE_MISMATCH: NTSTATUS = NTSTATUS(-1_073_741_281_i32); + pub const STATUS_REQUEST_ABORTED: NTSTATUS = NTSTATUS(-1_073_741_248_i32); + pub const STATUS_REQUEST_CANCELED: NTSTATUS = NTSTATUS(-1_073_740_029_i32); + pub const STATUS_REQUEST_NOT_ACCEPTED: NTSTATUS = NTSTATUS(-1_073_741_616_i32); + pub const STATUS_REQUEST_OUT_OF_SEQUENCE: NTSTATUS = NTSTATUS(-1_073_740_758_i32); + pub const STATUS_REQUEST_PAUSED: NTSTATUS = NTSTATUS(-1_073_740_711_i32); + pub const STATUS_RESIDENT_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_678_i32); + pub const STATUS_RESOURCEMANAGER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_103_345_i32); + pub const STATUS_RESOURCEMANAGER_READ_ONLY: NTSTATUS = NTSTATUS(514i32); + pub const STATUS_RESOURCE_DATA_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_687_i32); + pub const STATUS_RESOURCE_ENUM_USER_STOP: NTSTATUS = NTSTATUS(-1_073_020_921_i32); + pub const STATUS_RESOURCE_IN_USE: NTSTATUS = NTSTATUS(-1_073_740_024_i32); + pub const STATUS_RESOURCE_LANG_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_308_i32); + pub const STATUS_RESOURCE_NAME_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_685_i32); + pub const STATUS_RESOURCE_NOT_OWNED: NTSTATUS = NTSTATUS(-1_073_741_212_i32); + pub const STATUS_RESOURCE_REQUIREMENTS_CHANGED: NTSTATUS = NTSTATUS(281i32); + pub const STATUS_RESOURCE_TYPE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_686_i32); + pub const STATUS_RESTART_BOOT_APPLICATION: NTSTATUS = NTSTATUS(-1_073_740_717_i32); + pub const STATUS_RESUME_HIBERNATION: NTSTATUS = NTSTATUS(1_073_741_867_i32); + pub const STATUS_RETRY: NTSTATUS = NTSTATUS(-1_073_741_267_i32); + pub const STATUS_RETURN_ADDRESS_HIJACK_ATTEMPT: NTSTATUS = NTSTATUS(-2_147_483_597_i32); + pub const STATUS_REVISION_MISMATCH: NTSTATUS = NTSTATUS(-1_073_741_735_i32); + pub const STATUS_REVOCATION_OFFLINE_C: NTSTATUS = NTSTATUS(-1_073_740_917_i32); + pub const STATUS_REVOCATION_OFFLINE_KDC: NTSTATUS = NTSTATUS(-1_073_740_788_i32); + pub const STATUS_RING_NEWLY_EMPTY: NTSTATUS = NTSTATUS(531i32); + pub const STATUS_RING_PREVIOUSLY_ABOVE_QUOTA: NTSTATUS = NTSTATUS(530i32); + pub const STATUS_RING_PREVIOUSLY_EMPTY: NTSTATUS = NTSTATUS(528i32); + pub const STATUS_RING_PREVIOUSLY_FULL: NTSTATUS = NTSTATUS(529i32); + pub const STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT: NTSTATUS = NTSTATUS(532i32); + pub const STATUS_RKF_ACTIVE_KEY: NTSTATUS = NTSTATUS(-1_069_547_514_i32); + pub const STATUS_RKF_BLOB_FULL: NTSTATUS = NTSTATUS(-1_069_547_517_i32); + pub const STATUS_RKF_DUPLICATE_KEY: NTSTATUS = NTSTATUS(-1_069_547_518_i32); + pub const STATUS_RKF_FILE_BLOCKED: NTSTATUS = NTSTATUS(-1_069_547_515_i32); + pub const STATUS_RKF_KEY_NOT_FOUND: NTSTATUS = NTSTATUS(-1_069_547_519_i32); + pub const STATUS_RKF_STORE_FULL: NTSTATUS = NTSTATUS(-1_069_547_516_i32); + pub const STATUS_RM_ALREADY_STARTED: NTSTATUS = NTSTATUS(1_075_380_277_i32); + pub const STATUS_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT: NTSTATUS = NTSTATUS(-1_072_103_331_i32); + pub const STATUS_RM_DISCONNECTED: NTSTATUS = NTSTATUS(-1_072_103_374_i32); + pub const STATUS_RM_METADATA_CORRUPT: NTSTATUS = NTSTATUS(-1_072_103_418_i32); + pub const STATUS_RM_NOT_ACTIVE: NTSTATUS = NTSTATUS(-1_072_103_419_i32); + pub const STATUS_ROLLBACK_TIMER_EXPIRED: NTSTATUS = NTSTATUS(-1_072_103_364_i32); + pub const STATUS_RTPM_CONTEXT_COMPLETE: NTSTATUS = NTSTATUS(2_699_265_i32); + pub const STATUS_RTPM_CONTEXT_CONTINUE: NTSTATUS = NTSTATUS(2_699_264_i32); + pub const STATUS_RTPM_INVALID_CONTEXT: NTSTATUS = NTSTATUS(-1_071_042_556_i32); + pub const STATUS_RTPM_NO_RESULT: NTSTATUS = NTSTATUS(-1_071_042_558_i32); + pub const STATUS_RTPM_PCR_READ_INCOMPLETE: NTSTATUS = NTSTATUS(-1_071_042_557_i32); + pub const STATUS_RTPM_UNSUPPORTED_CMD: NTSTATUS = NTSTATUS(-1_071_042_555_i32); + pub const STATUS_RUNLEVEL_SWITCH_AGENT_TIMEOUT: NTSTATUS = NTSTATUS(-1_073_700_539_i32); + pub const STATUS_RUNLEVEL_SWITCH_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_073_700_538_i32); + pub const STATUS_RUNLEVEL_SWITCH_TIMEOUT: NTSTATUS = NTSTATUS(-1_073_700_541_i32); + pub const STATUS_RWRAW_ENCRYPTED_FILE_NOT_ENCRYPTED: NTSTATUS = NTSTATUS(-1_073_740_633_i32); + pub const STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILEOFFSET: NTSTATUS = NTSTATUS(-1_073_740_632_i32); + pub const STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_FILERANGE: NTSTATUS = NTSTATUS(-1_073_740_631_i32); + pub const STATUS_RWRAW_ENCRYPTED_INVALID_EDATAINFO_PARAMETER: NTSTATUS = NTSTATUS(-1_073_740_630_i32); + pub const STATUS_RXACT_COMMITTED: NTSTATUS = NTSTATUS(266i32); + pub const STATUS_RXACT_COMMIT_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_539_i32); + pub const STATUS_RXACT_COMMIT_NECESSARY: NTSTATUS = NTSTATUS(-2_147_483_624_i32); + pub const STATUS_RXACT_INVALID_STATE: NTSTATUS = NTSTATUS(-1_073_741_540_i32); + pub const STATUS_RXACT_STATE_CREATED: NTSTATUS = NTSTATUS(1_073_741_828_i32); + pub const STATUS_SAM_INIT_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_085_i32); + pub const STATUS_SAM_NEED_BOOTKEY_FLOPPY: NTSTATUS = NTSTATUS(-1_073_741_088_i32); + pub const STATUS_SAM_NEED_BOOTKEY_PASSWORD: NTSTATUS = NTSTATUS(-1_073_741_089_i32); + pub const STATUS_SCRUB_DATA_DISABLED: NTSTATUS = NTSTATUS(-1_073_740_680_i32); + pub const STATUS_SECCORE_INVALID_COMMAND: NTSTATUS = NTSTATUS(-1_058_537_472_i32); + pub const STATUS_SECONDARY_IC_PROVIDER_NOT_REGISTERED: NTSTATUS = NTSTATUS(-1_073_700_575_i32); + pub const STATUS_SECRET_TOO_LONG: NTSTATUS = NTSTATUS(-1_073_741_481_i32); + pub const STATUS_SECTION_DIRECT_MAP_ONLY: NTSTATUS = NTSTATUS(-1_073_739_503_i32); + pub const STATUS_SECTION_NOT_EXTENDED: NTSTATUS = NTSTATUS(-1_073_741_689_i32); + pub const STATUS_SECTION_NOT_IMAGE: NTSTATUS = NTSTATUS(-1_073_741_751_i32); + pub const STATUS_SECTION_PROTECTION: NTSTATUS = NTSTATUS(-1_073_741_746_i32); + pub const STATUS_SECTION_TOO_BIG: NTSTATUS = NTSTATUS(-1_073_741_760_i32); + pub const STATUS_SECUREBOOT_FILE_REPLACED: NTSTATUS = NTSTATUS(-1_069_350_905_i32); + pub const STATUS_SECUREBOOT_INVALID_POLICY: NTSTATUS = NTSTATUS(-1_069_350_909_i32); + pub const STATUS_SECUREBOOT_NOT_BASE_POLICY: NTSTATUS = NTSTATUS(-1_069_350_897_i32); + pub const STATUS_SECUREBOOT_NOT_ENABLED: NTSTATUS = NTSTATUS(-2_143_092_730_i32); + pub const STATUS_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY: NTSTATUS = NTSTATUS(-1_069_350_896_i32); + pub const STATUS_SECUREBOOT_PLATFORM_ID_MISMATCH: NTSTATUS = NTSTATUS(-1_069_350_901_i32); + pub const STATUS_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION: NTSTATUS = NTSTATUS(-1_069_350_902_i32); + pub const STATUS_SECUREBOOT_POLICY_NOT_AUTHORIZED: NTSTATUS = NTSTATUS(-1_069_350_904_i32); + pub const STATUS_SECUREBOOT_POLICY_NOT_SIGNED: NTSTATUS = NTSTATUS(-1_069_350_907_i32); + pub const STATUS_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_069_350_908_i32); + pub const STATUS_SECUREBOOT_POLICY_ROLLBACK_DETECTED: NTSTATUS = NTSTATUS(-1_069_350_900_i32); + pub const STATUS_SECUREBOOT_POLICY_UNKNOWN: NTSTATUS = NTSTATUS(-1_069_350_903_i32); + pub const STATUS_SECUREBOOT_POLICY_UPGRADE_MISMATCH: NTSTATUS = NTSTATUS(-1_069_350_899_i32); + pub const STATUS_SECUREBOOT_POLICY_VIOLATION: NTSTATUS = NTSTATUS(-1_069_350_910_i32); + pub const STATUS_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING: NTSTATUS = NTSTATUS(-1_069_350_898_i32); + pub const STATUS_SECUREBOOT_ROLLBACK_DETECTED: NTSTATUS = NTSTATUS(-1_069_350_911_i32); + pub const STATUS_SECURITY_STREAM_IS_INCONSISTENT: NTSTATUS = NTSTATUS(-1_073_741_408_i32); + pub const STATUS_SEGMENT_NOTIFICATION: NTSTATUS = NTSTATUS(1_073_741_829_i32); + pub const STATUS_SEMAPHORE_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_753_i32); + pub const STATUS_SERIAL_COUNTER_TIMEOUT: NTSTATUS = NTSTATUS(1_073_741_836_i32); + pub const STATUS_SERIAL_MORE_WRITES: NTSTATUS = NTSTATUS(1_073_741_832_i32); + pub const STATUS_SERIAL_NO_DEVICE_INITED: NTSTATUS = NTSTATUS(-1_073_741_488_i32); + pub const STATUS_SERVER_DISABLED: NTSTATUS = NTSTATUS(-1_073_741_696_i32); + pub const STATUS_SERVER_HAS_OPEN_HANDLES: NTSTATUS = NTSTATUS(-2_147_483_612_i32); + pub const STATUS_SERVER_NOT_DISABLED: NTSTATUS = NTSTATUS(-1_073_741_695_i32); + pub const STATUS_SERVER_SHUTDOWN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_073_741_057_i32); + pub const STATUS_SERVER_SID_MISMATCH: NTSTATUS = NTSTATUS(-1_073_741_152_i32); + pub const STATUS_SERVER_TRANSPORT_CONFLICT: NTSTATUS = NTSTATUS(-1_073_741_388_i32); + pub const STATUS_SERVER_UNAVAILABLE: NTSTATUS = NTSTATUS(-1_073_740_698_i32); + pub const STATUS_SERVICES_FAILED_AUTOSTART: NTSTATUS = NTSTATUS(1_073_783_108_i32); + pub const STATUS_SERVICE_NOTIFICATION: NTSTATUS = NTSTATUS(1_073_741_848_i32); + pub const STATUS_SESSION_KEY_TOO_SHORT: NTSTATUS = NTSTATUS(-1_073_740_521_i32); + pub const STATUS_SETMARK_DETECTED: NTSTATUS = NTSTATUS(-2_147_483_615_i32); + pub const STATUS_SET_CONTEXT_DENIED: NTSTATUS = NTSTATUS(-1_073_740_278_i32); + pub const STATUS_SHARED_IRQ_BUSY: NTSTATUS = NTSTATUS(-1_073_741_460_i32); + pub const STATUS_SHARED_POLICY: NTSTATUS = NTSTATUS(-1_073_741_159_i32); + pub const STATUS_SHARE_UNAVAILABLE: NTSTATUS = NTSTATUS(-1_073_740_672_i32); + pub const STATUS_SHARING_PAUSED: NTSTATUS = NTSTATUS(-1_073_741_617_i32); + pub const STATUS_SHARING_VIOLATION: NTSTATUS = NTSTATUS(-1_073_741_757_i32); + pub const STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME: NTSTATUS = NTSTATUS(-1_073_741_409_i32); + pub const STATUS_SHUTDOWN_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_073_741_058_i32); + pub const STATUS_SINGLE_STEP: NTSTATUS = NTSTATUS(-2_147_483_644_i32); + pub const STATUS_SMARTCARD_CARD_BLOCKED: NTSTATUS = NTSTATUS(-1_073_740_927_i32); + pub const STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED: NTSTATUS = NTSTATUS(-1_073_740_926_i32); + pub const STATUS_SMARTCARD_CERT_EXPIRED: NTSTATUS = NTSTATUS(-1_073_740_915_i32); + pub const STATUS_SMARTCARD_CERT_REVOKED: NTSTATUS = NTSTATUS(-1_073_740_919_i32); + pub const STATUS_SMARTCARD_IO_ERROR: NTSTATUS = NTSTATUS(-1_073_740_921_i32); + pub const STATUS_SMARTCARD_LOGON_REQUIRED: NTSTATUS = NTSTATUS(-1_073_741_062_i32); + pub const STATUS_SMARTCARD_NO_CARD: NTSTATUS = NTSTATUS(-1_073_740_925_i32); + pub const STATUS_SMARTCARD_NO_CERTIFICATE: NTSTATUS = NTSTATUS(-1_073_740_923_i32); + pub const STATUS_SMARTCARD_NO_KEYSET: NTSTATUS = NTSTATUS(-1_073_740_922_i32); + pub const STATUS_SMARTCARD_NO_KEY_CONTAINER: NTSTATUS = NTSTATUS(-1_073_740_924_i32); + pub const STATUS_SMARTCARD_SILENT_CONTEXT: NTSTATUS = NTSTATUS(-1_073_740_913_i32); + pub const STATUS_SMARTCARD_SUBSYSTEM_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_023_i32); + pub const STATUS_SMARTCARD_WRONG_PIN: NTSTATUS = NTSTATUS(-1_073_740_928_i32); + pub const STATUS_SMB1_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_073_740_525_i32); + pub const STATUS_SMB_BAD_CLUSTER_DIALECT: NTSTATUS = NTSTATUS(-1_067_646_975_i32); + pub const STATUS_SMB_GUEST_LOGON_BLOCKED: NTSTATUS = NTSTATUS(-1_067_646_974_i32); + pub const STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP: NTSTATUS = NTSTATUS(-1_067_646_976_i32); + pub const STATUS_SMB_NO_SIGNING_ALGORITHM_OVERLAP: NTSTATUS = NTSTATUS(-1_067_646_973_i32); + pub const STATUS_SMI_PRIMITIVE_INSTALLER_FAILED: NTSTATUS = NTSTATUS(-1_072_365_531_i32); + pub const STATUS_SMR_GARBAGE_COLLECTION_REQUIRED: NTSTATUS = NTSTATUS(-1_073_740_524_i32); + pub const STATUS_SOME_NOT_MAPPED: NTSTATUS = NTSTATUS(263i32); + pub const STATUS_SOURCE_ELEMENT_EMPTY: NTSTATUS = NTSTATUS(-1_073_741_181_i32); + pub const STATUS_SPACES_ALLOCATION_SIZE_INVALID: NTSTATUS = NTSTATUS(-1_058_602_994_i32); + pub const STATUS_SPACES_CACHE_FULL: NTSTATUS = NTSTATUS(-1_058_602_970_i32); + pub const STATUS_SPACES_COMPLETE: NTSTATUS = NTSTATUS(15_138_818_i32); + pub const STATUS_SPACES_CORRUPT_METADATA: NTSTATUS = NTSTATUS(-1_058_602_986_i32); + pub const STATUS_SPACES_DRIVE_LOST_DATA: NTSTATUS = NTSTATUS(-1_058_602_979_i32); + pub const STATUS_SPACES_DRIVE_NOT_READY: NTSTATUS = NTSTATUS(-1_058_602_981_i32); + pub const STATUS_SPACES_DRIVE_OPERATIONAL_STATE_INVALID: NTSTATUS = NTSTATUS(-1_058_602_990_i32); + pub const STATUS_SPACES_DRIVE_REDUNDANCY_INVALID: NTSTATUS = NTSTATUS(-1_058_603_002_i32); + pub const STATUS_SPACES_DRIVE_SECTOR_SIZE_INVALID: NTSTATUS = NTSTATUS(-1_058_603_004_i32); + pub const STATUS_SPACES_DRIVE_SPLIT: NTSTATUS = NTSTATUS(-1_058_602_980_i32); + pub const STATUS_SPACES_DRT_FULL: NTSTATUS = NTSTATUS(-1_058_602_985_i32); + pub const STATUS_SPACES_ENCLOSURE_AWARE_INVALID: NTSTATUS = NTSTATUS(-1_058_602_993_i32); + pub const STATUS_SPACES_ENTRY_INCOMPLETE: NTSTATUS = NTSTATUS(-1_058_602_978_i32); + pub const STATUS_SPACES_ENTRY_INVALID: NTSTATUS = NTSTATUS(-1_058_602_977_i32); + pub const STATUS_SPACES_EXTENDED_ERROR: NTSTATUS = NTSTATUS(-1_058_602_996_i32); + pub const STATUS_SPACES_FAULT_DOMAIN_TYPE_INVALID: NTSTATUS = NTSTATUS(-1_058_603_007_i32); + pub const STATUS_SPACES_FLUSH_METADATA: NTSTATUS = NTSTATUS(-1_058_602_971_i32); + pub const STATUS_SPACES_INCONSISTENCY: NTSTATUS = NTSTATUS(-1_058_602_984_i32); + pub const STATUS_SPACES_INTERLEAVE_LENGTH_INVALID: NTSTATUS = NTSTATUS(-1_058_602_999_i32); + pub const STATUS_SPACES_LOG_NOT_READY: NTSTATUS = NTSTATUS(-1_058_602_983_i32); + pub const STATUS_SPACES_MAP_REQUIRED: NTSTATUS = NTSTATUS(-1_058_602_988_i32); + pub const STATUS_SPACES_MARK_DIRTY: NTSTATUS = NTSTATUS(-1_058_602_976_i32); + pub const STATUS_SPACES_NOT_ENOUGH_DRIVES: NTSTATUS = NTSTATUS(-1_058_602_997_i32); + pub const STATUS_SPACES_NO_REDUNDANCY: NTSTATUS = NTSTATUS(-1_058_602_982_i32); + pub const STATUS_SPACES_NUMBER_OF_COLUMNS_INVALID: NTSTATUS = NTSTATUS(-1_058_602_998_i32); + pub const STATUS_SPACES_NUMBER_OF_DATA_COPIES_INVALID: NTSTATUS = NTSTATUS(-1_058_603_001_i32); + pub const STATUS_SPACES_NUMBER_OF_GROUPS_INVALID: NTSTATUS = NTSTATUS(-1_058_602_991_i32); + pub const STATUS_SPACES_PAUSE: NTSTATUS = NTSTATUS(15_138_817_i32); + pub const STATUS_SPACES_PD_INVALID_DATA: NTSTATUS = NTSTATUS(-1_058_602_972_i32); + pub const STATUS_SPACES_PD_LENGTH_MISMATCH: NTSTATUS = NTSTATUS(-1_058_602_974_i32); + pub const STATUS_SPACES_PD_NOT_FOUND: NTSTATUS = NTSTATUS(-1_058_602_975_i32); + pub const STATUS_SPACES_PD_UNSUPPORTED_VERSION: NTSTATUS = NTSTATUS(-1_058_602_973_i32); + pub const STATUS_SPACES_PROVISIONING_TYPE_INVALID: NTSTATUS = NTSTATUS(-1_058_602_995_i32); + pub const STATUS_SPACES_REDIRECT: NTSTATUS = NTSTATUS(15_138_819_i32); + pub const STATUS_SPACES_REPAIRED: NTSTATUS = NTSTATUS(15_138_816_i32); + pub const STATUS_SPACES_REPAIR_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_058_602_969_i32); + pub const STATUS_SPACES_RESILIENCY_TYPE_INVALID: NTSTATUS = NTSTATUS(-1_058_603_005_i32); + pub const STATUS_SPACES_UNSUPPORTED_VERSION: NTSTATUS = NTSTATUS(-1_058_602_987_i32); + pub const STATUS_SPACES_UPDATE_COLUMN_STATE: NTSTATUS = NTSTATUS(-1_058_602_989_i32); + pub const STATUS_SPACES_WRITE_CACHE_SIZE_INVALID: NTSTATUS = NTSTATUS(-1_058_602_992_i32); + pub const STATUS_SPARSE_FILE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_604_i32); + pub const STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION: NTSTATUS = NTSTATUS(-1_072_103_351_i32); + pub const STATUS_SPECIAL_ACCOUNT: NTSTATUS = NTSTATUS(-1_073_741_532_i32); + pub const STATUS_SPECIAL_GROUP: NTSTATUS = NTSTATUS(-1_073_741_531_i32); + pub const STATUS_SPECIAL_USER: NTSTATUS = NTSTATUS(-1_073_741_530_i32); + pub const STATUS_STACK_BUFFER_OVERRUN: NTSTATUS = NTSTATUS(-1_073_740_791_i32); + pub const STATUS_STACK_OVERFLOW: NTSTATUS = NTSTATUS(-1_073_741_571_i32); + pub const STATUS_STACK_OVERFLOW_READ: NTSTATUS = NTSTATUS(-1_073_741_272_i32); + pub const STATUS_STOPPED_ON_SYMLINK: NTSTATUS = NTSTATUS(-2_147_483_603_i32); + pub const STATUS_STORAGE_LOST_DATA_PERSISTENCE: NTSTATUS = NTSTATUS(-1_073_740_642_i32); + pub const STATUS_STORAGE_RESERVE_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1_073_740_625_i32); + pub const STATUS_STORAGE_RESERVE_DOES_NOT_EXIST: NTSTATUS = NTSTATUS(-1_073_740_626_i32); + pub const STATUS_STORAGE_RESERVE_ID_INVALID: NTSTATUS = NTSTATUS(-1_073_740_627_i32); + pub const STATUS_STORAGE_RESERVE_NOT_EMPTY: NTSTATUS = NTSTATUS(-1_073_740_624_i32); + pub const STATUS_STORAGE_STACK_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_073_740_607_i32); + pub const STATUS_STORAGE_TOPOLOGY_ID_MISMATCH: NTSTATUS = NTSTATUS(-1_073_740_666_i32); + pub const STATUS_STOWED_EXCEPTION: NTSTATUS = NTSTATUS(-1_073_741_189_i32); + pub const STATUS_STREAM_MINIVERSION_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_103_390_i32); + pub const STATUS_STREAM_MINIVERSION_NOT_VALID: NTSTATUS = NTSTATUS(-1_072_103_389_i32); + pub const STATUS_STRICT_CFG_VIOLATION: NTSTATUS = NTSTATUS(-1_073_740_282_i32); + pub const STATUS_STRONG_CRYPTO_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_741_066_i32); + pub const STATUS_SUCCESS: NTSTATUS = NTSTATUS(0i32); + pub const STATUS_SUSPEND_COUNT_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_741_750_i32); + pub const STATUS_SVHDX_ERROR_NOT_AVAILABLE: NTSTATUS = NTSTATUS(-1_067_647_232_i32); + pub const STATUS_SVHDX_ERROR_STORED: NTSTATUS = NTSTATUS(-1_067_712_512_i32); + pub const STATUS_SVHDX_NO_INITIATOR: NTSTATUS = NTSTATUS(-1_067_647_221_i32); + pub const STATUS_SVHDX_RESERVATION_CONFLICT: NTSTATUS = NTSTATUS(-1_067_647_225_i32); + pub const STATUS_SVHDX_UNIT_ATTENTION_AVAILABLE: NTSTATUS = NTSTATUS(-1_067_647_231_i32); + pub const STATUS_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGED: NTSTATUS = NTSTATUS(-1_067_647_230_i32); + pub const STATUS_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGED: NTSTATUS = NTSTATUS(-1_067_647_226_i32); + pub const STATUS_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTED: NTSTATUS = NTSTATUS(-1_067_647_227_i32); + pub const STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTED: NTSTATUS = NTSTATUS(-1_067_647_229_i32); + pub const STATUS_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASED: NTSTATUS = NTSTATUS(-1_067_647_228_i32); + pub const STATUS_SVHDX_VERSION_MISMATCH: NTSTATUS = NTSTATUS(-1_067_647_223_i32); + pub const STATUS_SVHDX_WRONG_FILE_TYPE: NTSTATUS = NTSTATUS(-1_067_647_224_i32); + pub const STATUS_SXS_ACTIVATION_CONTEXT_DISABLED: NTSTATUS = NTSTATUS(-1_072_365_561_i32); + pub const STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT: NTSTATUS = NTSTATUS(-1_072_365_538_i32); + pub const STATUS_SXS_ASSEMBLY_MISSING: NTSTATUS = NTSTATUS(-1_072_365_556_i32); + pub const STATUS_SXS_ASSEMBLY_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_365_564_i32); + pub const STATUS_SXS_CANT_GEN_ACTCTX: NTSTATUS = NTSTATUS(-1_072_365_566_i32); + pub const STATUS_SXS_COMPONENT_STORE_CORRUPT: NTSTATUS = NTSTATUS(-1_072_365_542_i32); + pub const STATUS_SXS_CORRUPTION: NTSTATUS = NTSTATUS(-1_072_365_547_i32); + pub const STATUS_SXS_CORRUPT_ACTIVATION_STACK: NTSTATUS = NTSTATUS(-1_072_365_548_i32); + pub const STATUS_SXS_EARLY_DEACTIVATION: NTSTATUS = NTSTATUS(-1_072_365_553_i32); + pub const STATUS_SXS_FILE_HASH_MISMATCH: NTSTATUS = NTSTATUS(-1_072_365_541_i32); + pub const STATUS_SXS_FILE_HASH_MISSING: NTSTATUS = NTSTATUS(-1_072_365_529_i32); + pub const STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY: NTSTATUS = NTSTATUS(-1_072_365_537_i32); + pub const STATUS_SXS_IDENTITIES_DIFFERENT: NTSTATUS = NTSTATUS(-1_072_365_539_i32); + pub const STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE: NTSTATUS = NTSTATUS(-1_072_365_544_i32); + pub const STATUS_SXS_IDENTITY_PARSE_ERROR: NTSTATUS = NTSTATUS(-1_072_365_543_i32); + pub const STATUS_SXS_INVALID_ACTCTXDATA_FORMAT: NTSTATUS = NTSTATUS(-1_072_365_565_i32); + pub const STATUS_SXS_INVALID_DEACTIVATION: NTSTATUS = NTSTATUS(-1_072_365_552_i32); + pub const STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME: NTSTATUS = NTSTATUS(-1_072_365_545_i32); + pub const STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE: NTSTATUS = NTSTATUS(-1_072_365_546_i32); + pub const STATUS_SXS_KEY_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_365_560_i32); + pub const STATUS_SXS_MANIFEST_FORMAT_ERROR: NTSTATUS = NTSTATUS(-1_072_365_563_i32); + pub const STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT: NTSTATUS = NTSTATUS(-1_072_365_540_i32); + pub const STATUS_SXS_MANIFEST_PARSE_ERROR: NTSTATUS = NTSTATUS(-1_072_365_562_i32); + pub const STATUS_SXS_MANIFEST_TOO_BIG: NTSTATUS = NTSTATUS(-1_072_365_534_i32); + pub const STATUS_SXS_MULTIPLE_DEACTIVATION: NTSTATUS = NTSTATUS(-1_072_365_551_i32); + pub const STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET: NTSTATUS = NTSTATUS(-1_072_365_554_i32); + pub const STATUS_SXS_PROCESS_TERMINATION_REQUESTED: NTSTATUS = NTSTATUS(-1_072_365_549_i32); + pub const STATUS_SXS_RELEASE_ACTIVATION_CONTEXT: NTSTATUS = NTSTATUS(1_075_118_093_i32); + pub const STATUS_SXS_SECTION_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_365_567_i32); + pub const STATUS_SXS_SETTING_NOT_REGISTERED: NTSTATUS = NTSTATUS(-1_072_365_533_i32); + pub const STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY: NTSTATUS = NTSTATUS(-1_072_365_550_i32); + pub const STATUS_SXS_THREAD_QUERIES_DISABLED: NTSTATUS = NTSTATUS(-1_072_365_557_i32); + pub const STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE: NTSTATUS = NTSTATUS(-1_072_365_532_i32); + pub const STATUS_SXS_VERSION_CONFLICT: NTSTATUS = NTSTATUS(-1_072_365_559_i32); + pub const STATUS_SXS_WRONG_SECTION_TYPE: NTSTATUS = NTSTATUS(-1_072_365_558_i32); + pub const STATUS_SYMLINK_CLASS_DISABLED: NTSTATUS = NTSTATUS(-1_073_740_011_i32); + pub const STATUS_SYNCHRONIZATION_REQUIRED: NTSTATUS = NTSTATUS(-1_073_741_516_i32); + pub const STATUS_SYSTEM_DEVICE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_740_718_i32); + pub const STATUS_SYSTEM_HIVE_TOO_LARGE: NTSTATUS = NTSTATUS(-1_073_740_946_i32); + pub const STATUS_SYSTEM_IMAGE_BAD_SIGNATURE: NTSTATUS = NTSTATUS(-1_073_741_103_i32); + pub const STATUS_SYSTEM_INTEGRITY_INVALID_POLICY: NTSTATUS = NTSTATUS(-1_058_471_933_i32); + pub const STATUS_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED: NTSTATUS = NTSTATUS(-1_058_471_932_i32); + pub const STATUS_SYSTEM_INTEGRITY_POLICY_VIOLATION: NTSTATUS = NTSTATUS(-1_058_471_934_i32); + pub const STATUS_SYSTEM_INTEGRITY_REPUTATION_DANGEROUS_EXT: NTSTATUS = NTSTATUS(-1_058_471_927_i32); + pub const STATUS_SYSTEM_INTEGRITY_REPUTATION_MALICIOUS: NTSTATUS = NTSTATUS(-1_058_471_929_i32); + pub const STATUS_SYSTEM_INTEGRITY_REPUTATION_OFFLINE: NTSTATUS = NTSTATUS(-1_058_471_926_i32); + pub const STATUS_SYSTEM_INTEGRITY_REPUTATION_PUA: NTSTATUS = NTSTATUS(-1_058_471_928_i32); + pub const STATUS_SYSTEM_INTEGRITY_REPUTATION_UNATTAINABLE: NTSTATUS = NTSTATUS(-1_058_471_924_i32); + pub const STATUS_SYSTEM_INTEGRITY_REPUTATION_UNFRIENDLY_FILE: NTSTATUS = NTSTATUS(-1_058_471_925_i32); + pub const STATUS_SYSTEM_INTEGRITY_ROLLBACK_DETECTED: NTSTATUS = NTSTATUS(-1_058_471_935_i32); + pub const STATUS_SYSTEM_INTEGRITY_SUPPLEMENTAL_POLICY_NOT_AUTHORIZED: NTSTATUS = NTSTATUS(-1_058_471_930_i32); + pub const STATUS_SYSTEM_INTEGRITY_TOO_MANY_POLICIES: NTSTATUS = NTSTATUS(-1_058_471_931_i32); + pub const STATUS_SYSTEM_NEEDS_REMEDIATION: NTSTATUS = NTSTATUS(-1_073_740_674_i32); + pub const STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION: NTSTATUS = NTSTATUS(1_073_741_873_i32); + pub const STATUS_SYSTEM_POWERSTATE_TRANSITION: NTSTATUS = NTSTATUS(1_073_741_871_i32); + pub const STATUS_SYSTEM_PROCESS_TERMINATED: NTSTATUS = NTSTATUS(-1_073_741_286_i32); + pub const STATUS_SYSTEM_SHUTDOWN: NTSTATUS = NTSTATUS(-1_073_741_077_i32); + pub const STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED: NTSTATUS = NTSTATUS(-1_073_740_018_i32); + pub const STATUS_THREADPOOL_HANDLE_EXCEPTION: NTSTATUS = NTSTATUS(-1_073_740_022_i32); + pub const STATUS_THREADPOOL_RELEASED_DURING_OPERATION: NTSTATUS = NTSTATUS(-1_073_740_017_i32); + pub const STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED: NTSTATUS = NTSTATUS(-1_073_740_019_i32); + pub const STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED: NTSTATUS = NTSTATUS(-1_073_740_020_i32); + pub const STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED: NTSTATUS = NTSTATUS(-1_073_740_021_i32); + pub const STATUS_THREAD_ALREADY_IN_SESSION: NTSTATUS = NTSTATUS(-1_073_740_714_i32); + pub const STATUS_THREAD_ALREADY_IN_TASK: NTSTATUS = NTSTATUS(-1_073_740_542_i32); + pub const STATUS_THREAD_IS_TERMINATING: NTSTATUS = NTSTATUS(-1_073_741_749_i32); + pub const STATUS_THREAD_NOT_IN_PROCESS: NTSTATUS = NTSTATUS(-1_073_741_526_i32); + pub const STATUS_THREAD_NOT_IN_SESSION: NTSTATUS = NTSTATUS(-1_073_740_713_i32); + pub const STATUS_THREAD_NOT_RUNNING: NTSTATUS = NTSTATUS(-1_073_740_522_i32); + pub const STATUS_THREAD_WAS_SUSPENDED: NTSTATUS = NTSTATUS(1_073_741_825_i32); + pub const STATUS_TIMEOUT: NTSTATUS = NTSTATUS(258i32); + pub const STATUS_TIMER_NOT_CANCELED: NTSTATUS = NTSTATUS(-1_073_741_812_i32); + pub const STATUS_TIMER_RESOLUTION_NOT_SET: NTSTATUS = NTSTATUS(-1_073_741_243_i32); + pub const STATUS_TIMER_RESUME_IGNORED: NTSTATUS = NTSTATUS(1_073_741_861_i32); + pub const STATUS_TIME_DIFFERENCE_AT_DC: NTSTATUS = NTSTATUS(-1_073_741_517_i32); + pub const STATUS_TM_IDENTITY_MISMATCH: NTSTATUS = NTSTATUS(-1_072_103_350_i32); + pub const STATUS_TM_INITIALIZATION_FAILED: NTSTATUS = NTSTATUS(-1_072_103_420_i32); + pub const STATUS_TM_VOLATILE: NTSTATUS = NTSTATUS(-1_072_103_365_i32); + pub const STATUS_TOKEN_ALREADY_IN_USE: NTSTATUS = NTSTATUS(-1_073_741_525_i32); + pub const STATUS_TOO_LATE: NTSTATUS = NTSTATUS(-1_073_741_431_i32); + pub const STATUS_TOO_MANY_ADDRESSES: NTSTATUS = NTSTATUS(-1_073_741_303_i32); + pub const STATUS_TOO_MANY_COMMANDS: NTSTATUS = NTSTATUS(-1_073_741_631_i32); + pub const STATUS_TOO_MANY_CONTEXT_IDS: NTSTATUS = NTSTATUS(-1_073_741_478_i32); + pub const STATUS_TOO_MANY_GUIDS_REQUESTED: NTSTATUS = NTSTATUS(-1_073_741_694_i32); + pub const STATUS_TOO_MANY_LINKS: NTSTATUS = NTSTATUS(-1_073_741_211_i32); + pub const STATUS_TOO_MANY_LUIDS_REQUESTED: NTSTATUS = NTSTATUS(-1_073_741_708_i32); + pub const STATUS_TOO_MANY_NAMES: NTSTATUS = NTSTATUS(-1_073_741_619_i32); + pub const STATUS_TOO_MANY_NODES: NTSTATUS = NTSTATUS(-1_073_741_298_i32); + pub const STATUS_TOO_MANY_OPENED_FILES: NTSTATUS = NTSTATUS(-1_073_741_537_i32); + pub const STATUS_TOO_MANY_PAGING_FILES: NTSTATUS = NTSTATUS(-1_073_741_673_i32); + pub const STATUS_TOO_MANY_PRINCIPALS: NTSTATUS = NTSTATUS(-1_073_741_065_i32); + pub const STATUS_TOO_MANY_SECRETS: NTSTATUS = NTSTATUS(-1_073_741_482_i32); + pub const STATUS_TOO_MANY_SEGMENT_DESCRIPTORS: NTSTATUS = NTSTATUS(-1_073_740_685_i32); + pub const STATUS_TOO_MANY_SESSIONS: NTSTATUS = NTSTATUS(-1_073_741_618_i32); + pub const STATUS_TOO_MANY_SIDS: NTSTATUS = NTSTATUS(-1_073_741_442_i32); + pub const STATUS_TOO_MANY_THREADS: NTSTATUS = NTSTATUS(-1_073_741_527_i32); + pub const STATUS_TPM_20_E_ASYMMETRIC: NTSTATUS = NTSTATUS(-1_071_054_719_i32); + pub const STATUS_TPM_20_E_ATTRIBUTES: NTSTATUS = NTSTATUS(-1_071_054_718_i32); + pub const STATUS_TPM_20_E_AUTHSIZE: NTSTATUS = NTSTATUS(-1_071_054_524_i32); + pub const STATUS_TPM_20_E_AUTH_CONTEXT: NTSTATUS = NTSTATUS(-1_071_054_523_i32); + pub const STATUS_TPM_20_E_AUTH_FAIL: NTSTATUS = NTSTATUS(-1_071_054_706_i32); + pub const STATUS_TPM_20_E_AUTH_MISSING: NTSTATUS = NTSTATUS(-1_071_054_555_i32); + pub const STATUS_TPM_20_E_AUTH_TYPE: NTSTATUS = NTSTATUS(-1_071_054_556_i32); + pub const STATUS_TPM_20_E_AUTH_UNAVAILABLE: NTSTATUS = NTSTATUS(-1_071_054_545_i32); + pub const STATUS_TPM_20_E_BAD_AUTH: NTSTATUS = NTSTATUS(-1_071_054_686_i32); + pub const STATUS_TPM_20_E_BAD_CONTEXT: NTSTATUS = NTSTATUS(-1_071_054_512_i32); + pub const STATUS_TPM_20_E_BINDING: NTSTATUS = NTSTATUS(-1_071_054_683_i32); + pub const STATUS_TPM_20_E_COMMAND_CODE: NTSTATUS = NTSTATUS(-1_071_054_525_i32); + pub const STATUS_TPM_20_E_COMMAND_SIZE: NTSTATUS = NTSTATUS(-1_071_054_526_i32); + pub const STATUS_TPM_20_E_CPHASH: NTSTATUS = NTSTATUS(-1_071_054_511_i32); + pub const STATUS_TPM_20_E_CURVE: NTSTATUS = NTSTATUS(-1_071_054_682_i32); + pub const STATUS_TPM_20_E_DISABLED: NTSTATUS = NTSTATUS(-1_071_054_560_i32); + pub const STATUS_TPM_20_E_ECC_CURVE: NTSTATUS = NTSTATUS(-1_071_054_557_i32); + pub const STATUS_TPM_20_E_ECC_POINT: NTSTATUS = NTSTATUS(-1_071_054_681_i32); + pub const STATUS_TPM_20_E_EXCLUSIVE: NTSTATUS = NTSTATUS(-1_071_054_559_i32); + pub const STATUS_TPM_20_E_EXPIRED: NTSTATUS = NTSTATUS(-1_071_054_685_i32); + pub const STATUS_TPM_20_E_FAILURE: NTSTATUS = NTSTATUS(-1_071_054_591_i32); + pub const STATUS_TPM_20_E_HANDLE: NTSTATUS = NTSTATUS(-1_071_054_709_i32); + pub const STATUS_TPM_20_E_HASH: NTSTATUS = NTSTATUS(-1_071_054_717_i32); + pub const STATUS_TPM_20_E_HIERARCHY: NTSTATUS = NTSTATUS(-1_071_054_715_i32); + pub const STATUS_TPM_20_E_HMAC: NTSTATUS = NTSTATUS(-1_071_054_567_i32); + pub const STATUS_TPM_20_E_INITIALIZE: NTSTATUS = NTSTATUS(-1_071_054_592_i32); + pub const STATUS_TPM_20_E_INSUFFICIENT: NTSTATUS = NTSTATUS(-1_071_054_694_i32); + pub const STATUS_TPM_20_E_INTEGRITY: NTSTATUS = NTSTATUS(-1_071_054_689_i32); + pub const STATUS_TPM_20_E_KDF: NTSTATUS = NTSTATUS(-1_071_054_708_i32); + pub const STATUS_TPM_20_E_KEY: NTSTATUS = NTSTATUS(-1_071_054_692_i32); + pub const STATUS_TPM_20_E_KEY_SIZE: NTSTATUS = NTSTATUS(-1_071_054_713_i32); + pub const STATUS_TPM_20_E_MGF: NTSTATUS = NTSTATUS(-1_071_054_712_i32); + pub const STATUS_TPM_20_E_MODE: NTSTATUS = NTSTATUS(-1_071_054_711_i32); + pub const STATUS_TPM_20_E_NEEDS_TEST: NTSTATUS = NTSTATUS(-1_071_054_509_i32); + pub const STATUS_TPM_20_E_NONCE: NTSTATUS = NTSTATUS(-1_071_054_705_i32); + pub const STATUS_TPM_20_E_NO_RESULT: NTSTATUS = NTSTATUS(-1_071_054_508_i32); + pub const STATUS_TPM_20_E_NV_AUTHORIZATION: NTSTATUS = NTSTATUS(-1_071_054_519_i32); + pub const STATUS_TPM_20_E_NV_DEFINED: NTSTATUS = NTSTATUS(-1_071_054_516_i32); + pub const STATUS_TPM_20_E_NV_LOCKED: NTSTATUS = NTSTATUS(-1_071_054_520_i32); + pub const STATUS_TPM_20_E_NV_RANGE: NTSTATUS = NTSTATUS(-1_071_054_522_i32); + pub const STATUS_TPM_20_E_NV_SIZE: NTSTATUS = NTSTATUS(-1_071_054_521_i32); + pub const STATUS_TPM_20_E_NV_SPACE: NTSTATUS = NTSTATUS(-1_071_054_517_i32); + pub const STATUS_TPM_20_E_NV_UNINITIALIZED: NTSTATUS = NTSTATUS(-1_071_054_518_i32); + pub const STATUS_TPM_20_E_PARENT: NTSTATUS = NTSTATUS(-1_071_054_510_i32); + pub const STATUS_TPM_20_E_PCR: NTSTATUS = NTSTATUS(-1_071_054_553_i32); + pub const STATUS_TPM_20_E_PCR_CHANGED: NTSTATUS = NTSTATUS(-1_071_054_552_i32); + pub const STATUS_TPM_20_E_POLICY: NTSTATUS = NTSTATUS(-1_071_054_554_i32); + pub const STATUS_TPM_20_E_POLICY_CC: NTSTATUS = NTSTATUS(-1_071_054_684_i32); + pub const STATUS_TPM_20_E_POLICY_FAIL: NTSTATUS = NTSTATUS(-1_071_054_691_i32); + pub const STATUS_TPM_20_E_PP: NTSTATUS = NTSTATUS(-1_071_054_704_i32); + pub const STATUS_TPM_20_E_PRIVATE: NTSTATUS = NTSTATUS(-1_071_054_581_i32); + pub const STATUS_TPM_20_E_RANGE: NTSTATUS = NTSTATUS(-1_071_054_707_i32); + pub const STATUS_TPM_20_E_REBOOT: NTSTATUS = NTSTATUS(-1_071_054_544_i32); + pub const STATUS_TPM_20_E_RESERVED_BITS: NTSTATUS = NTSTATUS(-1_071_054_687_i32); + pub const STATUS_TPM_20_E_SCHEME: NTSTATUS = NTSTATUS(-1_071_054_702_i32); + pub const STATUS_TPM_20_E_SELECTOR: NTSTATUS = NTSTATUS(-1_071_054_696_i32); + pub const STATUS_TPM_20_E_SENSITIVE: NTSTATUS = NTSTATUS(-1_071_054_507_i32); + pub const STATUS_TPM_20_E_SEQUENCE: NTSTATUS = NTSTATUS(-1_071_054_589_i32); + pub const STATUS_TPM_20_E_SIGNATURE: NTSTATUS = NTSTATUS(-1_071_054_693_i32); + pub const STATUS_TPM_20_E_SIZE: NTSTATUS = NTSTATUS(-1_071_054_699_i32); + pub const STATUS_TPM_20_E_SYMMETRIC: NTSTATUS = NTSTATUS(-1_071_054_698_i32); + pub const STATUS_TPM_20_E_TAG: NTSTATUS = NTSTATUS(-1_071_054_697_i32); + pub const STATUS_TPM_20_E_TICKET: NTSTATUS = NTSTATUS(-1_071_054_688_i32); + pub const STATUS_TPM_20_E_TOO_MANY_CONTEXTS: NTSTATUS = NTSTATUS(-1_071_054_546_i32); + pub const STATUS_TPM_20_E_TYPE: NTSTATUS = NTSTATUS(-1_071_054_710_i32); + pub const STATUS_TPM_20_E_UNBALANCED: NTSTATUS = NTSTATUS(-1_071_054_543_i32); + pub const STATUS_TPM_20_E_UPGRADE: NTSTATUS = NTSTATUS(-1_071_054_547_i32); + pub const STATUS_TPM_20_E_VALUE: NTSTATUS = NTSTATUS(-1_071_054_716_i32); + pub const STATUS_TPM_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_071_050_748_i32); + pub const STATUS_TPM_AREA_LOCKED: NTSTATUS = NTSTATUS(-1_071_054_788_i32); + pub const STATUS_TPM_AUDITFAILURE: NTSTATUS = NTSTATUS(-1_071_054_844_i32); + pub const STATUS_TPM_AUDITFAIL_SUCCESSFUL: NTSTATUS = NTSTATUS(-1_071_054_799_i32); + pub const STATUS_TPM_AUDITFAIL_UNSUCCESSFUL: NTSTATUS = NTSTATUS(-1_071_054_800_i32); + pub const STATUS_TPM_AUTH2FAIL: NTSTATUS = NTSTATUS(-1_071_054_819_i32); + pub const STATUS_TPM_AUTHFAIL: NTSTATUS = NTSTATUS(-1_071_054_847_i32); + pub const STATUS_TPM_AUTH_CONFLICT: NTSTATUS = NTSTATUS(-1_071_054_789_i32); + pub const STATUS_TPM_BADCONTEXT: NTSTATUS = NTSTATUS(-1_071_054_758_i32); + pub const STATUS_TPM_BADINDEX: NTSTATUS = NTSTATUS(-1_071_054_846_i32); + pub const STATUS_TPM_BADTAG: NTSTATUS = NTSTATUS(-1_071_054_818_i32); + pub const STATUS_TPM_BAD_ATTRIBUTES: NTSTATUS = NTSTATUS(-1_071_054_782_i32); + pub const STATUS_TPM_BAD_COUNTER: NTSTATUS = NTSTATUS(-1_071_054_779_i32); + pub const STATUS_TPM_BAD_DATASIZE: NTSTATUS = NTSTATUS(-1_071_054_805_i32); + pub const STATUS_TPM_BAD_DELEGATE: NTSTATUS = NTSTATUS(-1_071_054_759_i32); + pub const STATUS_TPM_BAD_HANDLE: NTSTATUS = NTSTATUS(-1_071_054_760_i32); + pub const STATUS_TPM_BAD_KEY_PROPERTY: NTSTATUS = NTSTATUS(-1_071_054_808_i32); + pub const STATUS_TPM_BAD_LOCALITY: NTSTATUS = NTSTATUS(-1_071_054_787_i32); + pub const STATUS_TPM_BAD_MIGRATION: NTSTATUS = NTSTATUS(-1_071_054_807_i32); + pub const STATUS_TPM_BAD_MODE: NTSTATUS = NTSTATUS(-1_071_054_804_i32); + pub const STATUS_TPM_BAD_ORDINAL: NTSTATUS = NTSTATUS(-1_071_054_838_i32); + pub const STATUS_TPM_BAD_PARAMETER: NTSTATUS = NTSTATUS(-1_071_054_845_i32); + pub const STATUS_TPM_BAD_PARAM_SIZE: NTSTATUS = NTSTATUS(-1_071_054_823_i32); + pub const STATUS_TPM_BAD_PRESENCE: NTSTATUS = NTSTATUS(-1_071_054_803_i32); + pub const STATUS_TPM_BAD_SCHEME: NTSTATUS = NTSTATUS(-1_071_054_806_i32); + pub const STATUS_TPM_BAD_SIGNATURE: NTSTATUS = NTSTATUS(-1_071_054_750_i32); + pub const STATUS_TPM_BAD_TYPE: NTSTATUS = NTSTATUS(-1_071_054_796_i32); + pub const STATUS_TPM_BAD_VERSION: NTSTATUS = NTSTATUS(-1_071_054_802_i32); + pub const STATUS_TPM_CLEAR_DISABLED: NTSTATUS = NTSTATUS(-1_071_054_843_i32); + pub const STATUS_TPM_COMMAND_BLOCKED: NTSTATUS = NTSTATUS(-1_071_053_824_i32); + pub const STATUS_TPM_COMMAND_CANCELED: NTSTATUS = NTSTATUS(-1_071_050_751_i32); + pub const STATUS_TPM_CONTEXT_GAP: NTSTATUS = NTSTATUS(-1_071_054_777_i32); + pub const STATUS_TPM_DAA_INPUT_DATA0: NTSTATUS = NTSTATUS(-1_071_054_767_i32); + pub const STATUS_TPM_DAA_INPUT_DATA1: NTSTATUS = NTSTATUS(-1_071_054_766_i32); + pub const STATUS_TPM_DAA_ISSUER_SETTINGS: NTSTATUS = NTSTATUS(-1_071_054_765_i32); + pub const STATUS_TPM_DAA_ISSUER_VALIDITY: NTSTATUS = NTSTATUS(-1_071_054_762_i32); + pub const STATUS_TPM_DAA_RESOURCES: NTSTATUS = NTSTATUS(-1_071_054_768_i32); + pub const STATUS_TPM_DAA_STAGE: NTSTATUS = NTSTATUS(-1_071_054_763_i32); + pub const STATUS_TPM_DAA_TPM_SETTINGS: NTSTATUS = NTSTATUS(-1_071_054_764_i32); + pub const STATUS_TPM_DAA_WRONG_W: NTSTATUS = NTSTATUS(-1_071_054_761_i32); + pub const STATUS_TPM_DEACTIVATED: NTSTATUS = NTSTATUS(-1_071_054_842_i32); + pub const STATUS_TPM_DECRYPT_ERROR: NTSTATUS = NTSTATUS(-1_071_054_815_i32); + pub const STATUS_TPM_DEFEND_LOCK_RUNNING: NTSTATUS = NTSTATUS(-1_071_052_797_i32); + pub const STATUS_TPM_DELEGATE_ADMIN: NTSTATUS = NTSTATUS(-1_071_054_771_i32); + pub const STATUS_TPM_DELEGATE_FAMILY: NTSTATUS = NTSTATUS(-1_071_054_772_i32); + pub const STATUS_TPM_DELEGATE_LOCK: NTSTATUS = NTSTATUS(-1_071_054_773_i32); + pub const STATUS_TPM_DISABLED: NTSTATUS = NTSTATUS(-1_071_054_841_i32); + pub const STATUS_TPM_DISABLED_CMD: NTSTATUS = NTSTATUS(-1_071_054_840_i32); + pub const STATUS_TPM_DOING_SELFTEST: NTSTATUS = NTSTATUS(-1_071_052_798_i32); + pub const STATUS_TPM_DUPLICATE_VHANDLE: NTSTATUS = NTSTATUS(-1_071_053_822_i32); + pub const STATUS_TPM_EMBEDDED_COMMAND_BLOCKED: NTSTATUS = NTSTATUS(-1_071_053_821_i32); + pub const STATUS_TPM_EMBEDDED_COMMAND_UNSUPPORTED: NTSTATUS = NTSTATUS(-1_071_053_820_i32); + pub const STATUS_TPM_ENCRYPT_ERROR: NTSTATUS = NTSTATUS(-1_071_054_816_i32); + pub const STATUS_TPM_ERROR_MASK: NTSTATUS = NTSTATUS(-1_071_054_848_i32); + pub const STATUS_TPM_FAIL: NTSTATUS = NTSTATUS(-1_071_054_839_i32); + pub const STATUS_TPM_FAILEDSELFTEST: NTSTATUS = NTSTATUS(-1_071_054_820_i32); + pub const STATUS_TPM_FAMILYCOUNT: NTSTATUS = NTSTATUS(-1_071_054_784_i32); + pub const STATUS_TPM_INAPPROPRIATE_ENC: NTSTATUS = NTSTATUS(-1_071_054_834_i32); + pub const STATUS_TPM_INAPPROPRIATE_SIG: NTSTATUS = NTSTATUS(-1_071_054_809_i32); + pub const STATUS_TPM_INSTALL_DISABLED: NTSTATUS = NTSTATUS(-1_071_054_837_i32); + pub const STATUS_TPM_INSUFFICIENT_BUFFER: NTSTATUS = NTSTATUS(-1_071_050_747_i32); + pub const STATUS_TPM_INVALID_AUTHHANDLE: NTSTATUS = NTSTATUS(-1_071_054_814_i32); + pub const STATUS_TPM_INVALID_FAMILY: NTSTATUS = NTSTATUS(-1_071_054_793_i32); + pub const STATUS_TPM_INVALID_HANDLE: NTSTATUS = NTSTATUS(-1_071_053_823_i32); + pub const STATUS_TPM_INVALID_KEYHANDLE: NTSTATUS = NTSTATUS(-1_071_054_836_i32); + pub const STATUS_TPM_INVALID_KEYUSAGE: NTSTATUS = NTSTATUS(-1_071_054_812_i32); + pub const STATUS_TPM_INVALID_PCR_INFO: NTSTATUS = NTSTATUS(-1_071_054_832_i32); + pub const STATUS_TPM_INVALID_POSTINIT: NTSTATUS = NTSTATUS(-1_071_054_810_i32); + pub const STATUS_TPM_INVALID_RESOURCE: NTSTATUS = NTSTATUS(-1_071_054_795_i32); + pub const STATUS_TPM_INVALID_STRUCTURE: NTSTATUS = NTSTATUS(-1_071_054_781_i32); + pub const STATUS_TPM_IOERROR: NTSTATUS = NTSTATUS(-1_071_054_817_i32); + pub const STATUS_TPM_KEYNOTFOUND: NTSTATUS = NTSTATUS(-1_071_054_835_i32); + pub const STATUS_TPM_KEY_NOTSUPPORTED: NTSTATUS = NTSTATUS(-1_071_054_790_i32); + pub const STATUS_TPM_KEY_OWNER_CONTROL: NTSTATUS = NTSTATUS(-1_071_054_780_i32); + pub const STATUS_TPM_MAXNVWRITES: NTSTATUS = NTSTATUS(-1_071_054_776_i32); + pub const STATUS_TPM_MA_AUTHORITY: NTSTATUS = NTSTATUS(-1_071_054_753_i32); + pub const STATUS_TPM_MA_DESTINATION: NTSTATUS = NTSTATUS(-1_071_054_755_i32); + pub const STATUS_TPM_MA_SOURCE: NTSTATUS = NTSTATUS(-1_071_054_754_i32); + pub const STATUS_TPM_MA_TICKET_SIGNATURE: NTSTATUS = NTSTATUS(-1_071_054_756_i32); + pub const STATUS_TPM_MIGRATEFAIL: NTSTATUS = NTSTATUS(-1_071_054_833_i32); + pub const STATUS_TPM_NEEDS_SELFTEST: NTSTATUS = NTSTATUS(-1_071_052_799_i32); + pub const STATUS_TPM_NOCONTEXTSPACE: NTSTATUS = NTSTATUS(-1_071_054_749_i32); + pub const STATUS_TPM_NOOPERATOR: NTSTATUS = NTSTATUS(-1_071_054_775_i32); + pub const STATUS_TPM_NOSPACE: NTSTATUS = NTSTATUS(-1_071_054_831_i32); + pub const STATUS_TPM_NOSRK: NTSTATUS = NTSTATUS(-1_071_054_830_i32); + pub const STATUS_TPM_NOTFIPS: NTSTATUS = NTSTATUS(-1_071_054_794_i32); + pub const STATUS_TPM_NOTLOCAL: NTSTATUS = NTSTATUS(-1_071_054_797_i32); + pub const STATUS_TPM_NOTRESETABLE: NTSTATUS = NTSTATUS(-1_071_054_798_i32); + pub const STATUS_TPM_NOTSEALED_BLOB: NTSTATUS = NTSTATUS(-1_071_054_829_i32); + pub const STATUS_TPM_NOT_FOUND: NTSTATUS = NTSTATUS(-1_071_050_749_i32); + pub const STATUS_TPM_NOT_FULLWRITE: NTSTATUS = NTSTATUS(-1_071_054_778_i32); + pub const STATUS_TPM_NO_ENDORSEMENT: NTSTATUS = NTSTATUS(-1_071_054_813_i32); + pub const STATUS_TPM_NO_NV_PERMISSION: NTSTATUS = NTSTATUS(-1_071_054_792_i32); + pub const STATUS_TPM_NO_WRAP_TRANSPORT: NTSTATUS = NTSTATUS(-1_071_054_801_i32); + pub const STATUS_TPM_OWNER_CONTROL: NTSTATUS = NTSTATUS(-1_071_054_769_i32); + pub const STATUS_TPM_OWNER_SET: NTSTATUS = NTSTATUS(-1_071_054_828_i32); + pub const STATUS_TPM_PERMANENTEK: NTSTATUS = NTSTATUS(-1_071_054_751_i32); + pub const STATUS_TPM_PER_NOWRITE: NTSTATUS = NTSTATUS(-1_071_054_785_i32); + pub const STATUS_TPM_PPI_FUNCTION_UNSUPPORTED: NTSTATUS = NTSTATUS(-1_071_050_746_i32); + pub const STATUS_TPM_READ_ONLY: NTSTATUS = NTSTATUS(-1_071_054_786_i32); + pub const STATUS_TPM_REQUIRES_SIGN: NTSTATUS = NTSTATUS(-1_071_054_791_i32); + pub const STATUS_TPM_RESOURCEMISSING: NTSTATUS = NTSTATUS(-1_071_054_774_i32); + pub const STATUS_TPM_RESOURCES: NTSTATUS = NTSTATUS(-1_071_054_827_i32); + pub const STATUS_TPM_RETRY: NTSTATUS = NTSTATUS(-1_071_052_800_i32); + pub const STATUS_TPM_SHA_ERROR: NTSTATUS = NTSTATUS(-1_071_054_821_i32); + pub const STATUS_TPM_SHA_THREAD: NTSTATUS = NTSTATUS(-1_071_054_822_i32); + pub const STATUS_TPM_SHORTRANDOM: NTSTATUS = NTSTATUS(-1_071_054_826_i32); + pub const STATUS_TPM_SIZE: NTSTATUS = NTSTATUS(-1_071_054_825_i32); + pub const STATUS_TPM_TOOMANYCONTEXTS: NTSTATUS = NTSTATUS(-1_071_054_757_i32); + pub const STATUS_TPM_TOO_MANY_CONTEXTS: NTSTATUS = NTSTATUS(-1_071_050_750_i32); + pub const STATUS_TPM_TRANSPORT_NOTEXCLUSIVE: NTSTATUS = NTSTATUS(-1_071_054_770_i32); + pub const STATUS_TPM_WRITE_LOCKED: NTSTATUS = NTSTATUS(-1_071_054_783_i32); + pub const STATUS_TPM_WRONGPCRVAL: NTSTATUS = NTSTATUS(-1_071_054_824_i32); + pub const STATUS_TPM_WRONG_ENTITYTYPE: NTSTATUS = NTSTATUS(-1_071_054_811_i32); + pub const STATUS_TPM_ZERO_EXHAUST_ENABLED: NTSTATUS = NTSTATUS(-1_071_038_464_i32); + pub const STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE: NTSTATUS = NTSTATUS(-1_072_103_360_i32); + pub const STATUS_TRANSACTIONAL_CONFLICT: NTSTATUS = NTSTATUS(-1_072_103_423_i32); + pub const STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED: NTSTATUS = NTSTATUS(-1_072_103_361_i32); + pub const STATUS_TRANSACTIONMANAGER_IDENTITY_MISMATCH: NTSTATUS = NTSTATUS(-1_072_103_332_i32); + pub const STATUS_TRANSACTIONMANAGER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_103_343_i32); + pub const STATUS_TRANSACTIONMANAGER_NOT_ONLINE: NTSTATUS = NTSTATUS(-1_072_103_342_i32); + pub const STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION: NTSTATUS = NTSTATUS(-1_072_103_341_i32); + pub const STATUS_TRANSACTIONS_NOT_FROZEN: NTSTATUS = NTSTATUS(-1_072_103_355_i32); + pub const STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE: NTSTATUS = NTSTATUS(-1_072_103_414_i32); + pub const STATUS_TRANSACTION_ABORTED: NTSTATUS = NTSTATUS(-1_073_741_297_i32); + pub const STATUS_TRANSACTION_ALREADY_ABORTED: NTSTATUS = NTSTATUS(-1_072_103_403_i32); + pub const STATUS_TRANSACTION_ALREADY_COMMITTED: NTSTATUS = NTSTATUS(-1_072_103_402_i32); + pub const STATUS_TRANSACTION_FREEZE_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_072_103_354_i32); + pub const STATUS_TRANSACTION_INTEGRITY_VIOLATED: NTSTATUS = NTSTATUS(-1_072_103_333_i32); + pub const STATUS_TRANSACTION_INVALID_ID: NTSTATUS = NTSTATUS(-1_073_741_292_i32); + pub const STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER: NTSTATUS = NTSTATUS(-1_072_103_401_i32); + pub const STATUS_TRANSACTION_INVALID_TYPE: NTSTATUS = NTSTATUS(-1_073_741_291_i32); + pub const STATUS_TRANSACTION_MUST_WRITETHROUGH: NTSTATUS = NTSTATUS(-1_072_103_330_i32); + pub const STATUS_TRANSACTION_NOT_ACTIVE: NTSTATUS = NTSTATUS(-1_072_103_421_i32); + pub const STATUS_TRANSACTION_NOT_ENLISTED: NTSTATUS = NTSTATUS(-1_072_103_327_i32); + pub const STATUS_TRANSACTION_NOT_FOUND: NTSTATUS = NTSTATUS(-1_072_103_346_i32); + pub const STATUS_TRANSACTION_NOT_JOINED: NTSTATUS = NTSTATUS(-1_072_103_417_i32); + pub const STATUS_TRANSACTION_NOT_REQUESTED: NTSTATUS = NTSTATUS(-1_072_103_404_i32); + pub const STATUS_TRANSACTION_NOT_ROOT: NTSTATUS = NTSTATUS(-1_072_103_340_i32); + pub const STATUS_TRANSACTION_NO_MATCH: NTSTATUS = NTSTATUS(-1_073_741_294_i32); + pub const STATUS_TRANSACTION_NO_RELEASE: NTSTATUS = NTSTATUS(-1_073_741_295_i32); + pub const STATUS_TRANSACTION_NO_SUPERIOR: NTSTATUS = NTSTATUS(-1_072_103_329_i32); + pub const STATUS_TRANSACTION_OBJECT_EXPIRED: NTSTATUS = NTSTATUS(-1_072_103_339_i32); + pub const STATUS_TRANSACTION_PROPAGATION_FAILED: NTSTATUS = NTSTATUS(-1_072_103_408_i32); + pub const STATUS_TRANSACTION_RECORD_TOO_LONG: NTSTATUS = NTSTATUS(-1_072_103_336_i32); + pub const STATUS_TRANSACTION_REQUEST_NOT_VALID: NTSTATUS = NTSTATUS(-1_072_103_405_i32); + pub const STATUS_TRANSACTION_REQUIRED_PROMOTION: NTSTATUS = NTSTATUS(-1_072_103_357_i32); + pub const STATUS_TRANSACTION_RESPONDED: NTSTATUS = NTSTATUS(-1_073_741_293_i32); + pub const STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED: NTSTATUS = NTSTATUS(-1_072_103_337_i32); + pub const STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET: NTSTATUS = NTSTATUS(-2_145_845_182_i32); + pub const STATUS_TRANSACTION_SUPERIOR_EXISTS: NTSTATUS = NTSTATUS(-1_072_103_406_i32); + pub const STATUS_TRANSACTION_TIMED_OUT: NTSTATUS = NTSTATUS(-1_073_741_296_i32); + pub const STATUS_TRANSLATION_COMPLETE: NTSTATUS = NTSTATUS(288i32); + pub const STATUS_TRANSPORT_FULL: NTSTATUS = NTSTATUS(-1_073_741_110_i32); + pub const STATUS_TRIGGERED_EXECUTABLE_MEMORY_WRITE: NTSTATUS = NTSTATUS(-1_073_739_994_i32); + pub const STATUS_TRIM_READ_ZERO_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_686_i32); + pub const STATUS_TRUSTED_DOMAIN_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_428_i32); + pub const STATUS_TRUSTED_RELATIONSHIP_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_427_i32); + pub const STATUS_TRUST_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_424_i32); + pub const STATUS_TS_INCOMPATIBLE_SESSIONS: NTSTATUS = NTSTATUS(-1_073_086_407_i32); + pub const STATUS_TS_VIDEO_SUBSYSTEM_ERROR: NTSTATUS = NTSTATUS(-1_073_086_406_i32); + pub const STATUS_TXF_ATTRIBUTE_CORRUPT: NTSTATUS = NTSTATUS(-1_072_103_363_i32); + pub const STATUS_TXF_DIR_NOT_EMPTY: NTSTATUS = NTSTATUS(-1_072_103_367_i32); + pub const STATUS_TXF_METADATA_ALREADY_PRESENT: NTSTATUS = NTSTATUS(-2_145_845_183_i32); + pub const STATUS_UNABLE_TO_DECOMMIT_VM: NTSTATUS = NTSTATUS(-1_073_741_780_i32); + pub const STATUS_UNABLE_TO_DELETE_SECTION: NTSTATUS = NTSTATUS(-1_073_741_797_i32); + pub const STATUS_UNABLE_TO_FREE_VM: NTSTATUS = NTSTATUS(-1_073_741_798_i32); + pub const STATUS_UNABLE_TO_LOCK_MEDIA: NTSTATUS = NTSTATUS(-1_073_741_451_i32); + pub const STATUS_UNABLE_TO_UNLOAD_MEDIA: NTSTATUS = NTSTATUS(-1_073_741_450_i32); + pub const STATUS_UNDEFINED_CHARACTER: NTSTATUS = NTSTATUS(-1_073_741_469_i32); + pub const STATUS_UNDEFINED_SCOPE: NTSTATUS = NTSTATUS(-1_073_740_540_i32); + pub const STATUS_UNEXPECTED_IO_ERROR: NTSTATUS = NTSTATUS(-1_073_741_591_i32); + pub const STATUS_UNEXPECTED_MM_CREATE_ERR: NTSTATUS = NTSTATUS(-1_073_741_590_i32); + pub const STATUS_UNEXPECTED_MM_EXTEND_ERR: NTSTATUS = NTSTATUS(-1_073_741_588_i32); + pub const STATUS_UNEXPECTED_MM_MAP_ERROR: NTSTATUS = NTSTATUS(-1_073_741_589_i32); + pub const STATUS_UNEXPECTED_NETWORK_ERROR: NTSTATUS = NTSTATUS(-1_073_741_628_i32); + pub const STATUS_UNFINISHED_CONTEXT_DELETED: NTSTATUS = NTSTATUS(-1_073_741_074_i32); + pub const STATUS_UNHANDLED_EXCEPTION: NTSTATUS = NTSTATUS(-1_073_741_500_i32); + pub const STATUS_UNKNOWN_REVISION: NTSTATUS = NTSTATUS(-1_073_741_736_i32); + pub const STATUS_UNMAPPABLE_CHARACTER: NTSTATUS = NTSTATUS(-1_073_741_470_i32); + pub const STATUS_UNRECOGNIZED_MEDIA: NTSTATUS = NTSTATUS(-1_073_741_804_i32); + pub const STATUS_UNRECOGNIZED_VOLUME: NTSTATUS = NTSTATUS(-1_073_741_489_i32); + pub const STATUS_UNSATISFIED_DEPENDENCIES: NTSTATUS = NTSTATUS(-1_073_740_615_i32); + pub const STATUS_UNSUCCESSFUL: NTSTATUS = NTSTATUS(-1_073_741_823_i32); + pub const STATUS_UNSUPPORTED_COMPRESSION: NTSTATUS = NTSTATUS(-1_073_741_217_i32); + pub const STATUS_UNSUPPORTED_PAGING_MODE: NTSTATUS = NTSTATUS(-1_073_740_613_i32); + pub const STATUS_UNSUPPORTED_PREAUTH: NTSTATUS = NTSTATUS(-1_073_740_975_i32); + pub const STATUS_UNTRUSTED_MOUNT_POINT: NTSTATUS = NTSTATUS(-1_073_740_612_i32); + pub const STATUS_UNWIND: NTSTATUS = NTSTATUS(-1_073_741_785_i32); + pub const STATUS_UNWIND_CONSOLIDATE: NTSTATUS = NTSTATUS(-2_147_483_607_i32); + pub const STATUS_USER2USER_REQUIRED: NTSTATUS = NTSTATUS(-1_073_740_792_i32); + pub const STATUS_USER_APC: NTSTATUS = NTSTATUS(192i32); + pub const STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED: NTSTATUS = NTSTATUS(-1_073_740_797_i32); + pub const STATUS_USER_EXISTS: NTSTATUS = NTSTATUS(-1_073_741_725_i32); + pub const STATUS_USER_MAPPED_FILE: NTSTATUS = NTSTATUS(-1_073_741_245_i32); + pub const STATUS_USER_SESSION_DELETED: NTSTATUS = NTSTATUS(-1_073_741_309_i32); + pub const STATUS_VALIDATE_CONTINUE: NTSTATUS = NTSTATUS(-1_073_741_199_i32); + pub const STATUS_VALID_CATALOG_HASH: NTSTATUS = NTSTATUS(301i32); + pub const STATUS_VALID_IMAGE_HASH: NTSTATUS = NTSTATUS(300i32); + pub const STATUS_VALID_STRONG_CODE_HASH: NTSTATUS = NTSTATUS(302i32); + pub const STATUS_VARIABLE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_568_i32); + pub const STATUS_VDM_DISALLOWED: NTSTATUS = NTSTATUS(-1_073_740_780_i32); + pub const STATUS_VDM_HARD_ERROR: NTSTATUS = NTSTATUS(-1_073_741_283_i32); + pub const STATUS_VERIFIER_STOP: NTSTATUS = NTSTATUS(-1_073_740_767_i32); + pub const STATUS_VERIFY_REQUIRED: NTSTATUS = NTSTATUS(-2_147_483_626_i32); + pub const STATUS_VHDSET_BACKING_STORAGE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_067_647_220_i32); + pub const STATUS_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE: NTSTATUS = NTSTATUS(-1_069_940_685_i32); + pub const STATUS_VHD_BITMAP_MISMATCH: NTSTATUS = NTSTATUS(-1_069_940_724_i32); + pub const STATUS_VHD_BLOCK_ALLOCATION_FAILURE: NTSTATUS = NTSTATUS(-1_069_940_727_i32); + pub const STATUS_VHD_BLOCK_ALLOCATION_TABLE_CORRUPT: NTSTATUS = NTSTATUS(-1_069_940_726_i32); + pub const STATUS_VHD_CHANGE_TRACKING_DISABLED: NTSTATUS = NTSTATUS(-1_069_940_694_i32); + pub const STATUS_VHD_CHILD_PARENT_ID_MISMATCH: NTSTATUS = NTSTATUS(-1_069_940_722_i32); + pub const STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH: NTSTATUS = NTSTATUS(-1_069_940_713_i32); + pub const STATUS_VHD_CHILD_PARENT_TIMESTAMP_MISMATCH: NTSTATUS = NTSTATUS(-1_069_940_721_i32); + pub const STATUS_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE: NTSTATUS = NTSTATUS(-1_069_940_686_i32); + pub const STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED: NTSTATUS = NTSTATUS(-1_069_940_712_i32); + pub const STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT: NTSTATUS = NTSTATUS(-1_069_940_711_i32); + pub const STATUS_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCH: NTSTATUS = NTSTATUS(-1_069_940_734_i32); + pub const STATUS_VHD_DRIVE_FOOTER_CORRUPT: NTSTATUS = NTSTATUS(-1_069_940_733_i32); + pub const STATUS_VHD_DRIVE_FOOTER_MISSING: NTSTATUS = NTSTATUS(-1_069_940_735_i32); + pub const STATUS_VHD_FORMAT_UNKNOWN: NTSTATUS = NTSTATUS(-1_069_940_732_i32); + pub const STATUS_VHD_FORMAT_UNSUPPORTED_VERSION: NTSTATUS = NTSTATUS(-1_069_940_731_i32); + pub const STATUS_VHD_INVALID_BLOCK_SIZE: NTSTATUS = NTSTATUS(-1_069_940_725_i32); + pub const STATUS_VHD_INVALID_CHANGE_TRACKING_ID: NTSTATUS = NTSTATUS(-1_069_940_695_i32); + pub const STATUS_VHD_INVALID_FILE_SIZE: NTSTATUS = NTSTATUS(-1_069_940_717_i32); + pub const STATUS_VHD_INVALID_SIZE: NTSTATUS = NTSTATUS(-1_069_940_718_i32); + pub const STATUS_VHD_INVALID_STATE: NTSTATUS = NTSTATUS(-1_069_940_708_i32); + pub const STATUS_VHD_INVALID_TYPE: NTSTATUS = NTSTATUS(-1_069_940_709_i32); + pub const STATUS_VHD_METADATA_FULL: NTSTATUS = NTSTATUS(-1_069_940_696_i32); + pub const STATUS_VHD_METADATA_READ_FAILURE: NTSTATUS = NTSTATUS(-1_069_940_720_i32); + pub const STATUS_VHD_METADATA_WRITE_FAILURE: NTSTATUS = NTSTATUS(-1_069_940_719_i32); + pub const STATUS_VHD_MISSING_CHANGE_TRACKING_INFORMATION: NTSTATUS = NTSTATUS(-1_069_940_688_i32); + pub const STATUS_VHD_PARENT_VHD_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_069_940_714_i32); + pub const STATUS_VHD_PARENT_VHD_NOT_FOUND: NTSTATUS = NTSTATUS(-1_069_940_723_i32); + pub const STATUS_VHD_RESIZE_WOULD_TRUNCATE_DATA: NTSTATUS = NTSTATUS(-1_069_940_687_i32); + pub const STATUS_VHD_SHARED: NTSTATUS = NTSTATUS(-1_067_647_222_i32); + pub const STATUS_VHD_SPARSE_HEADER_CHECKSUM_MISMATCH: NTSTATUS = NTSTATUS(-1_069_940_730_i32); + pub const STATUS_VHD_SPARSE_HEADER_CORRUPT: NTSTATUS = NTSTATUS(-1_069_940_728_i32); + pub const STATUS_VHD_SPARSE_HEADER_UNSUPPORTED_VERSION: NTSTATUS = NTSTATUS(-1_069_940_729_i32); + pub const STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST: NTSTATUS = NTSTATUS(1_075_511_532_i32); + pub const STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD: NTSTATUS = NTSTATUS(-1_071_972_118_i32); + pub const STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED: NTSTATUS = NTSTATUS(-2_145_713_941_i32); + pub const STATUS_VID_CHILD_GPA_PAGE_SET_CORRUPTED: NTSTATUS = NTSTATUS(-1_070_137_330_i32); + pub const STATUS_VID_DUPLICATE_HANDLER: NTSTATUS = NTSTATUS(-1_070_137_343_i32); + pub const STATUS_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMIT: NTSTATUS = NTSTATUS(-1_070_137_314_i32); + pub const STATUS_VID_EXCEEDED_MBP_ENTRY_MAP_LIMIT: NTSTATUS = NTSTATUS(-1_070_137_332_i32); + pub const STATUS_VID_HANDLER_NOT_PRESENT: NTSTATUS = NTSTATUS(-1_070_137_340_i32); + pub const STATUS_VID_INSUFFICIENT_RESOURCES_HV_DEPOSIT: NTSTATUS = NTSTATUS(-1_070_137_299_i32); + pub const STATUS_VID_INSUFFICIENT_RESOURCES_PHYSICAL_BUFFER: NTSTATUS = NTSTATUS(-1_070_137_300_i32); + pub const STATUS_VID_INSUFFICIENT_RESOURCES_RESERVE: NTSTATUS = NTSTATUS(-1_070_137_301_i32); + pub const STATUS_VID_INSUFFICIENT_RESOURCES_WITHDRAW: NTSTATUS = NTSTATUS(-1_070_137_297_i32); + pub const STATUS_VID_INVALID_CHILD_GPA_PAGE_SET: NTSTATUS = NTSTATUS(-1_070_137_310_i32); + pub const STATUS_VID_INVALID_GPA_RANGE_HANDLE: NTSTATUS = NTSTATUS(-1_070_137_323_i32); + pub const STATUS_VID_INVALID_MEMORY_BLOCK_HANDLE: NTSTATUS = NTSTATUS(-1_070_137_326_i32); + pub const STATUS_VID_INVALID_MESSAGE_QUEUE_HANDLE: NTSTATUS = NTSTATUS(-1_070_137_324_i32); + pub const STATUS_VID_INVALID_NUMA_NODE_INDEX: NTSTATUS = NTSTATUS(-1_070_137_328_i32); + pub const STATUS_VID_INVALID_NUMA_SETTINGS: NTSTATUS = NTSTATUS(-1_070_137_329_i32); + pub const STATUS_VID_INVALID_OBJECT_NAME: NTSTATUS = NTSTATUS(-1_070_137_339_i32); + pub const STATUS_VID_INVALID_PPM_HANDLE: NTSTATUS = NTSTATUS(-1_070_137_320_i32); + pub const STATUS_VID_INVALID_PROCESSOR_STATE: NTSTATUS = NTSTATUS(-1_070_137_315_i32); + pub const STATUS_VID_KM_INTERFACE_ALREADY_INITIALIZED: NTSTATUS = NTSTATUS(-1_070_137_313_i32); + pub const STATUS_VID_MBPS_ARE_LOCKED: NTSTATUS = NTSTATUS(-1_070_137_319_i32); + pub const STATUS_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGE: NTSTATUS = NTSTATUS(-1_070_137_307_i32); + pub const STATUS_VID_MBP_COUNT_EXCEEDED_LIMIT: NTSTATUS = NTSTATUS(-1_070_137_306_i32); + pub const STATUS_VID_MB_PROPERTY_ALREADY_SET_RESET: NTSTATUS = NTSTATUS(-1_070_137_312_i32); + pub const STATUS_VID_MB_STILL_REFERENCED: NTSTATUS = NTSTATUS(-1_070_137_331_i32); + pub const STATUS_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDED: NTSTATUS = NTSTATUS(-1_070_137_321_i32); + pub const STATUS_VID_MEMORY_TYPE_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_070_137_298_i32); + pub const STATUS_VID_MESSAGE_QUEUE_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1_070_137_333_i32); + pub const STATUS_VID_MESSAGE_QUEUE_CLOSED: NTSTATUS = NTSTATUS(-1_070_137_318_i32); + pub const STATUS_VID_MESSAGE_QUEUE_NAME_TOO_LONG: NTSTATUS = NTSTATUS(-1_070_137_337_i32); + pub const STATUS_VID_MMIO_RANGE_DESTROYED: NTSTATUS = NTSTATUS(-1_070_137_311_i32); + pub const STATUS_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATED: NTSTATUS = NTSTATUS(-1_070_137_327_i32); + pub const STATUS_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUE: NTSTATUS = NTSTATUS(-1_070_137_322_i32); + pub const STATUS_VID_PAGE_RANGE_OVERFLOW: NTSTATUS = NTSTATUS(-1_070_137_325_i32); + pub const STATUS_VID_PARTITION_ALREADY_EXISTS: NTSTATUS = NTSTATUS(-1_070_137_336_i32); + pub const STATUS_VID_PARTITION_DOES_NOT_EXIST: NTSTATUS = NTSTATUS(-1_070_137_335_i32); + pub const STATUS_VID_PARTITION_NAME_NOT_FOUND: NTSTATUS = NTSTATUS(-1_070_137_334_i32); + pub const STATUS_VID_PARTITION_NAME_TOO_LONG: NTSTATUS = NTSTATUS(-1_070_137_338_i32); + pub const STATUS_VID_PROCESS_ALREADY_SET: NTSTATUS = NTSTATUS(-1_070_137_296_i32); + pub const STATUS_VID_QUEUE_FULL: NTSTATUS = NTSTATUS(-1_070_137_341_i32); + pub const STATUS_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED: NTSTATUS = NTSTATUS(-2_143_879_167_i32); + pub const STATUS_VID_RESERVE_PAGE_SET_IS_BEING_USED: NTSTATUS = NTSTATUS(-1_070_137_309_i32); + pub const STATUS_VID_RESERVE_PAGE_SET_TOO_SMALL: NTSTATUS = NTSTATUS(-1_070_137_308_i32); + pub const STATUS_VID_SAVED_STATE_CORRUPT: NTSTATUS = NTSTATUS(-1_070_137_305_i32); + pub const STATUS_VID_SAVED_STATE_INCOMPATIBLE: NTSTATUS = NTSTATUS(-1_070_137_303_i32); + pub const STATUS_VID_SAVED_STATE_UNRECOGNIZED_ITEM: NTSTATUS = NTSTATUS(-1_070_137_304_i32); + pub const STATUS_VID_STOP_PENDING: NTSTATUS = NTSTATUS(-1_070_137_316_i32); + pub const STATUS_VID_TOO_MANY_HANDLERS: NTSTATUS = NTSTATUS(-1_070_137_342_i32); + pub const STATUS_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDED: NTSTATUS = NTSTATUS(-1_070_137_317_i32); + pub const STATUS_VID_VTL_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_070_137_302_i32); + pub const STATUS_VIRTDISK_DISK_ALREADY_OWNED: NTSTATUS = NTSTATUS(-1_069_940_706_i32); + pub const STATUS_VIRTDISK_DISK_ONLINE_AND_WRITABLE: NTSTATUS = NTSTATUS(-1_069_940_705_i32); + pub const STATUS_VIRTDISK_NOT_VIRTUAL_DISK: NTSTATUS = NTSTATUS(-1_069_940_715_i32); + pub const STATUS_VIRTDISK_PROVIDER_NOT_FOUND: NTSTATUS = NTSTATUS(-1_069_940_716_i32); + pub const STATUS_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZE: NTSTATUS = NTSTATUS(-1_069_940_707_i32); + pub const STATUS_VIRTUAL_CIRCUIT_CLOSED: NTSTATUS = NTSTATUS(-1_073_741_610_i32); + pub const STATUS_VIRTUAL_DISK_LIMITATION: NTSTATUS = NTSTATUS(-1_069_940_710_i32); + pub const STATUS_VIRUS_DELETED: NTSTATUS = NTSTATUS(-1_073_739_513_i32); + pub const STATUS_VIRUS_INFECTED: NTSTATUS = NTSTATUS(-1_073_739_514_i32); + pub const STATUS_VOLMGR_ALL_DISKS_FAILED: NTSTATUS = NTSTATUS(-1_070_071_767_i32); + pub const STATUS_VOLMGR_BAD_BOOT_DISK: NTSTATUS = NTSTATUS(-1_070_071_729_i32); + pub const STATUS_VOLMGR_DATABASE_FULL: NTSTATUS = NTSTATUS(-1_070_071_807_i32); + pub const STATUS_VOLMGR_DIFFERENT_SECTOR_SIZE: NTSTATUS = NTSTATUS(-1_070_071_730_i32); + pub const STATUS_VOLMGR_DISK_CONFIGURATION_CORRUPTED: NTSTATUS = NTSTATUS(-1_070_071_806_i32); + pub const STATUS_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC: NTSTATUS = NTSTATUS(-1_070_071_805_i32); + pub const STATUS_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUME: NTSTATUS = NTSTATUS(-1_070_071_803_i32); + pub const STATUS_VOLMGR_DISK_DUPLICATE: NTSTATUS = NTSTATUS(-1_070_071_802_i32); + pub const STATUS_VOLMGR_DISK_DYNAMIC: NTSTATUS = NTSTATUS(-1_070_071_801_i32); + pub const STATUS_VOLMGR_DISK_ID_INVALID: NTSTATUS = NTSTATUS(-1_070_071_800_i32); + pub const STATUS_VOLMGR_DISK_INVALID: NTSTATUS = NTSTATUS(-1_070_071_799_i32); + pub const STATUS_VOLMGR_DISK_LAST_VOTER: NTSTATUS = NTSTATUS(-1_070_071_798_i32); + pub const STATUS_VOLMGR_DISK_LAYOUT_INVALID: NTSTATUS = NTSTATUS(-1_070_071_797_i32); + pub const STATUS_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONS: NTSTATUS = NTSTATUS(-1_070_071_796_i32); + pub const STATUS_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNED: NTSTATUS = NTSTATUS(-1_070_071_795_i32); + pub const STATUS_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALL: NTSTATUS = NTSTATUS(-1_070_071_794_i32); + pub const STATUS_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONS: NTSTATUS = NTSTATUS(-1_070_071_793_i32); + pub const STATUS_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONS: NTSTATUS = NTSTATUS(-1_070_071_792_i32); + pub const STATUS_VOLMGR_DISK_MISSING: NTSTATUS = NTSTATUS(-1_070_071_791_i32); + pub const STATUS_VOLMGR_DISK_NOT_EMPTY: NTSTATUS = NTSTATUS(-1_070_071_790_i32); + pub const STATUS_VOLMGR_DISK_NOT_ENOUGH_SPACE: NTSTATUS = NTSTATUS(-1_070_071_789_i32); + pub const STATUS_VOLMGR_DISK_REVECTORING_FAILED: NTSTATUS = NTSTATUS(-1_070_071_788_i32); + pub const STATUS_VOLMGR_DISK_SECTOR_SIZE_INVALID: NTSTATUS = NTSTATUS(-1_070_071_787_i32); + pub const STATUS_VOLMGR_DISK_SET_NOT_CONTAINED: NTSTATUS = NTSTATUS(-1_070_071_786_i32); + pub const STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERS: NTSTATUS = NTSTATUS(-1_070_071_785_i32); + pub const STATUS_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXES: NTSTATUS = NTSTATUS(-1_070_071_784_i32); + pub const STATUS_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_070_071_783_i32); + pub const STATUS_VOLMGR_EXTENT_ALREADY_USED: NTSTATUS = NTSTATUS(-1_070_071_782_i32); + pub const STATUS_VOLMGR_EXTENT_NOT_CONTIGUOUS: NTSTATUS = NTSTATUS(-1_070_071_781_i32); + pub const STATUS_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGION: NTSTATUS = NTSTATUS(-1_070_071_780_i32); + pub const STATUS_VOLMGR_EXTENT_NOT_SECTOR_ALIGNED: NTSTATUS = NTSTATUS(-1_070_071_779_i32); + pub const STATUS_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITION: NTSTATUS = NTSTATUS(-1_070_071_778_i32); + pub const STATUS_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCH: NTSTATUS = NTSTATUS(-1_070_071_777_i32); + pub const STATUS_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_070_071_776_i32); + pub const STATUS_VOLMGR_INCOMPLETE_DISK_MIGRATION: NTSTATUS = NTSTATUS(-2_143_813_630_i32); + pub const STATUS_VOLMGR_INCOMPLETE_REGENERATION: NTSTATUS = NTSTATUS(-2_143_813_631_i32); + pub const STATUS_VOLMGR_INTERLEAVE_LENGTH_INVALID: NTSTATUS = NTSTATUS(-1_070_071_775_i32); + pub const STATUS_VOLMGR_MAXIMUM_REGISTERED_USERS: NTSTATUS = NTSTATUS(-1_070_071_774_i32); + pub const STATUS_VOLMGR_MEMBER_INDEX_DUPLICATE: NTSTATUS = NTSTATUS(-1_070_071_772_i32); + pub const STATUS_VOLMGR_MEMBER_INDEX_INVALID: NTSTATUS = NTSTATUS(-1_070_071_771_i32); + pub const STATUS_VOLMGR_MEMBER_IN_SYNC: NTSTATUS = NTSTATUS(-1_070_071_773_i32); + pub const STATUS_VOLMGR_MEMBER_MISSING: NTSTATUS = NTSTATUS(-1_070_071_770_i32); + pub const STATUS_VOLMGR_MEMBER_NOT_DETACHED: NTSTATUS = NTSTATUS(-1_070_071_769_i32); + pub const STATUS_VOLMGR_MEMBER_REGENERATING: NTSTATUS = NTSTATUS(-1_070_071_768_i32); + pub const STATUS_VOLMGR_MIRROR_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_070_071_717_i32); + pub const STATUS_VOLMGR_NOTIFICATION_RESET: NTSTATUS = NTSTATUS(-1_070_071_764_i32); + pub const STATUS_VOLMGR_NOT_PRIMARY_PACK: NTSTATUS = NTSTATUS(-1_070_071_726_i32); + pub const STATUS_VOLMGR_NO_REGISTERED_USERS: NTSTATUS = NTSTATUS(-1_070_071_766_i32); + pub const STATUS_VOLMGR_NO_SUCH_USER: NTSTATUS = NTSTATUS(-1_070_071_765_i32); + pub const STATUS_VOLMGR_NO_VALID_LOG_COPIES: NTSTATUS = NTSTATUS(-1_070_071_720_i32); + pub const STATUS_VOLMGR_NUMBER_OF_DISKS_INVALID: NTSTATUS = NTSTATUS(-1_070_071_718_i32); + pub const STATUS_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALID: NTSTATUS = NTSTATUS(-1_070_071_723_i32); + pub const STATUS_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALID: NTSTATUS = NTSTATUS(-1_070_071_724_i32); + pub const STATUS_VOLMGR_NUMBER_OF_EXTENTS_INVALID: NTSTATUS = NTSTATUS(-1_070_071_731_i32); + pub const STATUS_VOLMGR_NUMBER_OF_MEMBERS_INVALID: NTSTATUS = NTSTATUS(-1_070_071_763_i32); + pub const STATUS_VOLMGR_NUMBER_OF_PLEXES_INVALID: NTSTATUS = NTSTATUS(-1_070_071_762_i32); + pub const STATUS_VOLMGR_PACK_CONFIG_OFFLINE: NTSTATUS = NTSTATUS(-1_070_071_728_i32); + pub const STATUS_VOLMGR_PACK_CONFIG_ONLINE: NTSTATUS = NTSTATUS(-1_070_071_727_i32); + pub const STATUS_VOLMGR_PACK_CONFIG_UPDATE_FAILED: NTSTATUS = NTSTATUS(-1_070_071_804_i32); + pub const STATUS_VOLMGR_PACK_DUPLICATE: NTSTATUS = NTSTATUS(-1_070_071_761_i32); + pub const STATUS_VOLMGR_PACK_HAS_QUORUM: NTSTATUS = NTSTATUS(-1_070_071_756_i32); + pub const STATUS_VOLMGR_PACK_ID_INVALID: NTSTATUS = NTSTATUS(-1_070_071_760_i32); + pub const STATUS_VOLMGR_PACK_INVALID: NTSTATUS = NTSTATUS(-1_070_071_759_i32); + pub const STATUS_VOLMGR_PACK_LOG_UPDATE_FAILED: NTSTATUS = NTSTATUS(-1_070_071_725_i32); + pub const STATUS_VOLMGR_PACK_NAME_INVALID: NTSTATUS = NTSTATUS(-1_070_071_758_i32); + pub const STATUS_VOLMGR_PACK_OFFLINE: NTSTATUS = NTSTATUS(-1_070_071_757_i32); + pub const STATUS_VOLMGR_PACK_WITHOUT_QUORUM: NTSTATUS = NTSTATUS(-1_070_071_755_i32); + pub const STATUS_VOLMGR_PARTITION_STYLE_INVALID: NTSTATUS = NTSTATUS(-1_070_071_754_i32); + pub const STATUS_VOLMGR_PARTITION_UPDATE_FAILED: NTSTATUS = NTSTATUS(-1_070_071_753_i32); + pub const STATUS_VOLMGR_PLEX_INDEX_DUPLICATE: NTSTATUS = NTSTATUS(-1_070_071_751_i32); + pub const STATUS_VOLMGR_PLEX_INDEX_INVALID: NTSTATUS = NTSTATUS(-1_070_071_750_i32); + pub const STATUS_VOLMGR_PLEX_IN_SYNC: NTSTATUS = NTSTATUS(-1_070_071_752_i32); + pub const STATUS_VOLMGR_PLEX_LAST_ACTIVE: NTSTATUS = NTSTATUS(-1_070_071_749_i32); + pub const STATUS_VOLMGR_PLEX_MISSING: NTSTATUS = NTSTATUS(-1_070_071_748_i32); + pub const STATUS_VOLMGR_PLEX_NOT_RAID5: NTSTATUS = NTSTATUS(-1_070_071_745_i32); + pub const STATUS_VOLMGR_PLEX_NOT_SIMPLE: NTSTATUS = NTSTATUS(-1_070_071_744_i32); + pub const STATUS_VOLMGR_PLEX_NOT_SIMPLE_SPANNED: NTSTATUS = NTSTATUS(-1_070_071_721_i32); + pub const STATUS_VOLMGR_PLEX_REGENERATING: NTSTATUS = NTSTATUS(-1_070_071_747_i32); + pub const STATUS_VOLMGR_PLEX_TYPE_INVALID: NTSTATUS = NTSTATUS(-1_070_071_746_i32); + pub const STATUS_VOLMGR_PRIMARY_PACK_PRESENT: NTSTATUS = NTSTATUS(-1_070_071_719_i32); + pub const STATUS_VOLMGR_RAID5_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_070_071_716_i32); + pub const STATUS_VOLMGR_STRUCTURE_SIZE_INVALID: NTSTATUS = NTSTATUS(-1_070_071_743_i32); + pub const STATUS_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTS: NTSTATUS = NTSTATUS(-1_070_071_742_i32); + pub const STATUS_VOLMGR_TRANSACTION_IN_PROGRESS: NTSTATUS = NTSTATUS(-1_070_071_741_i32); + pub const STATUS_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGE: NTSTATUS = NTSTATUS(-1_070_071_740_i32); + pub const STATUS_VOLMGR_VOLUME_CONTAINS_MISSING_DISK: NTSTATUS = NTSTATUS(-1_070_071_739_i32); + pub const STATUS_VOLMGR_VOLUME_ID_INVALID: NTSTATUS = NTSTATUS(-1_070_071_738_i32); + pub const STATUS_VOLMGR_VOLUME_LENGTH_INVALID: NTSTATUS = NTSTATUS(-1_070_071_737_i32); + pub const STATUS_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLE: NTSTATUS = NTSTATUS(-1_070_071_736_i32); + pub const STATUS_VOLMGR_VOLUME_MIRRORED: NTSTATUS = NTSTATUS(-1_070_071_722_i32); + pub const STATUS_VOLMGR_VOLUME_NOT_MIRRORED: NTSTATUS = NTSTATUS(-1_070_071_735_i32); + pub const STATUS_VOLMGR_VOLUME_NOT_RETAINED: NTSTATUS = NTSTATUS(-1_070_071_734_i32); + pub const STATUS_VOLMGR_VOLUME_OFFLINE: NTSTATUS = NTSTATUS(-1_070_071_733_i32); + pub const STATUS_VOLMGR_VOLUME_RETAINED: NTSTATUS = NTSTATUS(-1_070_071_732_i32); + pub const STATUS_VOLSNAP_ACTIVATION_TIMEOUT: NTSTATUS = NTSTATUS(-1_068_498_940_i32); + pub const STATUS_VOLSNAP_BOOTFILE_NOT_VALID: NTSTATUS = NTSTATUS(-1_068_498_941_i32); + pub const STATUS_VOLSNAP_HIBERNATE_READY: NTSTATUS = NTSTATUS(293i32); + pub const STATUS_VOLSNAP_NO_BYPASSIO_WITH_SNAPSHOT: NTSTATUS = NTSTATUS(-1_068_498_939_i32); + pub const STATUS_VOLSNAP_PREPARE_HIBERNATE: NTSTATUS = NTSTATUS(-1_073_740_793_i32); + pub const STATUS_VOLUME_DIRTY: NTSTATUS = NTSTATUS(-1_073_739_770_i32); + pub const STATUS_VOLUME_DISMOUNTED: NTSTATUS = NTSTATUS(-1_073_741_202_i32); + pub const STATUS_VOLUME_MOUNTED: NTSTATUS = NTSTATUS(265i32); + pub const STATUS_VOLUME_NOT_CLUSTER_ALIGNED: NTSTATUS = NTSTATUS(-1_073_740_636_i32); + pub const STATUS_VOLUME_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_740_602_i32); + pub const STATUS_VOLUME_NOT_UPGRADED: NTSTATUS = NTSTATUS(-1_073_741_156_i32); + pub const STATUS_VOLUME_WRITE_ACCESS_DENIED: NTSTATUS = NTSTATUS(-1_073_740_589_i32); + pub const STATUS_VRF_VOLATILE_CFG_AND_IO_ENABLED: NTSTATUS = NTSTATUS(-1_073_738_744_i32); + pub const STATUS_VRF_VOLATILE_NMI_REGISTERED: NTSTATUS = NTSTATUS(-1_073_738_738_i32); + pub const STATUS_VRF_VOLATILE_NOT_RUNNABLE_SYSTEM: NTSTATUS = NTSTATUS(-1_073_738_741_i32); + pub const STATUS_VRF_VOLATILE_NOT_STOPPABLE: NTSTATUS = NTSTATUS(-1_073_738_743_i32); + pub const STATUS_VRF_VOLATILE_NOT_SUPPORTED_RULECLASS: NTSTATUS = NTSTATUS(-1_073_738_740_i32); + pub const STATUS_VRF_VOLATILE_PROTECTED_DRIVER: NTSTATUS = NTSTATUS(-1_073_738_739_i32); + pub const STATUS_VRF_VOLATILE_SAFE_MODE: NTSTATUS = NTSTATUS(-1_073_738_742_i32); + pub const STATUS_VRF_VOLATILE_SETTINGS_CONFLICT: NTSTATUS = NTSTATUS(-1_073_738_737_i32); + pub const STATUS_VSM_DMA_PROTECTION_NOT_IN_USE: NTSTATUS = NTSTATUS(-1_069_219_839_i32); + pub const STATUS_VSM_NOT_INITIALIZED: NTSTATUS = NTSTATUS(-1_069_219_840_i32); + pub const STATUS_WAIT_0: NTSTATUS = NTSTATUS(0i32); + pub const STATUS_WAIT_1: NTSTATUS = NTSTATUS(1i32); + pub const STATUS_WAIT_2: NTSTATUS = NTSTATUS(2i32); + pub const STATUS_WAIT_3: NTSTATUS = NTSTATUS(3i32); + pub const STATUS_WAIT_63: NTSTATUS = NTSTATUS(63i32); + pub const STATUS_WAIT_FOR_OPLOCK: NTSTATUS = NTSTATUS(871i32); + pub const STATUS_WAKE_SYSTEM: NTSTATUS = NTSTATUS(1_073_742_484_i32); + pub const STATUS_WAKE_SYSTEM_DEBUGGER: NTSTATUS = NTSTATUS(-2_147_483_641_i32); + pub const STATUS_WAS_LOCKED: NTSTATUS = NTSTATUS(1_073_741_849_i32); + pub const STATUS_WAS_UNLOCKED: NTSTATUS = NTSTATUS(1_073_741_847_i32); + pub const STATUS_WEAK_WHFBKEY_BLOCKED: NTSTATUS = NTSTATUS(-1_073_741_389_i32); + pub const STATUS_WIM_NOT_BOOTABLE: NTSTATUS = NTSTATUS(-1_073_740_665_i32); + pub const STATUS_WMI_ALREADY_DISABLED: NTSTATUS = NTSTATUS(-1_073_741_054_i32); + pub const STATUS_WMI_ALREADY_ENABLED: NTSTATUS = NTSTATUS(-1_073_741_053_i32); + pub const STATUS_WMI_GUID_DISCONNECTED: NTSTATUS = NTSTATUS(-1_073_741_055_i32); + pub const STATUS_WMI_GUID_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_163_i32); + pub const STATUS_WMI_INSTANCE_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_162_i32); + pub const STATUS_WMI_ITEMID_NOT_FOUND: NTSTATUS = NTSTATUS(-1_073_741_161_i32); + pub const STATUS_WMI_NOT_SUPPORTED: NTSTATUS = NTSTATUS(-1_073_741_091_i32); + pub const STATUS_WMI_READ_ONLY: NTSTATUS = NTSTATUS(-1_073_741_114_i32); + pub const STATUS_WMI_SET_FAILURE: NTSTATUS = NTSTATUS(-1_073_741_113_i32); + pub const STATUS_WMI_TRY_AGAIN: NTSTATUS = NTSTATUS(-1_073_741_160_i32); + pub const STATUS_WOF_FILE_RESOURCE_TABLE_CORRUPT: NTSTATUS = NTSTATUS(-1_073_700_185_i32); + pub const STATUS_WOF_WIM_HEADER_CORRUPT: NTSTATUS = NTSTATUS(-1_073_700_187_i32); + pub const STATUS_WOF_WIM_RESOURCE_TABLE_CORRUPT: NTSTATUS = NTSTATUS(-1_073_700_186_i32); + pub const STATUS_WORKING_SET_LIMIT_RANGE: NTSTATUS = NTSTATUS(1_073_741_826_i32); + pub const STATUS_WORKING_SET_QUOTA: NTSTATUS = NTSTATUS(-1_073_741_663_i32); + pub const STATUS_WOW_ASSERTION: NTSTATUS = NTSTATUS(-1_073_702_760_i32); + pub const STATUS_WRONG_COMPARTMENT: NTSTATUS = NTSTATUS(-1_073_700_731_i32); + pub const STATUS_WRONG_CREDENTIAL_HANDLE: NTSTATUS = NTSTATUS(-1_073_741_070_i32); + pub const STATUS_WRONG_EFS: NTSTATUS = NTSTATUS(-1_073_741_169_i32); + pub const STATUS_WRONG_PASSWORD_CORE: NTSTATUS = NTSTATUS(-1_073_741_495_i32); + pub const STATUS_WRONG_VOLUME: NTSTATUS = NTSTATUS(-1_073_741_806_i32); + pub const STATUS_WX86_BREAKPOINT: NTSTATUS = NTSTATUS(1_073_741_855_i32); + pub const STATUS_WX86_CONTINUE: NTSTATUS = NTSTATUS(1_073_741_853_i32); + pub const STATUS_WX86_CREATEWX86TIB: NTSTATUS = NTSTATUS(1_073_741_864_i32); + pub const STATUS_WX86_EXCEPTION_CHAIN: NTSTATUS = NTSTATUS(1_073_741_858_i32); + pub const STATUS_WX86_EXCEPTION_CONTINUE: NTSTATUS = NTSTATUS(1_073_741_856_i32); + pub const STATUS_WX86_EXCEPTION_LASTCHANCE: NTSTATUS = NTSTATUS(1_073_741_857_i32); + pub const STATUS_WX86_FLOAT_STACK_CHECK: NTSTATUS = NTSTATUS(-1_073_741_200_i32); + pub const STATUS_WX86_INTERNAL_ERROR: NTSTATUS = NTSTATUS(-1_073_741_201_i32); + pub const STATUS_WX86_SINGLE_STEP: NTSTATUS = NTSTATUS(1_073_741_854_i32); + pub const STATUS_WX86_UNSIMULATE: NTSTATUS = NTSTATUS(1_073_741_852_i32); + pub const STATUS_XMLDSIG_ERROR: NTSTATUS = NTSTATUS(-1_073_700_732_i32); + pub const STATUS_XML_ENCODING_MISMATCH: NTSTATUS = NTSTATUS(-1_072_365_535_i32); + pub const STATUS_XML_PARSE_ERROR: NTSTATUS = NTSTATUS(-1_073_700_733_i32); +} diff --git a/packaging/windows/vdisplay-driver/wdf-umdf/Cargo.toml b/packaging/windows/vdisplay-driver/wdf-umdf/Cargo.toml new file mode 100644 index 0000000..156e45f --- /dev/null +++ b/packaging/windows/vdisplay-driver/wdf-umdf/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "wdf-umdf" +version = "0.1.0" +edition = "2021" + +[lints] +workspace = true + +[dependencies] +wdf-umdf-sys = { path = "../wdf-umdf-sys" } +paste = "1.0.15" +thiserror = "2.0.3" diff --git a/packaging/windows/vdisplay-driver/wdf-umdf/src/iddcx.rs b/packaging/windows/vdisplay-driver/wdf-umdf/src/iddcx.rs new file mode 100644 index 0000000..9e0784b --- /dev/null +++ b/packaging/windows/vdisplay-driver/wdf-umdf/src/iddcx.rs @@ -0,0 +1,319 @@ +#![allow(non_snake_case)] +#![allow(clippy::missing_errors_doc)] + +use std::sync::OnceLock; + +use wdf_umdf_sys::{ + IDARG_IN_ADAPTERSETRENDERADAPTER, IDARG_IN_ADAPTER_INIT, IDARG_IN_MONITORCREATE, + IDARG_IN_QUERY_HWCURSOR, IDARG_IN_SETUP_HWCURSOR, IDARG_IN_SWAPCHAINSETDEVICE, + IDARG_OUT_ADAPTER_INIT, IDARG_OUT_MONITORARRIVAL, IDARG_OUT_MONITORCREATE, + IDARG_OUT_QUERY_HWCURSOR, IDARG_OUT_RELEASEANDACQUIREBUFFER, IDDCX_ADAPTER, IDDCX_MONITOR, + IDDCX_SWAPCHAIN, IDD_CX_CLIENT_CONFIG, NTSTATUS, WDFDEVICE, WDFDEVICE_INIT, +}; + +#[derive(Copy, Clone, Debug, thiserror::Error)] +pub enum IddCxError { + #[error("{0}")] + IddCxFunctionNotAvailable(&'static str), + #[error("{0}")] + CallFailed(NTSTATUS), + #[error("{0}")] + NtStatus(NTSTATUS), +} + +impl From for NTSTATUS { + fn from(value: IddCxError) -> Self { + #[allow(clippy::enum_glob_use)] + use IddCxError::*; + match value { + IddCxFunctionNotAvailable(_) => Self::STATUS_NOT_FOUND, + CallFailed(status) => status, + NtStatus(n) => n, + } + } +} + +impl From for IddCxError { + fn from(value: NTSTATUS) -> Self { + IddCxError::CallFailed(value) + } +} + +impl From for IddCxError { + fn from(val: i32) -> Self { + IddCxError::NtStatus(NTSTATUS(val)) + } +} + +// void IddCx functions return () on success; required by the call macro's error arm but never an error. +impl From<()> for IddCxError { + fn from(_: ()) -> Self { + IddCxError::NtStatus(NTSTATUS(0)) + } +} + +macro_rules! IddCxCall { + ($name:ident ( $($args:expr),* )) => { + IddCxCall!(false, $name($($args),*)) + }; + + ($other_is_error:expr, $name:ident ( $($args:expr),* )) => {{ + static CACHED_FN: OnceLock< + Result< + ::paste::paste!(::wdf_umdf_sys::[]), + IddCxError + > + > = OnceLock::new(); + + let f = CACHED_FN.get_or_init(|| { + ::paste::paste! { + const FN_INDEX: usize = ::wdf_umdf_sys::IDDFUNCENUM::[<$name TableIndex>].0 as usize; + + // validate that wdf function can be used + let is_available = ::wdf_umdf_sys::IddCxIsFunctionAvailable!($name); + + if is_available { + // SAFETY: Only immutable accesses are done to this + // The underlying array is Copy, so we call as_ptr() directly on it inside block + let fn_table = unsafe { ::wdf_umdf_sys::IddFunctions.as_ptr() }; + + // SAFETY: Ensured that this is present by if condition from `WdfIsFunctionAvailable!` + let f = unsafe { + fn_table.add(FN_INDEX) + .cast::<::wdf_umdf_sys::[]>() + }; + + // SAFETY: Ensured that this is present by if condition from `IddIsFunctionAvailable!` + let f = unsafe { f.read() }; + + Ok(f) + } else { + Err($crate::IddCxError::IddCxFunctionNotAvailable(concat!(stringify!($name), " is not available"))) + } + } + }).clone()?; + + // SAFETY: Above: If it's Ok, then it's guaranteed to be Some(fn) + let f = unsafe { f.unwrap_unchecked() }; + + // SAFETY: Pointer to globals is always immutable + let globals = unsafe { ::wdf_umdf_sys::IddDriverGlobals }; + + // SAFETY: None. User is responsible for safety and must use their own unsafe block + let result = unsafe { f(globals, $($args),*) }; + + if $crate::is_nt_error(&result, $other_is_error) { + Err(result.into()) + } else { + Ok(result.into()) + } + + }}; +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn IddCxDeviceInitConfig( + // in, out + DeviceInit: &mut WDFDEVICE_INIT, + // in + Config: &IDD_CX_CLIENT_CONFIG, +) -> Result { + IddCxCall! { + IddCxDeviceInitConfig( + DeviceInit, + Config + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn IddCxDeviceInitialize( + // in + Device: WDFDEVICE, +) -> Result { + IddCxCall! { + IddCxDeviceInitialize( + Device + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn IddCxAdapterInitAsync( + // in + pInArgs: &IDARG_IN_ADAPTER_INIT, + // out + pOutArgs: &mut IDARG_OUT_ADAPTER_INIT, +) -> Result { + IddCxCall! { + IddCxAdapterInitAsync( + pInArgs, + pOutArgs + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +#[rustfmt::skip] +pub unsafe fn IddCxMonitorCreate( + // in + AdapterObject: IDDCX_ADAPTER, + // in + pInArgs: &IDARG_IN_MONITORCREATE, + // out + pOutArgs: &mut IDARG_OUT_MONITORCREATE, +) -> Result { + IddCxCall!( + IddCxMonitorCreate( + AdapterObject, + pInArgs, + pOutArgs + ) + ) +} + +/// # Safety +/// +/// None. User is responsible for safety. +#[rustfmt::skip] +pub unsafe fn IddCxMonitorArrival( + // in + MonitorObject: IDDCX_MONITOR, + // out + pOutArgs: &mut IDARG_OUT_MONITORARRIVAL, +) -> Result { + IddCxCall!( + IddCxMonitorArrival( + MonitorObject, + pOutArgs + ) + ) +} + +/// # Safety +/// +/// None. User is responsible for safety. +#[rustfmt::skip] +pub unsafe fn IddCxSwapChainSetDevice( + // in + SwapChainObject: IDDCX_SWAPCHAIN, + // in + pInArgs: &IDARG_IN_SWAPCHAINSETDEVICE +) -> Result { + IddCxCall!( + true, + IddCxSwapChainSetDevice( + SwapChainObject, + pInArgs + ) + ) +} + +/// # Safety +/// +/// None. User is responsible for safety. +#[rustfmt::skip] +pub unsafe fn IddCxSwapChainReleaseAndAcquireBuffer( + // in + SwapChainObject: IDDCX_SWAPCHAIN, + // out + pOutArgs: &mut IDARG_OUT_RELEASEANDACQUIREBUFFER +) -> Result { + IddCxCall!( + true, + IddCxSwapChainReleaseAndAcquireBuffer( + SwapChainObject, + pOutArgs + ) + ) +} + +/// # Safety +/// +/// None. User is responsible for safety. +#[rustfmt::skip] +pub unsafe fn IddCxSwapChainFinishedProcessingFrame( + // in + SwapChainObject: IDDCX_SWAPCHAIN +) -> Result { + IddCxCall!( + true, + IddCxSwapChainFinishedProcessingFrame( + SwapChainObject + ) + ) +} + +/// # Safety +/// +/// None. User is responsible for safety. +#[rustfmt::skip] +pub unsafe fn IddCxMonitorDeparture( + // in + MonitorObject: IDDCX_MONITOR +) -> Result { + IddCxCall!( + IddCxMonitorDeparture( + MonitorObject + ) + ) +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn IddCxAdapterSetRenderAdapter( + // in + AdapterObject: IDDCX_ADAPTER, + // in + pInArgs: *const IDARG_IN_ADAPTERSETRENDERADAPTER, +) -> Result<(), IddCxError> { + IddCxCall!(IddCxAdapterSetRenderAdapter(AdapterObject, pInArgs)) +} + +/// # Safety +/// +/// None. User is responsible for safety. +#[rustfmt::skip] +pub unsafe fn IddCxMonitorSetupHardwareCursor( + // in + MonitorObject: IDDCX_MONITOR, + // in + pInArgs: &IDARG_IN_SETUP_HWCURSOR +) -> Result { + IddCxCall!( + IddCxMonitorSetupHardwareCursor( + MonitorObject, + pInArgs + ) + ) +} + +/// # Safety +/// +/// None. User is responsible for safety. +#[rustfmt::skip] +pub unsafe fn IddCxMonitorQueryHardwareCursor( + // in + MonitorObject: IDDCX_MONITOR, + // in + pInArgs: &IDARG_IN_QUERY_HWCURSOR, + // out + pOutArgs: &mut IDARG_OUT_QUERY_HWCURSOR +) -> Result { + IddCxCall!( + IddCxMonitorQueryHardwareCursor( + MonitorObject, + pInArgs, + pOutArgs + ) + ) +} diff --git a/packaging/windows/vdisplay-driver/wdf-umdf/src/lib.rs b/packaging/windows/vdisplay-driver/wdf-umdf/src/lib.rs new file mode 100644 index 0000000..bd5eba5 --- /dev/null +++ b/packaging/windows/vdisplay-driver/wdf-umdf/src/lib.rs @@ -0,0 +1,30 @@ +mod iddcx; +mod wdf; + +use std::any::Any; + +pub use paste::paste; + +pub use iddcx::*; +pub use wdf::*; +pub use wdf_umdf_sys; + +use wdf_umdf_sys::NTSTATUS; + +/// Used for the macros so they can correctly convert a functions result +fn is_nt_error(val: &dyn Any, other_is_error: bool) -> bool { + if let Some(status) = val.downcast_ref::() { + return !status.is_success(); + } + + // other errors which may not be error codes, but may also be + // such as HRESULT == i32 + if other_is_error { + if let Some(status) = val.downcast_ref::() { + let status = NTSTATUS(*status); + return !status.is_success(); + } + } + + false +} diff --git a/packaging/windows/vdisplay-driver/wdf-umdf/src/wdf.rs b/packaging/windows/vdisplay-driver/wdf-umdf/src/wdf.rs new file mode 100644 index 0000000..437d53c --- /dev/null +++ b/packaging/windows/vdisplay-driver/wdf-umdf/src/wdf.rs @@ -0,0 +1,667 @@ +#![allow(non_snake_case)] +#![allow(clippy::missing_errors_doc)] + +use std::ffi::c_void; +use std::sync::OnceLock; + +use wdf_umdf_sys::{ + DEVPROPTYPE, GUID, NTSTATUS, PCUNICODE_STRING, PCWDF_OBJECT_CONTEXT_TYPE_INFO, PDRIVER_OBJECT, + POOL_TYPE, PVOID, PWDFDEVICE_INIT, PWDF_DRIVER_CONFIG, PWDF_OBJECT_ATTRIBUTES, ULONG_PTR, + WDFDEVICE, WDFDRIVER, WDFMEMORY, WDFOBJECT, WDFREQUEST, WDF_DEVICE_FAILED_ACTION, WDF_NO_HANDLE, + WDF_NO_OBJECT_ATTRIBUTES, WDF_OBJECT_ATTRIBUTES, _WDF_DEVICE_PROPERTY_DATA, + _WDF_PNPPOWER_EVENT_CALLBACKS, +}; + +#[derive(Copy, Clone, Debug, thiserror::Error)] +pub enum WdfError { + #[error("{0}")] + WdfFunctionNotAvailable(&'static str), + #[error("{0}")] + CallFailed(NTSTATUS), + #[error("Failed to upgrade Arc pointer")] + UpgradeFailed, + #[error("Failed to lock")] + LockFailed, + #[error("Unknown")] + Unknown, + // this is required for success status for () + #[error("This is not an error, ignore it")] + _Success, +} + +impl From<()> for WdfError { + fn from(_: ()) -> Self { + WdfError::_Success + } +} + +impl From<*mut c_void> for WdfError { + fn from(_: *mut c_void) -> Self { + Self::Unknown + } +} + +impl From for NTSTATUS { + fn from(value: WdfError) -> Self { + #[allow(clippy::enum_glob_use)] + use WdfError::*; + match value { + WdfFunctionNotAvailable(_) => Self::STATUS_NOT_FOUND, + CallFailed(status) => status, + UpgradeFailed => Self::STATUS_INVALID_HANDLE, + LockFailed => Self::STATUS_WAS_LOCKED, + Unknown => Self::STATUS_DRIVER_INTERNAL_ERROR, + _Success => 0.into(), + } + } +} + +impl From for WdfError { + fn from(value: NTSTATUS) -> Self { + WdfError::CallFailed(value) + } +} + +macro_rules! WdfCall { + ($name:ident ( $($args:expr),* )) => { + WdfCall!(false, $name($($args),*)) + }; + + ($other_is_error:expr, $name:ident ( $($args:expr),* )) => {{ + static CACHED_FN: OnceLock< + Result< + ::paste::paste!(::wdf_umdf_sys::[]), + WdfError + > + > = OnceLock::new(); + + let f = CACHED_FN.get_or_init(|| { + ::paste::paste! { + const FN_INDEX: usize = ::wdf_umdf_sys::WDFFUNCENUM::[<$name TableIndex>].0 as usize; + + // validate that wdf function can be used + let is_available = ::wdf_umdf_sys::WdfIsFunctionAvailable!($name); + + if is_available { + // SAFETY: Only immutable accesses are done to this + let fn_table = unsafe { ::wdf_umdf_sys::WdfFunctions_02031 }; + + // SAFETY: Read-only, initialized by the time we use it, and checked to be in bounds + let f = unsafe { + fn_table + .add(FN_INDEX) + .cast::<::wdf_umdf_sys::[]>() + }; + + // SAFETY: Ensured that this is present by if condition from `WdfIsFunctionAvailable!` + let f = unsafe { f.read() }; + + Ok(f) + } else { + Err($crate::WdfError::WdfFunctionNotAvailable(concat!(stringify!($name), " is not available"))) + } + } + }).clone()?; + + // SAFETY: Above: If it's Ok, then it's guaranteed to be Some(fn) + let f = unsafe { f.unwrap_unchecked() }; + + // SAFETY: Pointer to globals is always immutable + let globals = unsafe { ::wdf_umdf_sys::WdfDriverGlobals }; + + // SAFETY: None. User is responsible for safety and must use their own unsafe block + let result = unsafe { f(globals, $($args),*) }; + + if $crate::is_nt_error(&result, $other_is_error) { + Err(result.into()) + } else { + Ok(result.into()) + } + + }}; +} + +/// Unlike the official `WDF_DECLARE_CONTEXT_TYPE` macro, you only need to declare this on the actual data struct want to use +/// Safety is maintained through a `RwLock` of the underlying data +/// +/// This generates associated fns `init`/`get`/`drop`/`get_type_info` on your `$context_type` with the same visibility +/// +/// Example: +/// ```rust +/// pub struct IndirectDeviceContext { +/// device: WDFDEVICE, +/// } +/// +/// impl IndirectDeviceContext { +/// pub fn new(device: WDFDEVICE) -> Self { +/// Self { device } +/// } +/// } +/// +/// WDF_DECLARE_CONTEXT_TYPE!(pub IndirectDeviceContext); +/// +/// // with a `device: WDFDEVICE` +/// let context = IndirectDeviceContext::new(device as WDFOBJECT); +/// IndirectDeviceContext::init(context); +/// // elsewhere +/// let mutable_access = IndirectDeviceContext::get_mut(device).unwrap(); +/// ``` +#[macro_export] +macro_rules! WDF_DECLARE_CONTEXT_TYPE { + ($sv:vis $context_type:ident) => { + $crate::paste! { + // keep it in a mod block to disallow access to private types + #[allow(non_snake_case)] + mod [] { + use super::$context_type; + + // Require `T: Sync` for safety. User has to uphold the invariant themselves + #[repr(transparent)] + #[allow(non_camel_case_types)] + struct [<_WDF_ $context_type _STATIC_WRAPPER>] { + cell: ::std::cell::UnsafeCell<$crate::wdf_umdf_sys::_WDF_OBJECT_CONTEXT_TYPE_INFO>, + _phantom: ::std::marker::PhantomData + } + + // SAFETY: `T` impls Sync too + unsafe impl Sync for [<_WDF_ $context_type _STATIC_WRAPPER>] {} + + // Unsure if C mutates this data, but it's in an unsafecell just in case + #[allow(non_upper_case_globals)] + static [<_WDF_ $context_type _TYPE_INFO>]: [<_WDF_ $context_type _STATIC_WRAPPER>]<$context_type> = + [<_WDF_ $context_type _STATIC_WRAPPER>] { + cell: ::std::cell::UnsafeCell::new( + $crate::wdf_umdf_sys::_WDF_OBJECT_CONTEXT_TYPE_INFO { + Size: ::std::mem::size_of::<$crate::wdf_umdf_sys::_WDF_OBJECT_CONTEXT_TYPE_INFO>() as u32, + ContextName: concat!(stringify!($context_type), "\0") + .as_ptr().cast::<::std::ffi::c_char>(), + ContextSize: ::std::mem::size_of::<[]>(), + // SAFETY: + // StaticWrapper and UnsafeCell are both repr(transparent), so cast to underlying _WDF_OBJECT_CONTEXT_TYPE_INFO is ok + UniqueType: &[<_WDF_ $context_type _TYPE_INFO>] as *const _ as *const _, + EvtDriverGetUniqueContextType: ::std::option::Option::None, + } + ), + + _phantom: ::std::marker::PhantomData + }; + + /// Allows us to keep ONE main Arc allocation while handing out weak pointers to the rest of the clones. + /// In this way, we can drop the allocation by dropping 1 arc, while letting others still access it + enum ArcPointer { + Strong(::std::sync::Arc), + Weak(::std::sync::Weak) + } + + #[repr(transparent)] + struct [](ArcPointer<::std::sync::RwLock<$context_type>>); + + impl $context_type { + /// Initialize and place context into internal WdfObject + /// + /// SAFETY: + /// - handle must be a fresh unused object with no data in its context already + /// - context type must already have been set up for handle + /// - Must be set only once regardless of the object. For all other objects, use clone_into() + $sv unsafe fn init( + self, + handle: $crate::wdf_umdf_sys::WDFOBJECT, + ) -> ::std::result::Result<(), $crate::WdfError> { + let context = unsafe { + $crate::WdfObjectGetTypedContextWorker(handle, [<_WDF_ $context_type _TYPE_INFO>].cell.get())? + } as *mut ::std::mem::MaybeUninit<[]>; + + let context = &mut *context; + + // Write to the memory location, making the data in it init + context.write( + []( + ArcPointer::Strong(::std::sync::Arc::new(::std::sync::RwLock::new(self))) + ) + ); + + Ok(()) + } + + /// Initialize handle's context and clone a Weak pointer to self context into it. + /// Internally, these are Arc's, so they will always point to the same data. + /// When the main Arc drops, none of these may access memory any longer + /// + /// SAFETY: + /// - handle must be a fresh unused object with no data in its context already + /// - to_handle must have set context_type for this type via WDF_OBJECT_ATTRIBUTES when it was created + /// - to_handle must be a valid T + $sv unsafe fn clone_into( + &self, + handle: $crate::wdf_umdf_sys::WDFOBJECT + ) -> ::std::result::Result<(), $crate::WdfError> { + let context = unsafe { + $crate::WdfObjectGetTypedContextWorker(handle, [<_WDF_ $context_type _TYPE_INFO>].cell.get())? + } as *mut ::std::mem::MaybeUninit<[]>; + + let context = &mut *context; + + let from_context = unsafe { + $crate::WdfObjectGetTypedContextWorker(self.device as *mut _, [<_WDF_ $context_type _TYPE_INFO>].cell.get())? + } as *mut []; + + let from_context = match &(*from_context).0 { + ArcPointer::Strong(a) => a.clone(), + ArcPointer::Weak(a) => a.upgrade().ok_or($crate::WdfError::UpgradeFailed)?.clone(), + }; + + // Write to the memory location, making the data in it init + // clones the arc into new handle + context.write( + [](ArcPointer::Weak(::std::sync::Arc::downgrade(&from_context))) + ); + + Ok(()) + } + + /// NOTE: Dropping memory that was created via `clone_into` will never drop the main allocation. + /// To drop the main allocation, you need to drop the instance made via `init`. + /// That instance can be obtained through the original handle you created it through + /// + /// SAFETY: + /// - Data in context is assumed to already be init and a valid T + /// - Therefore, init for the context must already have been done on this handle + /// - No other mutable/non-mutable refs can exist to data when this is called, or it will alias + /// + /// This may overwrite data in the handle's context memory, it is UB to read it after drop (e.g. get*) + $sv unsafe fn drop( + handle: $crate::wdf_umdf_sys::WDFOBJECT, + ) -> ::std::result::Result<(), $crate::WdfError> { + let context = $crate::WdfObjectGetTypedContextWorker( + handle, + [<_WDF_ $context_type _TYPE_INFO>].cell.get(), + )? as *mut []; + + // drop the memory + ::std::ptr::drop_in_place(context); + + Ok(()) + } + + /// Borrow the context immutably + /// Function returns with error and won't call cb if it failed to lock + /// + /// SAFETY: + /// - Must have initialized WdfObject first + /// - Data must not have been dropped + /// - Object must not have been destroyed + $sv unsafe fn get( + handle: *mut $crate::wdf_umdf_sys::WDFDEVICE__, + cb: F + ) -> ::std::result::Result<(), $crate::WdfError> + where + F: ::std::ops::FnOnce(&$context_type) + { + let context = unsafe { + $crate::WdfObjectGetTypedContextWorker(handle as *mut _, + // SAFETY: Reading is always fine, since user cannot obtain mutable reference + (&*[<_WDF_ $context_type _TYPE_INFO>].cell.get()).UniqueType + )? + } as *mut []; + + let context = &*context; + + let context = match &context.0 { + ArcPointer::Strong(a) => a.clone(), + ArcPointer::Weak(a) => a.upgrade().ok_or($crate::WdfError::UpgradeFailed)?.clone(), + }; + + let guard = context.read().map_err(|_| $crate::WdfError::LockFailed)?; + + cb(&*guard); + + Ok(()) + } + + /// Borrow the context mutably + /// Function returns with error and won't call cb if it failed to lock + /// + /// SAFETY: + /// - Must have initialized WdfObject first + /// - Data must not have been dropped + /// - Object must not have been destroyed + $sv unsafe fn get_mut( + handle: *mut $crate::wdf_umdf_sys::WDFDEVICE__, + cb: F + ) -> ::std::result::Result<(), $crate::WdfError> + where + F: ::std::ops::FnOnce(&mut $context_type) + { + let context = unsafe { + $crate::WdfObjectGetTypedContextWorker(handle as *mut _, + // SAFETY: Reading is always fine, since user cannot obtain mutable reference + (&*[<_WDF_ $context_type _TYPE_INFO>].cell.get()).UniqueType + )? + } as *mut []; + + let context = &*context; + + let context = match &context.0 { + ArcPointer::Strong(a) => a.clone(), + ArcPointer::Weak(a) => a.upgrade().ok_or($crate::WdfError::UpgradeFailed)?.clone(), + }; + + let mut guard = context.write().map_err(|_| $crate::WdfError::LockFailed)?; + + cb(&mut *guard); + + Ok(()) + } + + /// Borrow the context immutably + /// Function returns with error and won't call cb if it failed to lock + /// + /// SAFETY: + /// - Must have initialized WdfObject first + /// - Data must not have been dropped + /// - Object must not have been destroyed + $sv unsafe fn try_get( + handle: *mut $crate::wdf_umdf_sys::WDFDEVICE__, + cb: F + ) -> ::std::result::Result<(), $crate::WdfError> + where + F: ::std::ops::FnOnce(&$context_type) + { + let context = unsafe { + $crate::WdfObjectGetTypedContextWorker(handle as *mut _, + // SAFETY: Reading is always fine, since user cannot obtain mutable reference + (&*[<_WDF_ $context_type _TYPE_INFO>].cell.get()).UniqueType + )? + } as *mut []; + + let context = &*context; + + let context = match &context.0 { + ArcPointer::Strong(a) => a.clone(), + ArcPointer::Weak(a) => a.upgrade().ok_or($crate::WdfError::UpgradeFailed)?.clone(), + }; + + let guard = context.try_read().map_err(|_| $crate::WdfError::LockFailed)?; + + cb(&*guard); + + Ok(()) + } + + /// Try to borrow the context mutably. Immediately returns if it's locked + /// Function returns with error and won't call cb if it failed to lock + /// + /// SAFETY: + /// - Must have initialized WdfObject first + /// - Data must not have been dropped + /// - Object must not have been destroyed + $sv unsafe fn try_get_mut( + handle: *mut $crate::wdf_umdf_sys::WDFDEVICE__, + cb: F + ) -> ::std::result::Result<(), $crate::WdfError> + where + F: ::std::ops::FnOnce(&mut $context_type) + { + let context = unsafe { + $crate::WdfObjectGetTypedContextWorker(handle as *mut _, + // SAFETY: Reading is always fine, since user cannot obtain mutable reference + (&*[<_WDF_ $context_type _TYPE_INFO>].cell.get()).UniqueType + )? + } as *mut []; + + let context = &*context; + + let context = match &context.0 { + ArcPointer::Strong(a) => a.clone(), + ArcPointer::Weak(a) => a.upgrade().ok_or($crate::WdfError::UpgradeFailed)?.clone(), + }; + + let mut guard = context.try_write().map_err(|_| $crate::WdfError::LockFailed)?; + + cb(&mut *guard); + + Ok(()) + } + + // SAFETY: + // - No other mutable refs must exist to target type + // - Underlying memory must remain immutable and unchanged until reference is dropped + $sv unsafe fn get_type_info() -> &'static $crate::wdf_umdf_sys::_WDF_OBJECT_CONTEXT_TYPE_INFO { + unsafe { &*[<_WDF_ $context_type _TYPE_INFO>].cell.get() } + } + } + } + } + }; +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfDriverCreate( + // in + DriverObject: PDRIVER_OBJECT, + // in + RegistryPath: PCUNICODE_STRING, + // in, optional + DriverAttributes: Option, + // in + DriverConfig: PWDF_DRIVER_CONFIG, + // out, optional + Driver: Option<&mut WDFDRIVER>, +) -> Result { + WdfCall! { + WdfDriverCreate( + DriverObject, + RegistryPath, + DriverAttributes.unwrap_or(WDF_NO_OBJECT_ATTRIBUTES!()), + DriverConfig, + Driver + .map(std::ptr::from_mut) + .unwrap_or(WDF_NO_HANDLE!()) + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfDeviceCreate( + // in, out + DeviceInit: &mut PWDFDEVICE_INIT, + // in, optional + DeviceAttributes: Option<&mut WDF_OBJECT_ATTRIBUTES>, + // out + Device: &mut WDFDEVICE, +) -> Result { + WdfCall! { + WdfDeviceCreate( + DeviceInit, + DeviceAttributes.map_or(WDF_NO_OBJECT_ATTRIBUTES!(), std::ptr::from_mut), + Device + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfDeviceInitSetPnpPowerEventCallbacks( + // in + DeviceInit: PWDFDEVICE_INIT, + // in + PnpPowerEventCallbacks: *mut _WDF_PNPPOWER_EVENT_CALLBACKS, +) -> Result<(), WdfError> { + WdfCall! { + WdfDeviceInitSetPnpPowerEventCallbacks( + DeviceInit, + PnpPowerEventCallbacks + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfObjectGetTypedContextWorker( + // in + Handle: WDFOBJECT, + // in + TypeInfo: PCWDF_OBJECT_CONTEXT_TYPE_INFO, +) -> Result<*mut c_void, WdfError> { + WdfCall! { + WdfObjectGetTypedContextWorker( + Handle, + TypeInfo + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfObjectDelete( + // in + Object: WDFOBJECT, +) -> Result<(), WdfError> { + WdfCall! { + WdfObjectDelete( + Object + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfDeviceSetFailed( + // in + Device: WDFDEVICE, + // in + FailedAction: WDF_DEVICE_FAILED_ACTION, +) -> Result<(), WdfError> { + WdfCall! { + WdfDeviceSetFailed( + Device, + FailedAction + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfDeviceAllocAndQueryPropertyEx( + // in + Device: WDFDEVICE, + // in + DeviceProperty: &mut _WDF_DEVICE_PROPERTY_DATA, + // in + PoolType: POOL_TYPE, + // in, optional + PropertyMemoryAttributes: PWDF_OBJECT_ATTRIBUTES, + // out + PropertyMemory: &mut WDFMEMORY, + // out + Type: &mut DEVPROPTYPE, +) -> Result { + WdfCall! { + WdfDeviceAllocAndQueryPropertyEx( + Device, + DeviceProperty, + PoolType, + PropertyMemoryAttributes, + PropertyMemory, + Type + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfMemoryGetBuffer( + // in + Memory: WDFMEMORY, + // out, optional + BufferSize: Option<&mut usize>, +) -> Result<*mut c_void, WdfError> { + WdfCall! { + WdfMemoryGetBuffer( + Memory, + BufferSize.map_or(std::ptr::null_mut(), std::ptr::from_mut) + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfDeviceCreateDeviceInterface( + Device: WDFDEVICE, + InterfaceClassGUID: *const GUID, + ReferenceString: PCUNICODE_STRING, +) -> Result { + WdfCall! { + WdfDeviceCreateDeviceInterface( + Device, + InterfaceClassGUID, + ReferenceString + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfRequestRetrieveInputBuffer( + Request: WDFREQUEST, + MinimumRequiredLength: usize, + Buffer: *mut PVOID, + Length: *mut usize, +) -> Result { + WdfCall! { + WdfRequestRetrieveInputBuffer( + Request, + MinimumRequiredLength, + Buffer, + Length + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfRequestRetrieveOutputBuffer( + Request: WDFREQUEST, + MinimumRequiredSize: usize, + Buffer: *mut PVOID, + Length: *mut usize, +) -> Result { + WdfCall! { + WdfRequestRetrieveOutputBuffer( + Request, + MinimumRequiredSize, + Buffer, + Length + ) + } +} + +/// # Safety +/// +/// None. User is responsible for safety. +pub unsafe fn WdfRequestCompleteWithInformation( + Request: WDFREQUEST, + Status: NTSTATUS, + Information: ULONG_PTR, +) -> Result<(), WdfError> { + WdfCall! { + WdfRequestCompleteWithInformation( + Request, + Status, + Information + ) + } +}