# CVE-2026-122984 — udfs.sys patch diff

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

## `UdfInitializeAllocations`  (modified)

```diff
--- UdfInitializeAllocations
+++ UdfInitializeAllocations
@@ -1,14 +1,369 @@
 

-undefined4

-UdfInitializeAllocations(undefined8 *param_1,ulonglong *param_2,longlong param_3,char param_4)

+void UdfInitializeAllocations

+               (undefined8 *param_1,ulonglong *param_2,undefined *param_3,char param_4)

 

 {

-  undefined4 unaff_EDI;

-  undefined8 *unaff_R13;

+  short sVar1;

+  longlong lVar2;

+  short *psVar3;

+  bool bVar4;

+  char cVar5;

+  ushort uVar6;

+  uint uVar7;

+  undefined4 uVar8;

+  ulonglong uVar9;

+  ulonglong uVar10;

+  uint uVar11;

+  int iVar12;

+  undefined2 uVar13;

+  ulonglong *puVar14;

+  uint uVar15;

+  undefined7 uVar17;

+  undefined *puVar16;

+  uint *puVar18;

+  uint uVar19;

+  char local_res10;

+  int local_b0;

+  int local_ac;

+  int local_a8;

+  uint local_a4;

+  ulonglong *local_a0;

+  ulonglong local_98;

+  longlong local_90;

+  ulonglong local_88 [2];

+  uint *local_78;

+  undefined8 uStack_70;

+  undefined8 local_68;

+  ulonglong uStack_60;

+  undefined8 local_58;

   

-  if ((param_1 != unaff_R13) && ((*(uint *)((longlong)param_1 + 0x2c) & 1) != 0)) {

-    WPP_SF_D(param_1[3],0x34,&WPP_04865a50136434d7f145de5059f08911_Traceguids,unaff_EDI);

-  }

-  return unaff_EDI;

+  lVar2 = param_1[2];

+  local_90 = -1;

+  psVar3 = *(short **)(param_3 + 0x10);

+  local_b0 = 0;

+  uVar11 = *(uint *)(lVar2 + 0x30) & 0x4000;

+  local_58 = 0;

+  local_98 = 0;

+  local_a4 = 0;

+  local_88[0] = 0;

+  local_88[1] = 0;

+  local_ac = 0;

+  local_78 = (uint *)0x0;

+  uStack_70 = 0;

+  local_a8 = 0;

+  local_68 = 0;

+  uStack_60 = 0;

+  local_res10 = '\0';

+  bVar4 = false;

+  uVar9 = Feature_3861534011__private_IsEnabledDeviceUsageNoInline();

+  puVar14 = param_2 + 0x31;

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

+    if (((ulonglong *)*puVar14 != (ulonglong *)0x0) && ((ulonglong *)*puVar14 != param_2 + 0x32)) {

+      UdfFreePool((longlong *)puVar14);

+    }

+    *(undefined4 *)((longlong)param_2 + 0x184) = 0;

+  }

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

+  *puVar14 = (ulonglong)(param_2 + 0x32);

+  if (*psVar3 != 0x105) {

+    iVar12 = *(int *)(psVar3 + 0x68);

+  }

+  else {

+    iVar12 = *(int *)(psVar3 + 0x54);

+  }

+  uVar19 = 0xd8;

+  uVar15 = 0xb0;

+  if (*psVar3 != 0x105) {

+    uVar15 = uVar19;

+  }

+  *(uint *)(param_2 + 0x1c) = uVar15 + iVar12;

+  if (*psVar3 == 0x105) {

+    uVar7 = *(uint *)(psVar3 + 0x54);

+  }

+  else {

+    uVar7 = *(uint *)(psVar3 + 0x68);

+  }

+  if (uVar15 + iVar12 < uVar7) {

+    if (((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

+       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) >> 0x12 & 1) == 0)) goto LAB_0;

+    if (*psVar3 == 0x105) {

+      uVar19 = 0xb0;

+    }

+    uVar13 = 0x45;

+  }

+  else {

+    uVar9 = Feature_379829561__private_IsEnabledDeviceUsageNoInline();

+    if (((int)uVar9 == 0) || (uVar19 = (uint)param_2[0x1c], uVar19 < *(uint *)(lVar2 + 0x44))) {

+      puVar14 = param_2 + 4;

+      if ((ulonglong)(0xffffffffL << ((byte)*(uint *)(lVar2 + 0x48) & 0x3f)) < *puVar14)

+      goto LAB_0;

+      UdfInitializeScbMcb((ulonglong)*(uint *)(lVar2 + 0x48),(longlong)param_2,uVar11 == 0);

+      uVar9 = *puVar14;

+      param_2[0x27] = uVar9;

+      param_2[0x26] = uVar9;

+      uVar19 = *(ushort *)(*(longlong *)(param_3 + 0x10) + 0x22) & 7;

+      uStack_70 = CONCAT44(uStack_70._4_4_,(uint)*(ushort *)(*(longlong *)(param_3 + 0x10) + 0x22))

+                  & 0xffffffff00000007;

+      if (uVar19 == 1) {

+        *(uint *)((longlong)param_2 + 0xd4) = *(uint *)((longlong)param_2 + 0xd4) | 0x20000;

+      }

+      else if (uVar19 == 3) {

+        UdfUninitializeScbMcb((longlong)param_2);

+        *(uint *)((longlong)param_2 + 0xd4) = *(uint *)((longlong)param_2 + 0xd4) | 2;

+        if (*psVar3 == 0x105) {

+          iVar12 = *(int *)(psVar3 + 0x56);

+        }

+        else {

+          iVar12 = *(int *)(psVar3 + 0x6a);

+        }

+        if (iVar12 == (int)*puVar14) {

+          uVar9 = Feature_3645010233__private_IsEnabledDeviceUsageNoInline();

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

+            if (*psVar3 == 0x105) {

+              uVar11 = *(uint *)(psVar3 + 0x56);

+            }

+            else {

+              uVar11 = *(uint *)(psVar3 + 0x6a);

+            }

+            uVar9 = param_2[4];

+            if ((uVar9 != uVar11) ||

+               ((ulonglong)*(uint *)(lVar2 + 0x44) < (uint)param_2[0x1c] + uVar9)) {

+              if (((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+                 ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) >> 0x12 & 1) != 0)) {

+                if (*psVar3 == 0x105) {

+                  uVar11 = *(uint *)(psVar3 + 0x56);

+                }

+                else {

+                  uVar11 = *(uint *)(psVar3 + 0x6a);

+                }

+                WPP_SF_iDDD(WPP_GLOBAL_Control[3],(ulonglong)uVar11,0x105,uVar9);

+              }

+              goto LAB_0;

+            }

+          }

+          *(undefined4 *)((longlong)param_2 + 300) = 0;

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

+          return;

+        }

+        if (((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) >> 0x12 & 1) == 0)) goto LAB_0;

+        if (*psVar3 == 0x105) {

+          uVar19 = *(uint *)(psVar3 + 0x56);

+        }

+        else {

+          uVar19 = *(uint *)(psVar3 + 0x6a);

+        }

+        uVar13 = 0x47;

+        goto LAB_1;

+      }

+      local_a0 = param_2 + 4;

+      if (uVar9 != 0) {

+        puVar14 = local_88;

+        puVar16 = param_3;

+        UdfInitializeAllocationContext

+                  ((longlong)param_1,(longlong *)puVar14,(longlong)param_3,param_4,(longlong)param_2

+                  );

+        uVar9 = 0;

+        do {

+          puVar16 = (undefined *)CONCAT71((int7)((ulonglong)puVar16 >> 8),local_res10);

+          uVar19 = (uint)local_68;

+          if (((local_a4 != (uint)local_68) && ((*(uint *)((longlong)param_2 + 0xd4) & 0x8000) == 0)

+              ) && (uVar11 == 0)) {

+            uVar10 = uStack_60 & 0xffffffff;

+            puVar14 = param_2;

+            UdfInsertAdExtInfo((longlong)param_1,(longlong)param_2,uVar10,(uint)local_68,

+                               (int)(uVar9 >> ((byte)*(undefined4 *)(lVar2 + 0x48) & 0x3f)));

+            puVar16 = (undefined *)CONCAT71((int7)(uVar10 >> 8),local_res10);

+            local_a4 = uVar19;

+          }

+          puVar18 = local_78;

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

+LAB_2:

+            local_res10 = (char)puVar16;

+            if ((*local_78 & 0xc0000000) == 0x40000000) {

+              iVar12 = *(int *)(lVar2 + 0x44);

+              uVar19 = (uint)uVar9 & iVar12 - 1U;

+              goto joined_r0x00014004be1a;

+            }

+LAB_3:

+            if (((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+               ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) >> 0x12 & 1) != 0)) {

+              WPP_SF_cii(WPP_GLOBAL_Control[3],puVar14,

+                         CONCAT71((int7)((ulonglong)puVar16 >> 8),-(char)puVar16),

+                         (-((char)puVar16 != '\0') & 0xbU) + 0x4e);

+            }

+            goto LAB_0;

+          }

+          uVar17 = (undefined7)((ulonglong)puVar16 >> 8);

+          puVar14 = local_a0;

+          if ((longlong)*local_a0 <= (longlong)uVar9) {

+            if ((uVar11 == 0) && (uVar9 == *local_a0)) {

+              puVar16 = (undefined *)CONCAT71(uVar17,1);

+              uVar10 = (ulonglong)(*(int *)(lVar2 + 0x44) - 1);

+              uVar9 = uVar9 + uVar10 & ~uVar10;

+              goto LAB_2;

+            }

+            break;

+          }

+          iVar12 = *(int *)(lVar2 + 0x44);

+          puVar16 = (undefined *)CONCAT71(uVar17,local_res10);

+          uVar19 = (uint)uVar9 & iVar12 - 1U;

+joined_r0x00014004be1a:

+          if (uVar19 != 0) goto LAB_3;

+          uVar19 = *local_78;

+          if ((uVar19 & 0xc0000000) < 0x80000000) {

+            uVar15 = (((uVar19 & 0x3fffffff) - 1) + iVar12 & -iVar12) >>

+                     ((byte)*(undefined4 *)(lVar2 + 0x48) & 0x1f);

+            local_a8 = local_a8 + uVar15;

+            if (uVar19 < 0x40000000) {

+              local_ac = local_ac + uVar15;

+            }

+            else if (uVar11 != 0) goto LAB_4;

+            uVar19 = uVar11;

+            if (*(longlong *)(lVar2 + 0x160) == 0) {

+              local_b0 = 0;

+              uVar6 = UdfGetPartitionOfCurrentAllocation((longlong *)local_88);

+            }

+            else {

+              uVar6 = 0;

+              local_b0 = 0;

+            }

+            if (((uVar19 == 0) && (uVar6 != *(ushort *)(*(longlong *)(lVar2 + 0x10) + 0x5c))) &&

+               (uVar6 != *(ushort *)(*(longlong *)(lVar2 + 0x10) + 0x54))) {

+              if (((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+                 ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) >> 0x12 & 1) != 0)) {

+                WPP_SF_D(WPP_GLOBAL_Control[3],0x4a,&WPP_dafe4f8ea98c3a097051008be5effc2d_Traceguids

+                         ,(uint)uVar6);

+              }

+              goto LAB_0;

+            }

+            if (((*(uint *)(lVar2 + 0x30) & 0x4000000) == 0) ||

+               (uVar6 != *(ushort *)(*(longlong *)(lVar2 + 0x10) + 0x54))) {

+              uVar10 = UdfLookupPsnOfExtent

+                                 ((longlong)param_1,lVar2,uVar6,puVar18[1],*puVar18 & 0x3fffffff);

+              uVar19 = (uint)uVar10;

+            }

+            else {

+              uVar19 = puVar18[1];

+              local_b0 = 1;

+            }

+            uVar10 = (ulonglong)uVar19;

+            FsRtlAddLargeMcbEntry

+                      ((-(ulonglong)(*puVar18 < 0x40000000) & 0xffffffffffffffe0) + 0x108 +

+                       (longlong)param_2,

+                       uVar9 >> ((byte)*(undefined4 *)(lVar2 + 0x48) & 0x3f) & 0xffffffff,uVar10);

+            puVar16 = (undefined *)CONCAT71((int7)(uVar10 >> 8),local_res10);

+          }

+          else if (uVar11 == 0) {

+            bVar4 = true;

+          }

+LAB_4:

+          uVar9 = uVar9 + (*puVar18 & 0x3fffffff);

+          if ((ulonglong)(0xffffffffL << ((byte)*(undefined4 *)(lVar2 + 0x48) & 0x3f)) < uVar9)

+          goto LAB_0;

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

+            local_98 = uVar9;

+          }

+          if ((*puVar18 & 0xc0000000) != 0x80000000) {

+            local_90 = uVar9 - 1;

+          }

+          puVar14 = local_88;

+          cVar5 = UdfGetNextAllocation((longlong)param_1,(longlong *)puVar14);

+        } while (cVar5 != '\0');

+        uVar9 = (ulonglong)(*(int *)(lVar2 + 0x44) - 1);

+        uVar8 = (undefined4)

+                ((local_90 + 1 + uVar9 & ~uVar9) >> ((byte)*(undefined4 *)(lVar2 + 0x48) & 0x3f));

+        *(undefined4 *)((longlong)param_2 + 300) = uVar8;

+        *(undefined4 *)(param_2 + 0x25) = uVar8;

+        if (((bVar4) && ((*(byte *)(*(longlong *)(lVar2 + 0x10) + 6) & 2) == 0)) &&

+           ((*(uint *)(lVar2 + 0x30) & 0x20000000) == 0)) {

+          puVar16 = (undefined *)0x0;

+          UdfAcquireResource((longlong)param_1,param_2[2],'\0',0);

+          uVar9 = UdfSetStreamSparse((longlong)param_1,(longlong)param_2);

+          ExReleaseResourceLite(param_2[2]);

+          if ((int)uVar9 < 0) {

+                    /* WARNING: Subroutine does not return */

+            UdfRaiseStatusEx((longlong)param_1,(int)uVar9,'\0');

+          }

+        }

+        if ((local_res10 == '\0') && (param_2[4] != local_98)) {

+          if (((((short)*param_2 == 0x934) &&

+               ((param_4 != '\0' && ((*(uint *)((longlong)param_2 + 0xd4) & 0x18) == 0)))) &&

+              (((uint)param_2[4] & 0x3fffffff) == local_98)) &&

+             (psVar3 = *(short **)(local_88[0] + 0x10), psVar3 != (short *)0x0)) {

+            sVar1 = *psVar3;

+            uVar11 = 0xb0;

+            if (sVar1 != 0x105) {

+              uVar11 = 0xd8;

+            }

+            puVar16 = (undefined *)(ulonglong)uVar11;

+            if (sVar1 != 0x105) {

+              uVar11 = *(uint *)(psVar3 + 0x68);

+            }

+            else {

+              uVar11 = *(uint *)(psVar3 + 0x54);

+            }

+            puVar18 = (uint *)(puVar16 + uVar11 + (longlong)psVar3);

+            if ((*(byte *)(psVar3 + 0x11) & 7) == 0) {

+              if (sVar1 == 0x105) {

+                iVar12 = *(int *)(psVar3 + 0x56);

+              }

+              else {

+                iVar12 = *(int *)(psVar3 + 0x6a);

+              }

+              if ((iVar12 == 8) && ((ulonglong)*puVar18 == param_2[4])) {

+                uVar6 = UdfGetPartitionOfCurrentAllocation((longlong *)local_88);

+                uVar9 = UdfLookupPsnOfExtent

+                                  ((longlong)param_1,lVar2,uVar6,puVar18[1],(uint)param_2[4]);

+                FsRtlTruncateLargeMcb(param_2 + 0x1d,0);

+                puVar16 = (undefined *)(uVar9 & 0xffffffff);

+                FsRtlAddLargeMcbEntry(param_2 + 0x1d,0);

+                local_98 = param_2[4];

+                if (((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+                   ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) >> 0x12 & 1) != 0)) {

+                  puVar16 = &WPP_dafe4f8ea98c3a097051008be5effc2d_Traceguids;

+                  WPP_SF_i(WPP_GLOBAL_Control[3],0x4b,

+                           &WPP_dafe4f8ea98c3a097051008be5effc2d_Traceguids,param_2);

+                }

+              }

+            }

+          }

+          if (param_2[4] != local_98) {

+            if (((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+               ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) >> 0x12 & 1) != 0)) {

+              WPP_SF_iii(WPP_GLOBAL_Control[3],param_2[4],puVar16,local_98);

+            }

+            goto LAB_0;

+          }

+        }

+        uVar11 = *(uint *)(param_1[2] + 0x30);

+        if (((((byte)uVar11 & 0x60) == 0x60) && ((*(uint *)(param_1[2] + 0x54) & 0x10) == 0)) &&

+           ((uVar11 >> 0xe & 1) == 0)) {

+          UdfVerifyMcbAllocatedInBitmap(param_1,local_b0,param_2,param_2 + 0x1d);

+          UdfVerifyMcbAllocatedInBitmap(param_1,local_b0,param_2,param_2 + 0x21);

+        }

+        UdfUnpinView((longlong)param_1,(undefined8 *)(param_3 + 0x38));

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

+          UdfMapMetadataView((longlong)param_1,(undefined8 *)(param_3 + 0x10),lVar2,0,0,0,2);

+        }

+        *(int *)(param_2 + 0x28) = local_ac;

+        *(int *)((longlong)param_2 + 0x144) = local_a8;

+        if (((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) >> 0x12 & 1) != 0)) {

+          WPP_SF_iD(WPP_GLOBAL_Control[3],0x4d,&WPP_dafe4f8ea98c3a097051008be5effc2d_Traceguids,

+                    param_2);

+        }

+      }

+      return;

+    }

+    if (((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

+       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) >> 0x12 & 1) == 0)) goto LAB_0;

+    uVar13 = 0x46;

+  }

+LAB_1:

+  WPP_SF_dD(WPP_GLOBAL_Control[3],uVar13,&WPP_dafe4f8ea98c3a097051008be5effc2d_Traceguids,uVar19);

+LAB_0:

+                    /* WARNING: Subroutine does not return */

+  UdfRaiseStatusEx((longlong)param_1,0xc0000102,'\0');

 }
```

