# CVE-2026-96992 — pci.sys patch diff

`pci.sys` 10.0.26100.9818 -> 10.0.26100.9974 (ghidriff).

## `PciBus_Remove`  (modified)

```diff
--- PciBus_Remove
+++ PciBus_Remove
@@ -1,111 +1,332 @@
 

 /* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

 

 void PciBus_Remove(longlong param_1,undefined8 param_2,int *param_3,undefined8 param_4)

 

 {

-  code *pcVar1;

-  longlong lVar2;

-  char *in_RAX;

-  longlong lVar3;

-  longlong unaff_RBP;

-  longlong *unaff_RSI;

-  longlong unaff_RDI;

-  undefined8 uVar4;

-  undefined4 uVar5;

-  undefined8 uVar6;

-  undefined4 unaff_R12D;

-  longlong unaff_R14;

-  longlong unaff_R15;

-  bool bVar7;

+  longlong *plVar1;

+  undefined4 uVar2;

+  longlong *plVar3;

+  int *piVar4;

+  code *pcVar5;

+  undefined4 *puVar6;

+  void *pvVar7;

+  int iVar8;

+  ulonglong uVar9;

+  longlong lVar10;

+  undefined8 uVar11;

+  undefined8 uVar12;

+  undefined1 *puVar13;

+  undefined1 *puVar14;

+  undefined1 *puVar15;

+  int *piVar16;

+  char *pcVar17;

+  undefined8 uVar18;

+  undefined *unaff_R13;

+  bool bVar19;

+  undefined1 auStackY_58 [8];

+  undefined1 auStackY_50 [24];

   

-  *in_RAX = *in_RAX + (char)in_RAX;

-  bVar7 = *in_RAX == '\0';

-  do {

-    if (bVar7) {

-      lVar3 = *(longlong *)(*(longlong *)(unaff_RDI + 0x88) + 0x20);

-      pcVar1 = *(code **)(lVar3 + 0x50);

-      if (pcVar1 != (code *)0x0) {

-        (*pcVar1)(*(undefined8 *)(lVar3 + 8));

+  puVar13 = auStackY_58;

+  puVar14 = auStackY_58;

+  puVar15 = auStackY_58;

+  piVar16 = param_3;

+  if (*(longlong **)(param_3 + 0xf2) != (longlong *)0x0) {

+    PciDestroyResourceHint(*(longlong **)(param_3 + 0xf2));

+    param_3[0xf2] = 0;

+    param_3[0xf3] = 0;

+  }

+  if ((param_3[0x130] & 1U) != 0) {

+    PciFpbFdoDestroyNode((longlong)(param_3 + 0x100));

+  }

+  uVar9 = Feature_Servicing_PCI_SplitPowerManagementThreads__private_IsEnabledDeviceUsageNoInline();

+  bVar19 = false;

+  if ((int)uVar9 == 0) {

+    KeAcquireSpinLockRaiseToDpc(*(longlong *)(param_3 + 0x22) + 0x4e8);

+    if (((uint)param_3[0xb8] >> 0x1c & 1) == 0) {

+LAB_0:

+      KeReleaseSpinLock(*(longlong *)(param_3 + 0x22) + 0x4e8);

+      goto LAB_1;

+    }

+    LOCK();

+    *(ulonglong *)(param_3 + 0xb8) = *(ulonglong *)(param_3 + 0xb8) & 0xffffffffefffffff;

+    UNLOCK();

+    plVar1 = (longlong *)(param_3 + 0x84);

+    lVar10 = *plVar1;

+    if ((*(longlong **)(lVar10 + 8) == plVar1) &&

+       (plVar3 = *(longlong **)(param_3 + 0x86), (longlong *)*plVar3 == plVar1)) {

+      *plVar3 = lVar10;

+      *(longlong **)(lVar10 + 8) = plVar3;

+      piVar16 = (int *)0x20;

+      IoReleaseRemoveLockEx(param_3 + 8,0x20507757);

+      goto LAB_0;

+    }

+    pcVar5 = (code *)swi(0x29);

+    (*pcVar5)(3);

+    puVar13 = auStackY_50;

+LAB_2:

+    *(undefined8 *)(puVar13 + -8) = 0x1400244ff;

+    KeReleaseSpinLock();

+LAB_3:

+    puVar14 = puVar13;

+    if (param_3[0xa0] != 0) {

+      *(undefined8 *)(puVar13 + -8) = 0x14002451b;

+      KeEnterCriticalRegion();

+      *(undefined8 *)(puVar13 + 0x20) = 0;

+      *(undefined8 *)(puVar13 + -8) = 0x140024537;

+      KeWaitForSingleObject(unaff_R13);

+      *(undefined8 *)(puVar13 + 0x20) = 0;

+      *(undefined8 *)(puVar13 + -8) = 0x14002455a;

+      KeWaitForSingleObject(param_3 + 0x2a);

+      for (lVar10 = *(longlong *)(param_3 + 0x26); lVar10 != 0;

+          lVar10 = *(longlong *)(lVar10 + 0x98)) {

+        if ((*(uint *)(lVar10 + 0x698) >> 8 & 1) != 0) goto LAB_4;

       }

-    }

-    unaff_RDI = PciNextBusInSegment(unaff_RDI);

-    while (unaff_RDI == 0) {

-      unaff_RSI = (longlong *)*unaff_RSI;

-      if (unaff_RSI == (longlong *)0x0) {

-        PoSetHiberRange(0,unaff_R12D,&PciSkipWppTracing,1,0x70696350);

-        if (PciKsrData != 0) {

-          PoSetHiberRange(0,unaff_R12D,PciKsrData,(ulonglong)PciKsrDataCount * 0x3ec,0x70696350);

-        }

-        return;

+      goto LAB_5;

+    }

+  }

+  else {

+LAB_1:

+    uVar18 = 0;

+    PciHibernateInfoUpdate((longlong)param_3,'\0',piVar16,param_4);

+    if ((((*(longlong *)(param_3 + 0x24) != 0) &&

+         (piVar4 = *(int **)(*(longlong *)(param_3 + 0x24) + 0x3f0), piVar4 != (int *)0x0)) &&

+        ((*piVar4 - 4U & 0xfffffffd) == 0)) && (*(longlong *)(piVar4 + 0x262) != 0)) {

+      PciBus_DisarmForWake((longlong)param_3,uVar18,piVar16);

+    }

+    PciBus_RunDownWake((longlong)param_3,uVar18,piVar16);

+    uVar9 = Feature_Servicing_PCI_SplitPowerManagementThreads__private_IsEnabledDeviceUsageNoInline

+                      ();

+    unaff_R13 = &PciGlobalLock;

+    if ((int)uVar9 == 0) {

+      puVar15 = auStackY_58;

+      if ((*(byte *)(param_3 + 0xb8) & 0x40) == 0) goto LAB_6;

+      KeAcquireSpinLockRaiseToDpc(param_3 + 0x90);

+      puVar13 = auStackY_58;

+      if ((param_3[0xb8] & 0x400U) != 0) goto LAB_2;

+      LOCK();

+      *(ulonglong *)(param_3 + 0xb8) = *(ulonglong *)(param_3 + 0xb8) | 0x400;

+      UNLOCK();

+      KeReleaseSpinLock(param_3 + 0x90);

+      PciBus_PowerReference((longlong)param_3,8);

+      PciBus_RetireChildPowerIrps((longlong)param_3);

+      puVar13 = auStackY_58;

+      goto LAB_3;

+    }

+    PciBus_RundownPmeWorkItems((longlong)param_3,uVar18,piVar16);

+    if ((*(byte *)(param_3 + 0xb8) & 0x40) == 0) goto LAB_6;

+    KeAcquireSpinLockRaiseToDpc(param_3 + 0x90);

+    if (((((uint)param_3[0xb8] >> 10 & 1) != 0) &&

+        ((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED)) &&

+       (PciSkipWppTracing == '\0')) {

+      uVar18 = imp_WppRecorderLogGetDefault(WPP_GLOBAL_Control);

+      WPP_RECORDER_SF_Dq(uVar18,2,2,0xb,&WPP_eaa00b83c4203b3b7be6bf826cf9ee70_Traceguids);

+    }

+    KeReleaseSpinLock(param_3 + 0x90);

+    if (param_3[0xa0] != 0) {

+      KeEnterCriticalRegion();

+      KeWaitForSingleObject(&PciGlobalLock);

+      KeWaitForSingleObject(param_3 + 0x2a);

+      for (lVar10 = *(longlong *)(param_3 + 0x26); puVar14 = auStackY_58, lVar10 != 0;

+          lVar10 = *(longlong *)(lVar10 + 0x98)) {

+        if ((*(uint *)(lVar10 + 0x698) >> 8 & 1) != 0) goto LAB_4;

       }

-      PoSetHiberRange(0,unaff_R12D,unaff_RSI,0x58,0x73696350);

-      unaff_RDI = unaff_RSI[2];

-    }

-    PoSetHiberRange(0,unaff_R12D,unaff_RDI,0x768,0x62696350);

-    if (*(longlong *)(unaff_RDI + 0x90) == 0) {

-      uVar4 = *(undefined8 *)(unaff_RDI + 0x88);

-      uVar6 = 0xca8;

-LAB_0:

-      PoSetHiberRange(0,unaff_R12D,uVar4,uVar6,0x62696350);

-    }

-    else {

-      PoSetHiberRange(0,unaff_R12D,*(longlong *)(unaff_RDI + 0x90),0x458,0x62696350);

-      lVar3 = *(longlong *)(*(longlong *)(unaff_RDI + 0x90) + 0x3f0);

-      if ((lVar3 != 0) &&

-         (PoSetHiberRange(0,unaff_R12D,lVar3,0xb48,0x62696350),

-         **(int **)(*(longlong *)(unaff_RDI + 0x90) + 0x3f0) == 5)) {

-        uVar4 = *(undefined8 *)(lVar3 + 0x940);

-        uVar6 = 0x20;

-        goto LAB_0;

-      }

-    }

-    for (lVar3 = *(longlong *)(unaff_RDI + 0x98); lVar3 != 0; lVar3 = *(longlong *)(lVar3 + 0x98)) {

-      PoSetHiberRange(0,unaff_R12D,lVar3,0x910);

-      lVar2 = *(longlong *)(lVar3 + 0x88);

-      if (unaff_R14 != lVar2) {

-        PoSetHiberRange(0,unaff_R12D,lVar2,0xca8);

-        lVar2 = *(longlong *)(lVar3 + 0x88);

-        unaff_R14 = lVar2;

-      }

-      if (unaff_R15 != *(longlong *)(lVar2 + 0x20)) {

-        PoSetHiberRange(0,unaff_R12D,*(longlong *)(lVar2 + 0x20),0x58);

-        unaff_R15 = *(longlong *)(*(longlong *)(lVar3 + 0x88) + 0x20);

-      }

-      if (unaff_RBP != *(longlong *)(lVar3 + 0x6b8)) {

-        PoSetHiberRange(0,unaff_R12D,*(longlong *)(lVar3 + 0x6b8),0x18);

-        unaff_RBP = *(longlong *)(lVar3 + 0x6b8);

-      }

-      if (*(longlong *)(lVar3 + 0xd8) == 0) {

-        lVar2 = *(longlong *)(lVar3 + 0xd0);

-        if (lVar2 != 0) {

-          uVar5 = 0x98;

-          goto LAB_1;

-        }

-      }

-      else {

-        PoSetHiberRange(0,unaff_R12D,*(longlong *)(lVar3 + 0xd8),0xa10);

-        lVar2 = *(longlong *)(*(longlong *)(lVar3 + 0xd8) + 0x48);

-        if (lVar2 != 0) {

-          PoSetHiberRange(0,unaff_R12D,lVar2,0x48);

-        }

-        lVar2 = *(longlong *)(*(longlong *)(lVar3 + 0xd8) + 0x978);

-        if (lVar2 != 0) {

-          PoSetHiberRange(0,unaff_R12D,lVar2,

-                          ((*(ushort *)(*(longlong *)(lVar3 + 0xd8) + 0x96e) & 0x7ff) + 1) * 2);

-        }

-        lVar2 = *(longlong *)(*(longlong *)(lVar3 + 0xd8) + 0x9e0);

-        if (lVar2 != 0) {

-          uVar5 = *(undefined4 *)(*(longlong *)(lVar3 + 0xd8) + 0x9dc);

-LAB_1:

-          PoSetHiberRange(0,unaff_R12D,lVar2,uVar5);

-        }

-      }

-      if ((*(uint *)(lVar3 + 0x7ac) & 1) != 0) {

-        PciFpbPdoMarkHiberPhase();

-      }

-    }

-    bVar7 = *(longlong *)(unaff_RDI + 0x90) == 0;

-  } while( true );

+      goto LAB_5;

+    }

+  }

+LAB_7:

+  pcVar5 = *(code **)(param_3 + 0xe8);

+  puVar15 = puVar14;

+  if (pcVar5 != (code *)0x0) {

+    uVar18 = *(undefined8 *)(param_3 + 0xe2);

+    *(undefined8 *)(puVar14 + -8) = 0x14002470a;

+    (*pcVar5)(uVar18);

+  }

+LAB_6:

+  pcVar5 = *(code **)(param_3 + 0xe6);

+  if (pcVar5 != (code *)0x0) {

+    uVar18 = *(undefined8 *)(param_3 + 0xe2);

+    *(undefined8 *)(puVar15 + -8) = 0x140024722;

+    (*pcVar5)(uVar18);

+  }

+  *(undefined8 *)(puVar15 + -8) = 0x140024729;

+  KeEnterCriticalRegion();

+  *(undefined8 *)(puVar15 + 0x20) = 0;

+  *(undefined8 *)(puVar15 + -8) = 0x140024745;

+  KeWaitForSingleObject(unaff_R13);

+  *(undefined8 *)(puVar15 + 0x20) = 0;

+  uVar18 = 0;

+  *(undefined8 *)(puVar15 + -8) = 0x140024768;

+  KeWaitForSingleObject(param_3 + 0x2a);

+  while (puVar6 = *(undefined4 **)(param_3 + 0x26), puVar6 != (undefined4 *)0x0) {

+    *(undefined4 *)(puVar15 + 0x20) = 0x20;

+    uVar18 = 1;

+    *(undefined8 *)(puVar15 + -8) = 0x140024797;

+    IoAcquireRemoveLockEx(puVar6 + 0x2c,0,"");

+    *(undefined8 *)(puVar15 + -8) = 0x1400247ac;

+    IoReleaseRemoveLockAndWaitEx(puVar6 + 0x2c);

+    *(undefined8 *)(puVar15 + -8) = 0x1400247b9;

+    PciDestroyDevice(puVar6);

+  }

+  *(undefined8 *)(puVar15 + -8) = 0x1400247d4;

+  KeSetEvent(param_3 + 0x2a,0);

+  uVar12 = 0;

+  *(undefined8 *)(puVar15 + -8) = 0x1400247e8;

+  KeSetEvent(unaff_R13,0);

+  *(undefined8 *)(puVar15 + -8) = 0x1400247f4;

+  KeLeaveCriticalRegion();

+  if (*(longlong *)(param_3 + 0xf4) != 0) {

+    uVar11 = *(undefined8 *)(*(longlong *)(param_3 + 0xf4) + 0x18);

+    *(undefined8 *)(puVar15 + -8) = 0x140024815;

+    ObfDereferenceObject(uVar11);

+    uVar11 = *(undefined8 *)(param_3 + 0xf4);

+    *(undefined8 *)(puVar15 + -8) = 0x14002482a;

+    ExFreePoolWithTag(uVar11,0x42696350);

+    param_3[0xf4] = 0;

+    param_3[0xf5] = 0;

+  }

+  uVar11 = 2;

+  *(undefined8 *)(puVar15 + -8) = 0x140024845;

+  piVar16 = param_3;

+  iVar8 = PciIsInTransitionToState((longlong)param_3,2);

+  if ((char)iVar8 == '\0') {

+    *(undefined8 *)(puVar15 + -8) = 0x14002484e;

+    PciBeginStateTransition(piVar16,uVar11,uVar12,uVar18);

+  }

+  *(undefined8 *)(puVar15 + -8) = 0x140024858;

+  PciCommitStateTransition(param_3,2);

+  *(undefined8 *)(puVar15 + -8) = 0x14002485d;

+  uVar9 = Feature_3167895864__private_IsEnabledDeviceUsageNoInline();

+  if ((int)uVar9 == 0) {

+    *(undefined8 *)(puVar15 + -8) = 0x140024869;

+    PciRemoveBusFromTree((longlong)param_3);

+  }

+  *(undefined4 *)(puVar15 + 0x20) = 0x20;

+  *(undefined8 *)(puVar15 + -8) = 0x1400248b0;

+  IoAcquireRemoveLockEx(param_3 + 8,0,"");

+  if ((*(longlong *)(param_3 + 0x24) != 0) &&

+     (piVar16 = *(int **)(*(longlong *)(param_3 + 0x24) + 0x3f0), piVar16 != (int *)0x0)) {

+    *(undefined8 *)(puVar15 + -8) = 0x1400248d2;

+    ExpressBridgeDisableInterrupts(piVar16);

+    piVar16 = *(int **)(*(longlong *)(param_3 + 0x24) + 0x3f0);

+    *(undefined8 *)(puVar15 + -8) = 0x1400248e5;

+    ExpressBridgeDisconnectInterrupt(piVar16);

+    if (*(int *)(*(longlong *)(*(longlong *)(param_3 + 0x24) + 0x3f0) + 0x84) == 1) {

+      uVar2 = *(undefined4 *)(*(longlong *)(*(longlong *)(param_3 + 0x24) + 0x3f0) + 0xb4);

+      *(undefined8 *)(puVar15 + -8) = 0x140024909;

+      WheaRemoveErrorSource(uVar2);

+    }

+  }

+  *(undefined8 *)(puVar15 + -8) = 0x140024915;

+  KeEnterCriticalRegion();

+  *(undefined8 *)(puVar15 + 0x20) = 0;

+  uVar18 = 0;

+  *(undefined8 *)(puVar15 + -8) = 0x140024938;

+  KeWaitForSingleObject(param_3 + 0x14a,0,0);

+  if (*(longlong *)(param_3 + 0x154) != 0) {

+    *(undefined8 *)(puVar15 + -8) = 0x140024950;

+    Usb4CleanUpPoFxRelation((longlong)param_3,'\x01');

+  }

+  *(undefined8 *)(puVar15 + -8) = 0x14002495f;

+  KeSetEvent(param_3 + 0x14a,0,0);

+  *(undefined8 *)(puVar15 + -8) = 0x14002496b;

+  KeLeaveCriticalRegion();

+  if (*(longlong *)(param_3 + 0x156) != 0) {

+    *(undefined8 *)(puVar15 + -8) = 0x140024981;

+    Usb4UnregisterDriverCallback((longlong)param_3);

+  }

+  lVar10 = *(longlong *)(param_3 + 0x24);

+  if ((lVar10 != 0) && (*(longlong *)(lVar10 + 0x3f0) != 0)) {

+    *(undefined8 *)(puVar15 + -8) = 0x14002499b;

+    PciThermalUnregisterDeviceInterface(lVar10);

+  }

+  pcVar17 = (char *)0x20;

+  uVar12 = 0;

+  *(undefined8 *)(puVar15 + -8) = 0x1400249ab;

+  IoReleaseRemoveLockAndWaitEx(param_3 + 8);

+  *(undefined8 *)(puVar15 + -8) = 0x1400249b5;

+  uVar9 = Feature_3167895864__private_IsEnabledDeviceUsageNoInline();

+  if ((int)uVar9 != 0) {

+    *(undefined8 *)(puVar15 + -8) = 0x1400249c1;

+    PciRemoveBusFromTree((longlong)param_3);

+  }

+  *(undefined8 *)(puVar15 + -8) = 0x1400249c9;

+  BusPowerUnregisterPep((longlong)param_3);

+  *(undefined8 *)(puVar15 + -8) = 0x1400249d7;

+  RtlFreeUnicodeString(param_3 + 0x140);

+  *(undefined8 *)(puVar15 + -8) = 0x1400249ea;

+  RtlFreeUnicodeString(param_3 + 0x146);

+  *(undefined8 *)(puVar15 + -8) = 0x1400249f7;

+  PciDestroyArbiters((longlong)param_3);

+  if (*(longlong *)(param_3 + 0x24) == 0) {

+    *(undefined8 *)(puVar15 + -8) = 0x140024a5f;

+    PciDestroyRootBus((longlong)param_3);

+  }

+  else {

+    if (*(longlong *)(*(longlong *)(param_3 + 0x24) + 0x3f0) != 0) {

+      *(undefined8 *)(puVar15 + -8) = 0x140024a13;

+      KeFlushQueuedDpcs();

+      piVar16 = *(int **)(*(longlong *)(param_3 + 0x24) + 0x3f0);

+      *(undefined8 *)(puVar15 + -8) = 0x140024a2b;

+      ExpressDestroyVirtualBridge(piVar16,uVar12,pcVar17,uVar18);

+      *(undefined8 *)(*(longlong *)(param_3 + 0x24) + 0x3f0) = 0;

+    }

+    uVar18 = *(undefined8 *)(param_3 + 0x24);

+    *(undefined8 *)(puVar15 + -8) = 0x140024a49;

+    ExFreePoolWithTag(uVar18,0x42696350);

+    param_3[0x24] = 0;

+    param_3[0x25] = 0;

+  }

+  if (*(longlong *)(param_3 + 0xdc) != 0) {

+    *(undefined8 *)(puVar15 + -8) = 0x140024a79;

+    imp_WppRecorderLogDelete(WPP_GLOBAL_Control);

+  }

+  if (*(longlong *)(param_3 + 0xde) != 0) {

+    *(undefined8 *)(puVar15 + -8) = 0x140024a98;

+    imp_WppRecorderLogDelete(WPP_GLOBAL_Control);

+  }

+  uVar18 = *(undefined8 *)(param_3 + 0x44);

+  *(undefined8 *)(puVar15 + -8) = 0x140024aae;

+  IoDetachDevice(uVar18);

+  uVar12 = *(undefined8 *)(param_3 + 0x10);

+  *(undefined8 *)(puVar15 + -8) = 0x140024abe;

+  IoFreeWorkItem(uVar12);

+  uVar12 = *(undefined8 *)(param_3 + 0x42);

+  param_3[0x10] = 0;

+  param_3[0x11] = 0;

+  *(undefined8 *)(puVar15 + -8) = 0x140024ad5;

+  IoDeleteDevice(uVar12);

+  LOCK();

+  iVar8 = PciCreateControlDeviceCount + -1;

+  UNLOCK();

+  bVar19 = PciCreateControlDeviceCount == 1;

+  PciCreateControlDeviceCount = iVar8;

+  if (bVar19) {

+    pvVar7 = *(void **)(PciControlDevice + 0x40);

+    *(undefined8 *)(puVar15 + -8) = 0x140024afa;

+    PciCleanupCtrlDevExt(pvVar7);

+    *(undefined8 *)(puVar15 + -8) = 0x140024b08;

+    IoDeleteDevice(PciControlDevice);

+    PciControlDevice = 0;

+  }

+  *(char *)(param_1 + 0x43) = *(char *)(param_1 + 0x43) + '\x01';

+  *(longlong *)(param_1 + 0xb8) = *(longlong *)(param_1 + 0xb8) + 0x48;

+  *(undefined4 *)(param_1 + 0x30) = 0;

+  *(undefined8 *)(puVar15 + -8) = 0x140024b31;

+  IofCallDriver(uVar18,param_1);

+  return;

+LAB_4:

+  bVar19 = true;

+  puVar14 = puVar13;

+LAB_5:

+  *(undefined8 *)(puVar14 + -8) = 0x1400246c7;

+  KeSetEvent(param_3 + 0x2a);

+  *(undefined8 *)(puVar14 + -8) = 0x1400246db;

+  KeSetEvent(unaff_R13);

+  *(undefined8 *)(puVar14 + -8) = 0x1400246e7;

+  KeLeaveCriticalRegion();

+  puVar15 = puVar14;

+  if (bVar19) goto LAB_6;

+  goto LAB_7;

 }
```