## `UdfCreateIrpContext`  (modified)

```diff
--- UdfCreateIrpContext
+++ UdfCreateIrpContext
@@ -1,10 +1,61 @@
-

-/* WARNING: Control flow encountered bad instruction data */

 

 void UdfCreateIrpContext(longlong param_1,char param_2)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  char cVar1;

+  char *pcVar2;

+  longlong lVar3;

+  bool bVar4;

+  undefined8 *puVar5;

+  uint uVar6;

+  

+  pcVar2 = *(char **)(param_1 + 0xb8);

+  if ((*(longlong *)(pcVar2 + 0x28) == DAT_0) ||

+     (*(longlong *)(pcVar2 + 0x28) == DAT_1)) {

+    bVar4 = true;

+    if ((*(longlong *)(pcVar2 + 0x30) != 0) &&

+       (((cVar1 = *pcVar2, cVar1 != '\0' && (cVar1 != '\x12')) && (cVar1 != '\x02')))) {

+                    /* WARNING: Subroutine does not return */

+      ExRaiseStatus(0xc0000010);

+    }

+  }

+  else {

+    bVar4 = false;

+  }

+  puVar5 = (undefined8 *)ExAllocateFromNPagedLookasideList(&UdfIrpContextLookasideList);

+  *puVar5 = 0;

+  puVar5[1] = 0;

+  puVar5[2] = 0;

+  puVar5[3] = 0;

+  puVar5[4] = 0;

+  puVar5[5] = 0;

+  puVar5[6] = 0;

+  puVar5[7] = 0;

+  puVar5[8] = 0;

+  puVar5[9] = 0;

+  puVar5[10] = 0;

+  puVar5[0xb] = 0;

+  puVar5[0xc] = 0;

+  puVar5[0xd] = 0;

+  *(undefined4 *)puVar5 = 0x700937;

+  puVar5[1] = param_1;

+  lVar3 = *(longlong *)(pcVar2 + 0x30);

+  if ((lVar3 != 0) &&

+     ((puVar5[4] = *(undefined8 *)(lVar3 + 8), (*(uint *)(lVar3 + 0x50) & 0x10) != 0 ||

+      (((*pcVar2 == '\x04' && ((*(uint *)(param_1 + 0x10) & 1) != 0)) && ((pcVar2[2] & 4U) != 0)))))

+     ) {

+    *(uint *)((longlong)puVar5 + 0x1c) = *(uint *)((longlong)puVar5 + 0x1c) | 0x20000;

+  }

+  if (!bVar4) {

+    puVar5[2] = *(longlong *)(pcVar2 + 0x28) + 0x170;

+  }

+  *(char *)(puVar5 + 7) = *pcVar2;

+  *(char *)((longlong)puVar5 + 0x39) = pcVar2[1];

+  uVar6 = 4;

+  if (param_2 == '\0') {

+    uVar6 = 8;

+  }

+  *(uint *)((longlong)puVar5 + 0x1c) = *(uint *)((longlong)puVar5 + 0x1c) | uVar6;

+  return;

 }
```

## `UdfChangeOrVerifyBitmapRun`  (modified)

```diff
--- UdfChangeOrVerifyBitmapRun
+++ UdfChangeOrVerifyBitmapRun
@@ -1,17 +1,89 @@
 

-ulonglong UdfChangeOrVerifyBitmapRun

-                    (undefined8 *param_1,int param_2,uint param_3,uint param_4,char param_5,

-                    char param_6,int *param_7)

+void UdfChangeOrVerifyBitmapRun

+               (undefined8 *param_1,int param_2,uint param_3,uint param_4,char param_5,char param_6,

+               int *param_7)

 

 {

-  ulonglong uVar1;

+  longlong lVar1;

+  char cVar2;

+  int iVar3;

+  ulonglong uVar4;

+  undefined8 *puVar5;

+  undefined8 *puVar6;

+  longlong lVar7;

+  uint uVar8;

+  longlong lVar9;

   

-  if ((Feature_2331137338__private_featureState & 0x10) == 0) {

-    uVar1 = func_0x00014000e5e8(Feature_2331137338__private_featureState,3);

+  lVar1 = param_1[2];

+  lVar9 = (longlong)param_2;

+  puVar6 = param_1;

+  if (param_6 == '\0') {

+    UdfMarkVolumeOpenAndQueueCloseDpc(param_1);

   }

-  else {

-    uVar1 = (ulonglong)(Feature_2331137338__private_featureState & 1);

-  }

-  return uVar1;

+  *param_7 = 0;

+  do {

+    if (param_4 == 0) {

+LAB_0:

+      UdfUnpinCurrentBitmapPage(puVar6,lVar1,param_2);

+      return;

+    }

+    uVar4 = Feature_2331137338__private_IsEnabledDeviceUsageNoInline();

+    if (((int)uVar4 != 0) && (*(uint *)(lVar9 * 200 + 0x298 + lVar1) <= param_3)) {

+                    /* WARNING: Subroutine does not return */

+      UdfRaiseStatusEx((longlong)param_1,0xc0000032,'\0');

+    }

+    lVar7 = lVar9 * 200;

+    UdfMapOrPinBitmapLbnRange((longlong)param_1,param_2,param_3);

+    uVar4 = Feature_2331137338__private_IsEnabledDeviceUsageNoInline();

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

+      uVar8 = *(uint *)(lVar7 + 0x208 + lVar1);

+      if ((param_3 < uVar8) || (*(uint *)(lVar7 + 0x20c + lVar1) <= param_3 - uVar8)) {

+        UdfUnpinCurrentBitmapPage((ulonglong)uVar8,lVar1,param_2);

+                    /* WARNING: Subroutine does not return */

+        UdfRaiseStatusEx((longlong)param_1,0xc0000032,'\0');

+      }

+    }

+    iVar3 = *(int *)(lVar7 + 0x208 + lVar1);

+    uVar8 = (*(int *)(lVar7 + 0x20c + lVar1) - param_3) + iVar3;

+    if (param_4 <= uVar8) {

+      uVar8 = param_4;

+    }

+    puVar5 = (undefined8 *)(lVar1 + 0x218 + lVar7);

+    if (param_6 == '\0') {

+      CcSetDirtyPinnedData(*(undefined8 *)(lVar9 * 200 + 0x1f8 + lVar1),0);

+      if (param_5 == '\0') {

+        RtlClearBits(puVar5,param_3 - *(int *)(lVar9 * 200 + 0x208 + lVar1));

+        puVar6 = puVar5;

+      }

+      else {

+        RtlSetBits();

+        puVar6 = puVar5;

+      }

+    }

+    else {

+      puVar6 = puVar5;

+      if (param_5 == '\0') {

+        cVar2 = RtlAreBitsClear(puVar5,param_3 - iVar3);

+        if (cVar2 == '\0') {

+          iVar3 = RtlFindSetBits(puVar5,1,param_3 - *(int *)(lVar9 * 200 + 0x208 + lVar1));

+          goto LAB_1;

+        }

+      }

+      else {

+        cVar2 = RtlAreBitsSet();

+        if (cVar2 == '\0') {

+          iVar3 = RtlFindClearBits(puVar5,1,param_3 - *(int *)(lVar9 * 200 + 0x208 + lVar1));

+LAB_1:

+          uVar8 = (*(int *)(lVar9 * 200 + 0x208 + lVar1) - param_3) + iVar3;

+          puVar6 = (undefined8 *)(ulonglong)uVar8;

+          *param_7 = *param_7 + uVar8;

+          goto LAB_0;

+        }

+      }

+    }

+    *param_7 = *param_7 + uVar8;

+    param_3 = param_3 + uVar8;

+    param_4 = param_4 - uVar8;

+  } while( true );

 }
```