## `ExpressPcProcessWorkQueueItem`  (modified)

```diff
--- ExpressPcProcessWorkQueueItem
+++ ExpressPcProcessWorkQueueItem
@@ -1,21 +1,231 @@
 

-char ExpressPcProcessWorkQueueItem(undefined8 param_1,longlong param_2)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+

+void ExpressPcProcessWorkQueueItem(undefined8 param_1,longlong param_2)

 

 {

-  char unaff_BL;

-  longlong unaff_RBP;

-  longlong unaff_RDI;

-  uint *in_R8;

+  byte *pbVar1;

+  int *piVar2;

+  int *piVar3;

+  longlong lVar4;

+  longlong lVar5;

+  longlong lVar6;

+  longlong lVar7;

+  bool bVar8;

+  int iVar9;

+  ulonglong uVar10;

+  ushort *puVar11;

+  undefined8 uVar12;

+  int *piVar13;

+  int *piVar14;

+  uint uVar15;

+  longlong *plVar16;

+  int *piVar17;

+  ulonglong *puVar18;

+  ulonglong *puVar19;

+  ulonglong *puVar20;

+  undefined1 auStackY_198 [32];

+  undefined8 in_stack_fffffffffffffe98;

+  undefined8 in_stack_fffffffffffffea8;

+  undefined1 uStack_136;

+  undefined4 local_134;

+  longlong local_108;

+  undefined4 local_100;

+  undefined4 local_f8;

+  int local_f4;

+  int local_f0;

+  uint local_ec;

+  ushort local_e6;

+  undefined4 local_e4;

+  undefined1 local_df;

+  ushort local_d8;

+  uint local_d4;

+  ulonglong *local_d0;

+  undefined1 local_c8 [8];

+  longlong local_c0 [5];

+  byte local_98;

+  ulonglong local_88 [5];

+  int local_5c;

+  int local_58;

+  int local_54 [7];

+  ulonglong local_38;

   

-  ExpressBridgeHotPlugInterruptRoutine

-            (unaff_RDI,param_2,in_R8,(undefined1 *)(unaff_RBP + 0x38),

-             (undefined1 *)(ulonglong)((int)unaff_RDI + 0x9a0));

-  if ((*(char *)(unaff_RBP + 0x28) != unaff_BL) || (*(char *)(unaff_RBP + 0x30) != unaff_BL)) {

-    KeInsertQueueDpc(*(longlong *)(**(longlong **)(unaff_RDI + 8) + 0x108) + 200,0);

-  }

-  if ((*(char *)(unaff_RBP + 0x38) != unaff_BL) || (*(char *)(unaff_RBP + -0x10) != unaff_BL)) {

-    unaff_BL = '\x01';

-  }

-  return unaff_BL;

+  local_38 = __security_cookie ^ (ulonglong)auStackY_198;

+  memset(local_88,0,0x4c);

+  piVar3 = *(int **)(param_2 + 0x18);

+  puVar19 = (ulonglong *)0x0;

+  local_134 = 1;

+  puVar20 = (ulonglong *)0x0;

+  uVar15 = 0;

+  lVar4 = **(longlong **)(piVar3 + 2);

+  memset(&local_108,0,0x80);

+  lVar5 = *(longlong *)(*(longlong *)(param_2 + 0x20) + 0xd8);

+  PciReadDeviceConfig(*(longlong *)(lVar5 + 8),(byte *)(lVar5 + 0x74),

+                      (uint)*(ushort *)(lVar5 + 0x70),0x2c);

+  puVar18 = puVar19;

+  if (((char)piVar3[0x260] != '\0') &&

+     (((*(uint *)(lVar5 + 0x78) & 0x20) != 0 ||

+      (uVar10 = ExpressPcIsDevicePresentInSlot((longlong)piVar3), (char)uVar10 == '\0')))) {

+    bVar8 = PciGeteDpcHotplugSetting();

+    puVar18 = (ulonglong *)(ulonglong)bVar8;

+    if (bVar8) {

+      IoInvalidateDeviceRelations(*(undefined8 *)(lVar4 + 0x118),0);

+    }

+  }

+  uStack_136 = 2;

+  DbgPrint("%s: enter... ExpressBridge: 0x%p\n","ExpressPcProcessWorkQueueItem",piVar3);

+  lVar6 = *(longlong *)(*(longlong *)(param_2 + 0x20) + 0xd8);

+  pbVar1 = (byte *)(lVar6 + 0xc0);

+  PciReadDeviceConfig(*(longlong *)(lVar6 + 8),pbVar1,(uint)*(ushort *)(lVar6 + 0x72),0xc);

+  lVar7 = *(longlong *)(*(longlong *)(param_2 + 0x20) + 0xd8);

+  puVar11 = (ushort *)(lVar6 + 200);

+  PciReadDeviceConfig(*(longlong *)(lVar7 + 8),(byte *)puVar11,*(ushort *)(lVar7 + 0x72) + 8,2);

+  if ((*(byte *)puVar11 & 1) == 0) {

+LAB_0:

+    puVar19 = (ulonglong *)0x0;

+  }

+  else {

+    uVar10 = ExpressPcGetTriggerReason((longlong)pbVar1);

+    iVar9 = (int)uVar10;

+    DbgPrint("%s: trigger reason 0x%x...\n","ExpressPcProcessWorkQueueItem",uVar10 & 0xffffffff);

+    uVar12 = PciBusWaitForDataLinkSettle(lVar4,0);

+    if ((char)uVar12 != '\0') {

+      DbgPrint("%s: tear down complete\n","ExpressPcProcessWorkQueueItem");

+      if (*piVar3 == 4) {

+        uVar10 = ExpressPcWaitForRootPort(*(longlong *)(param_2 + 0x20),(longlong)pbVar1);

+        if ((char)uVar10 == '\0') {

+          uStack_136 = 4;

+          goto LAB_1;

+        }

+        if (((*piVar3 == 4) &&

+            ((*(ulonglong *)(**(longlong **)(piVar3 + 2) + 0x2e0) >> 0x2c & 1) != 0)) &&

+           (piVar3[0x264] = 0, (char)puVar18 == '\0')) {

+          ExpressBridgeSaveRestoreConfigurationForReset((longlong)piVar3,'\x01');

+        }

+      }

+      ExpressPcClearTriggerStatus(*(longlong *)(param_2 + 0x20),(longlong)pbVar1);

+      if ((char)puVar18 != '\0') {

+        LOCK();

+        *(ulonglong *)(lVar4 + 0x2e0) = *(ulonglong *)(lVar4 + 0x2e0) & 0xffffffbfffffffff;

+        UNLOCK();

+        if ((*piVar3 == 4) &&

+           ((*(ulonglong *)(**(longlong **)(piVar3 + 2) + 0x2e0) >> 0x2c & 1) != 0)) {

+          ExpressBridgeSaveRestoreConfigurationForReset((longlong)piVar3,'\0');

+        }

+        goto LAB_0;

+      }

+      uVar12 = PciBusWaitForDataLinkSettle(lVar4,1);

+      if (((char)uVar12 == '\0') &&

+         (uVar10 = ExpressPcIsDevicePresentInSlot((longlong)piVar3), (char)uVar10 != '\0')) {

+        uStack_136 = 3;

+      }

+      else {

+        if ((*piVar3 == 4) &&

+           ((*(ulonglong *)(**(longlong **)(piVar3 + 2) + 0x2e0) >> 0x2c & 1) != 0)) {

+          ExpressBridgeSaveRestoreConfigurationForReset((longlong)piVar3,'\0');

+        }

+        ExpressPcWaitForInternalInit((longlong)piVar3);

+        local_f4 = *piVar3;

+        local_f8 = 0xffffffff;

+        local_108 = *(longlong *)(**(longlong **)(piVar3 + 2) + 0x68);

+        local_100 = (undefined4)(*(longlong **)(piVar3 + 2))[1];

+        local_ec = (uint)*puVar11;

+        local_f0 = piVar3[0x2a4];

+        if (iVar9 - 1U < 2) {

+          local_e6 = *(ushort *)(lVar6 + 0xca);

+          uVar15 = local_e6 >> 3 & 0x1f | (local_e6 & 7) << 5;

+          local_d8 = *(ushort *)(lVar4 + 0x124) & 0xff;

+        }

+        else if ((iVar9 == 0) || (uVar15 = 0, iVar9 == 4)) {

+          local_d8 = *(ushort *)(*(longlong *)(param_2 + 0x20) + 0x20) & 0xff;

+          uVar15 = *(uint *)(*(longlong *)(param_2 + 0x20) + 0x24);

+        }

+        local_d4 = uVar15;

+        ExpressRootPortMarkChildrenForDpc

+                  (*(longlong *)(lVar4 + 0x68),(ulonglong)*(uint *)(lVar4 + 0x124));

+        LOCK();

+        *(ulonglong *)(lVar4 + 0x2e0) = *(ulonglong *)(lVar4 + 0x2e0) & 0xffffffbfffffffff;

+        UNLOCK();

+        uVar10 = ExpressPcIsDevicePresentInSlot((longlong)piVar3);

+        local_134 = 2;

+        if (((char)uVar10 != '\0') && (local_134 = 1, PcieDpcRecoveryEnabled != 0)) {

+          local_134 = 0;

+        }

+        local_e4 = local_134;

+        PciPopulateAerErrorInfo(&local_108,'\0');

+        uStack_136 = 0;

+      }

+    }

+LAB_1:

+    if (piVar3[0x21] == 1) {

+      if (local_d0 == (ulonglong *)0x0) {

+        puVar19 = local_88;

+        memset(local_88,0,0x4c);

+        local_d0 = *(ulonglong **)(param_2 + 0x20);

+        piVar13 = &local_5c;

+        piVar14 = &local_58;

+        piVar17 = local_54;

+      }

+      else {

+        uVar10 = local_d0[0x1b];

+        puVar19 = (ulonglong *)(uVar10 + 0x74);

+        piVar13 = (int *)(uVar10 + 0xa0);

+        piVar14 = (int *)(uVar10 + 0xa4);

+        piVar17 = (int *)(uVar10 + 0xa8);

+      }

+      piVar2 = piVar3 + 0x119;

+      piVar3[0x12f] = *piVar3;

+      *piVar13 = piVar3[0x2a4];

+      *piVar14 = piVar3[0x2a5];

+      *piVar17 = piVar3[0x2a6];

+      ExpressPcInitWheaErrorPacket

+                ((longlong)local_d0,piVar14,piVar2,puVar19,(undefined8 *)pbVar1,local_134,

+                 in_stack_fffffffffffffe98,piVar3[0x2d],in_stack_fffffffffffffea8,local_df,local_98,

+                 (longlong)local_c8);

+      *(undefined2 *)((longlong)piVar3 + 0x5c9) = 2;

+      *(undefined1 *)((longlong)piVar3 + 0x5cb) = uStack_136;

+      uVar12 = WheaGetErrorSource(piVar3[0x11f]);

+      PshedRetrieveErrorInfo(piVar2,uVar12);

+      *(int **)(piVar3 + 0x125) = piVar3;

+      WheaReportHwError(piVar2);

+      puVar20 = local_d0;

+    }

+    else {

+      PciWheaReportSpuriousError(*piVar3,local_134,uVar15,(uint)*puVar11,0x435044,(undefined4 *)0x0)

+      ;

+      puVar20 = puVar19;

+    }

+  }

+  LOCK();

+  *(undefined4 *)(param_2 + 0x10) = 0;

+  UNLOCK();

+  LOCK();

+  piVar3[0x268] = piVar3[0x268] & 0xfffffff7;

+  UNLOCK();

+  if (puVar20 == (ulonglong *)0x0) {

+    puVar20 = *(ulonglong **)(param_2 + 0x20);

+    puVar19 = (ulonglong *)(lVar5 + 0x74);

+  }

+  PciClearAerStatus((longlong)puVar20,(longlong)puVar19);

+  if (local_98 != 0) {

+    plVar16 = local_c0;

+    uVar10 = (ulonglong)local_98;

+    do {

+      PciClearAerStatus(*plVar16,*(longlong *)(*plVar16 + 0xd8) + 0x74);

+      plVar16 = plVar16 + 2;

+      uVar10 = uVar10 - 1;

+    } while (uVar10 != 0);

+  }

+  PciClearAerRootErrorStatus

+            (*(longlong *)(**(longlong **)(piVar3 + 2) + 0x68),

+             *(uint *)(*(longlong **)(piVar3 + 2) + 1),*(ushort *)((longlong)piVar3 + 0x52),

+             (byte *)(piVar3 + 0x2a5));

+  ExpressPcClearInterruptStatus(*(longlong *)(param_2 + 0x20),(longlong)pbVar1);

+  DbgPrint("%s: done\n","ExpressPcProcessWorkQueueItem");

+  uVar10 = Feature_3167895864__private_IsEnabledDeviceUsageNoInline();

+  if ((int)uVar10 != 0) {

+    IoReleaseRemoveLockEx(**(longlong **)(piVar3 + 2) + 0x20,0,0x20);

+  }

+  return;

 }
```

## `NTOSKRNL.EXE::IoReleaseRemoveLockEx`  (modified)

```diff
--- NTOSKRNL.EXE::IoReleaseRemoveLockEx calling
+++ NTOSKRNL.EXE::IoReleaseRemoveLockEx calling
@@ -4,0 +5 @@
+ExpressBridgePcInterruptRoutine
@@ -13,0 +15 @@
+ExpressPcProcessWorkQueueItem
```

## `NTOSKRNL.EXE::IoAcquireRemoveLockEx`  (modified)

```diff
--- NTOSKRNL.EXE::IoAcquireRemoveLockEx calling
+++ NTOSKRNL.EXE::IoAcquireRemoveLockEx calling
@@ -4,0 +5 @@
+ExpressBridgePcInterruptRoutine
```