## `UdfVmcbCheckForNoOpRead`  (modified)

```diff
--- UdfVmcbCheckForNoOpRead
+++ UdfVmcbCheckForNoOpRead
@@ -1,63 +1,66 @@
 

-int UdfVmcbCheckForNoOpRead(undefined8 *param_1,longlong param_2,int param_3,uint param_4)

+void UdfVmcbCheckForNoOpRead(undefined8 *param_1,longlong param_2,int param_3,uint param_4)

 

 {

-  uint uVar1;

+  uint *puVar1;

   uint uVar2;

   ulonglong uVar3;

-  undefined8 uVar4;

-  uint uVar5;

-  longlong unaff_RBX;

-  uint unaff_ESI;

-  short sVar6;

+  uint *puVar4;

+  ulonglong uVar5;

+  ushort uVar6;

   uint uVar7;

-  short unaff_R12W;

-  uint *unaff_R13;

-  short *unaff_R14;

-  longlong unaff_R15;

-  int in_stack_00000044;

+  uint uVar8;

+  int local_res18 [4];

   

-  if ((((((ulonglong)param_1 & 0x1800) == 0) &&

-       (uVar1 = *unaff_R13,

-       (byte)((byte)unaff_ESI & ((byte)((ulonglong)param_1 >> 8) >> 5 ^ (byte)(uVar1 >> 4))) == 0))

-      && (*(char *)((longlong)unaff_R14 + 0x1b) == *(char *)(unaff_RBX + 0x1f6))) &&

-     ((((unaff_R14[10] == unaff_R12W &&

-        (sVar6 = (short)param_3, (uVar1 >> 1 & unaff_ESI) == (uint)(sVar6 == 3))) &&

-       (((uVar1 >> 0x11 & unaff_ESI) == (uint)(sVar6 == (short)unaff_ESI) &&

-        ((sVar6 != 2 && (*(longlong *)(unaff_R14 + 0x1c) == *(longlong *)(unaff_RBX + 0x20))))))) &&

-      (unaff_R14[0x18] == *(short *)(unaff_RBX + 500))))) {

-    uVar3 = Feature_156644667__private_IsEnabledDeviceUsageNoInline();

+  uVar5 = 0;

+  local_res18[0] = 0;

+  if (param_3 == 0) {

+    uVar6 = *(ushort *)(*(longlong *)(param_2 + 0x10) + 0x58);

+  }

+  else {

+    uVar6 = *(ushort *)(*(longlong *)(param_2 + 0x10) + 0x54);

+  }

+  uVar3 = UdfLookupPsnOfExtent((longlong)param_1,param_2,uVar6,param_4,*(uint *)(param_2 + 0x44));

+  uVar7 = ~*(uint *)(param_2 + 0x4fc) & (uint)uVar3;

+  uVar8 = (uint)uVar3 - uVar7;

+  if (uVar8 <= param_4) {

+    uVar3 = Feature_2331137338__private_IsEnabledDeviceUsageNoInline();

     if ((int)uVar3 != 0) {

-      if (*unaff_R14 == 0x105) {

-        uVar1 = *(uint *)(unaff_R14 + 0x56);

-        uVar7 = *(uint *)(unaff_R14 + 0x54);

+      uVar2 = *(uint *)((longlong)param_3 * 200 + 0x298 + param_2);

+      if (uVar2 <= param_4 - uVar8) {

+        return;

       }

-      else {

-        uVar1 = *(uint *)(unaff_R14 + 0x6a);

-        uVar7 = *(uint *)(unaff_R14 + 0x68);

+      if (uVar2 - (param_4 - uVar8) < *(uint *)(param_2 + 0x4f8)) {

+        return;

       }

-      uVar5 = 0xd8;

-      if (*unaff_R14 != 0x10a) {

-        uVar5 = 0xb0;

-      }

-      uVar2 = *(uint *)(*(longlong *)(unaff_R15 + 0x10) + 0x44);

-      if ((((uVar2 < uVar5) || (uVar2 - uVar5 < uVar7)) || ((uVar2 - uVar5) - uVar7 < uVar1)) ||

-         ((uVar5 + uVar7 != *(int *)(unaff_RBX + 0xe0) ||

-          (uVar2 - *(int *)(unaff_RBX + 0xe0) < uVar1)))) goto LAB_0;

     }

-    if ((*unaff_R13 & 0x2000) != 0) {

-      uVar4 = UdfCreateSparseReservationBitmap(unaff_R15,unaff_RBX);

-      in_stack_00000044 = (int)uVar4;

-    }

-    if (in_stack_00000044 == 0) {

-      *(undefined4 *)(unaff_RBX + 0xd8) = 0;

+    UdfChangeOrVerifyBitmapRun

+              (param_1,param_3,param_4 - uVar8,*(uint *)(param_2 + 0x4f8),'\x01','\x01',local_res18)

+    ;

+    if (local_res18[0] == *(int *)(param_2 + 0x4f8)) {

+      puVar4 = (uint *)(param_2 + 0x568);

+      do {

+        puVar1 = (uint *)(param_2 + 0x568 + uVar5 * 4);

+        LOCK();

+        uVar8 = *puVar1;

+        if (uVar8 == 0xffffffff) {

+          *puVar1 = uVar7;

+          uVar8 = 0xffffffff;

+        }

+        UNLOCK();

+        if (uVar8 == 0xffffffff) {

+          *(uint *)((longlong)param_1 + 0x1c) = *(uint *)((longlong)param_1 + 0x1c) | 0x80000;

+          return;

+        }

+        if (*puVar4 == uVar7) {

+          return;

+        }

+        uVar8 = (int)uVar5 + 1;

+        uVar5 = (ulonglong)uVar8;

+        puVar4 = puVar4 + 1;

+      } while (uVar8 < 4);

     }

   }

-  else {

-LAB_0:

-    *(undefined4 *)(unaff_RBX + 0xd8) = 2;

-  }

-  UdfUnpinView(unaff_R15,(undefined8 *)&stack0x00000060);

-  return in_stack_00000044;

+  return;

 }
```

## `UdfPrepareMediaEjectWorker`  (modified)

```diff
--- UdfPrepareMediaEjectWorker
+++ UdfPrepareMediaEjectWorker
@@ -1,37 +1,84 @@
 

-uint UdfPrepareMediaEjectWorker(ulonglong *param_1)

+void UdfPrepareMediaEjectWorker(ulonglong *param_1)

 

 {

-  byte bVar1;

-  ulonglong uVar2;

-  uint uVar3;

-  longlong in_RAX;

-  ulonglong *unaff_RBX;

-  ulonglong *unaff_RDI;

-  longlong unaff_R14;

-  byte in_CF;

-  char cStack0000000000000030;

+  void *pvVar1;

+  char cVar2;

+  ulonglong uVar3;

+  longlong lVar4;

+  ulonglong *puVar5;

+  undefined8 uVar6;

+  undefined8 uVar7;

+  undefined8 in_stack_ffffffffffffffb0;

+  undefined8 local_38;

+  undefined8 uStack_30;

+  undefined8 local_28;

   

-  uVar2 = *unaff_RDI;

-  bVar1 = (char)*unaff_RDI + (byte)param_1;

-  *(byte *)unaff_RDI = bVar1 + in_CF;

-  *(int *)(in_RAX + -0x38) =

-       *(int *)(in_RAX + -0x38) + (int)param_1 +

-       (uint)(CARRY1((byte)uVar2,(byte)param_1) || CARRY1(bVar1,in_CF));

-  *(undefined4 *)(in_RAX + -0x28) = *(undefined4 *)(in_RAX + 0x20);

-  *(undefined4 *)(in_RAX + -0x24) = *(undefined4 *)(in_RAX + 0x24);

-  *(undefined4 *)(in_RAX + -0x20) = *(undefined4 *)(in_RAX + 0x28);

-  *(undefined4 *)(in_RAX + -0x1c) = *(undefined4 *)(in_RAX + 0x2c);

-  *(undefined8 *)(in_RAX + -0x18) = *(undefined8 *)(in_RAX + 0x30);

-  *(undefined1 *)(in_RAX + -0x45) = 0;

-  uVar3 = IoSynchronousCallDriver(unaff_RBX[3]);

-  UdfFlushVolume(unaff_RDI,unaff_RBX,0,(ulonglong *)0x0,'\x01','\x01');

-  cStack0000000000000030 = UdfCheckForDismount((longlong)unaff_RDI,unaff_RBX,'\x01');

-  if (cStack0000000000000030 != '\0') {

-    ExReleaseResourceLite();

+  local_38 = 0;

+  uStack_30 = 0;

+  local_28 = 0;

+  pvVar1 = (void *)param_1[2];

+  UdfSetThreadContext((longlong)param_1,(undefined4 *)&local_38);

+  if (((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+     ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) {

+    WPP_SF_i(WPP_GLOBAL_Control[3],0xb,&WPP_21fbff4a1f0632bfa5788e87f7da5e73_Traceguids,pvVar1);

   }

-  ExReleaseResourceLite(&DAT_0);

-  UdfCompleteRequest((longlong)unaff_RDI,unaff_R14,uVar3);

-  return uVar3;

+  KeEnterCriticalRegion();

+  UdfAcquireResource((longlong)param_1,(longlong)pvVar1 + 0x5c8,'\0',0);

+  if (*(int *)((longlong)pvVar1 + 0x34) == 2) {

+    uVar7 = 0;

+    uVar6 = 0;

+    UdfAcquireResource((longlong)param_1,(longlong)pvVar1 + 0x7e8,'\0',0);

+    if (((*(uint *)((longlong)pvVar1 + 0x850) & 6) == 0) &&

+       ((*(uint *)((longlong)pvVar1 + 0x850) & 0x10) != 0)) {

+      puVar5 = param_1;

+      if ((*(uint *)((longlong)pvVar1 + 0x30) & 0x200000) == 0) {

+        if (((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) {

+          WPP_SF_i(WPP_GLOBAL_Control[3],0xc,&WPP_21fbff4a1f0632bfa5788e87f7da5e73_Traceguids,pvVar1

+                  );

+        }

+        UdfStopBackgroundFormat((ulonglong)param_1,(longlong)pvVar1);

+      }

+      else {

+        if (param_1[1] == 0) {

+          lVar4 = *(longlong *)(*(longlong *)((longlong)pvVar1 + 0x120) + 0x1f8);

+        }

+        else {

+          lVar4 = *(longlong *)(*(longlong *)(param_1[1] + 0xb8) + 0x30);

+        }

+        if (lVar4 != 0) {

+          FsRtlNotifyVolumeEvent();

+        }

+        UdfSeqCacheCloseSession(param_1,'\0',uVar6,uVar7);

+      }

+      UdfPerformDevIoCtrl(puVar5,0x2d4808,*(undefined8 *)((longlong)pvVar1 + 0x18),(void *)0x0,0,

+                          (void *)0x0,0,in_stack_ffffffffffffffb0,'\0',(undefined4 *)0x0);

+    }

+    *(uint *)((longlong)pvVar1 + 0x850) = *(uint *)((longlong)pvVar1 + 0x850) & 0xffffffdf;

+    ExReleaseResourceLite((longlong)pvVar1 + 0x7e8);

+  }

+  lVar4 = (longlong)pvVar1 + 0x5c8;

+  ExReleaseResourceLite(lVar4);

+  uVar3 = Feature_119952696__private_IsEnabledDeviceUsageNoInline();

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

+    cVar2 = '\x01';

+    ExAcquireResourceExclusiveLite(&DAT_0,1);

+    UdfAcquireResource((longlong)param_1,lVar4,'\0',0);

+    ExAcquireFastMutexUnsafe((longlong)pvVar1 + 0x630);

+    *(int *)((longlong)pvVar1 + 0x100) = *(int *)((longlong)pvVar1 + 0x100) + -1;

+    *(undefined8 *)((longlong)pvVar1 + 0x668) = 0;

+    ExReleaseFastMutexUnsafe((longlong)pvVar1 + 0x630);

+    if (*(int *)((longlong)pvVar1 + 0x34) == 4) {

+      cVar2 = UdfCheckForDismount((longlong)param_1,pvVar1,'\0');

+    }

+    if (cVar2 != '\0') {

+      ExReleaseResourceLite(lVar4);

+    }

+    ExReleaseResourceLite(&DAT_0);

+  }

+  ExFreeToNPagedLookasideList(&UdfIrpContextLookasideList,param_1);

+  KeLeaveCriticalRegion();

+  return;

 }
```

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

```diff
--- NTOSKRNL.EXE::ExReleaseFastMutexUnsafe calling
+++ NTOSKRNL.EXE::ExAcquireResourceExclusiveLite calling
@@ -1,8 +1,5 @@
-UdfAddAllocation
-UdfAllocateAtFileTail
-UdfAllocateAtFileTail$fin$0
-UdfAllocateBlockForIcb
-UdfAllocateBlockForIcb$fin$1
-UdfAssignNextUniqueId
-UdfCheckForDismount
-UdfCleanVolumeWorker
+UdfAcquireDeviceShared
+UdfAcquireForCacheWrite
+UdfAcquireForCcFlush
+UdfAcquireForModWrite
+UdfAcquireResource
@@ -9,0 +7 @@
+UdfCommonClose
@@ -11 +9,4 @@
-UdfCommonWrite
+UdfCommonCreate
+UdfCommonFlushBuffers
+UdfCommonPnp
+UdfCommonShutdown
@@ -13,10 +13,0 @@
-UdfCompleteScbOpen$fin$0
-UdfCreateInternalStream
-UdfCreateInternalStream$fin$0
-UdfCreateLink
-UdfCreateOrResetVatAndVmcbStreams
-UdfCreateOrResetVatAndVmcbStreams$fin$1
-UdfCreateSparseReservationBitmap
-UdfDeallocateMetaDataBlock
-UdfDeleteInternalStream
-UdfDismountVcb
@@ -24,2 +15 @@
-UdfExtendMetaDataFile
-UdfExtendMetaDataFile$fin$3
+UdfFilterCallbackAcquireForCreateSection
@@ -26,0 +17 @@
+UdfFlushIcbForScb
@@ -28,3 +19,2 @@
-UdfFreeAllocation
-UdfInitializeUniqueIdTable
-UdfInitializeUniqueIdTable$fin$0
+UdfFspClose
+UdfInitializeAllocationSupport
@@ -32,12 +22,4 @@
-UdfMarkAllScbsForVerify
-UdfMarkVolumeCorrupt
-UdfMarkVolumeOpenAndQueueCloseDpc
-UdfMoveFile
-UdfMoveFile$fin$0
-UdfMovePrefix
-UdfOpenObjectByFileId
-UdfOpenObjectByFileId$fin$1
-UdfOpenObjectFromDirContext
-UdfOpenObjectFromDirContext$fin$0
-UdfOpenStreamDirectory
-UdfOpenStreamDirectory$fin$1
+UdfLookupMetaVsnOfExtent
+UdfMountVolume
+UdfPerformVerify
+UdfPnpCallbackRoutine
@@ -45,11 +27 @@
-UdfPnpRemove
-UdfPnpSurpriseRemove
-UdfPrepareForAllocationChange
-UdfProcessHolesInFileRegion
-UdfPurgeAndFreeAllocationForScb
-UdfPurgeAndFreeAllocationForScb$fin$0
-UdfQueryStreamsInfo
-UdfQueryStreamsInfo$fin$0
-UdfQueueClose
-UdfReleaseBlockReservation
-UdfRemoveClose
+UdfQueryDirectory
@@ -56,0 +29 @@
+UdfRmwBgFormatWorker
@@ -58,0 +32,2 @@
+UdfRmwIssueIoRequest
+UdfRmwMakeCacheRunValid
@@ -61,3 +35,0 @@
-UdfSeqCacheUpdateFileRefCount
-UdfSeqCacheWriteBlocksForFile
-UdfSeqCacheWriteBlocksForFile$fin$0
@@ -66,5 +37,0 @@
-UdfSetFileAllocationSize
-UdfSetLinkInfo
-UdfSetLinkInfo$fin$2
-UdfSetRenameInfo
-UdfSetRenameInfo$fin$3
@@ -72,8 +39 @@
-UdfUpdateLvidCounts
-UdfUpdateVcbPhase0
-UdfUpdateVcbPhase0$fin$1
-UdfUpdateVcbPhase1
-UdfUpdateVcbPhase1$fin$0
-UdfVerifyScbBranch
-UdfVmcbContigDirtyBlocksAtVbn
-UdfVmcbSetSectorState
+UdfVerifyVolume
```

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

```diff
--- NTOSKRNL.EXE::ExAcquireFastMutexUnsafe calling
+++ NTOSKRNL.EXE::ExAcquireFastMutexUnsafe calling
@@ -36,0 +37 @@
+UdfPnpCallbackRoutine
@@ -40,0 +42 @@
+UdfPrepareMediaEjectWorker
```

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

```diff
--- NTOSKRNL.EXE::ExFreeToNPagedLookasideList calling
+++ NTOSKRNL.EXE::ExFreeToNPagedLookasideList calling
@@ -4,0 +5 @@
+UdfPnpCallbackRoutine
```

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

```diff
--- NTOSKRNL.EXE::ExAcquireResourceExclusiveLite calling
+++ NTOSKRNL.EXE::ExAcquireResourceExclusiveLite calling
@@ -26,0 +27 @@
+UdfPrepareMediaEjectWorker
```

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

```diff
--- NTOSKRNL.EXE::ExRaiseStatus calling
+++ NTOSKRNL.EXE::ExRaiseStatus calling
@@ -23 +22,0 @@
-UdfInitializeAllocations
```
