From: Pierre Schweitzer <pierre@reactos.org>
Date: Sun, 1 Sep 2019 12:53:20 +0000 (+0200)
Subject: [BTRFS] Upgrade to 1.4
X-Git-Tag: 0.4.14-dev~185
X-Git-Url: https://git.reactos.org/?p=reactos.git;a=commitdiff_plain;h=318da0c18c51da3e93425de65629ae7e222cabc0

[BTRFS] Upgrade to 1.4

CORE-16354
---

diff --git a/dll/shellext/shellbtrfs/contextmenu.cpp b/dll/shellext/shellbtrfs/contextmenu.cpp
index 6e51a0f9eeb..8fcdf2cc551 100644
--- a/dll/shellext/shellbtrfs/contextmenu.cpp
+++ b/dll/shellext/shellbtrfs/contextmenu.cpp
@@ -542,7 +542,7 @@ void BtrfsContextMenu::reflink_copy(HWND hwnd, const WCHAR* fn, const WCHAR* dir
     wstring dirw, newpath;
     FILE_BASIC_INFO fbi;
     FILETIME atime, mtime;
-    btrfs_inode_info2 bii;
+    btrfs_inode_info bii;
     btrfs_set_inode_info bsii;
     ULONG bytesret;
     NTSTATUS Status;
@@ -575,7 +575,7 @@ void BtrfsContextMenu::reflink_copy(HWND hwnd, const WCHAR* fn, const WCHAR* dir
     if (source == INVALID_HANDLE_VALUE)
         throw last_error(GetLastError());
 
-    Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info2));
+    Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info));
     if (!NT_SUCCESS(Status))
         throw ntstatus_error(Status);
 
@@ -1302,7 +1302,7 @@ static void reflink_copy2(const wstring& srcfn, const wstring& destdir, const ws
     win_handle source, dest;
     FILE_BASIC_INFO fbi;
     FILETIME atime, mtime;
-    btrfs_inode_info2 bii;
+    btrfs_inode_info bii;
     btrfs_set_inode_info bsii;
     ULONG bytesret;
     NTSTATUS Status;
@@ -1313,7 +1313,7 @@ static void reflink_copy2(const wstring& srcfn, const wstring& destdir, const ws
     if (source == INVALID_HANDLE_VALUE)
         throw last_error(GetLastError());
 
-    Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info2));
+    Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info));
     if (!NT_SUCCESS(Status))
         throw ntstatus_error(Status);
 
diff --git a/dll/shellext/shellbtrfs/propsheet.cpp b/dll/shellext/shellbtrfs/propsheet.cpp
index 4c3478f9e85..153d6484fb4 100644
--- a/dll/shellext/shellbtrfs/propsheet.cpp
+++ b/dll/shellext/shellbtrfs/propsheet.cpp
@@ -111,11 +111,11 @@ void BtrfsPropSheet::do_search(const wstring& fn) {
                 if (fh != INVALID_HANDLE_VALUE) {
                     NTSTATUS Status;
                     IO_STATUS_BLOCK iosb;
-                    btrfs_inode_info2 bii2;
+                    btrfs_inode_info bii2;
 
                     memset(&bii2, 0, sizeof(bii2));
 
-                    Status = NtFsControlFile(fh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info2));
+                    Status = NtFsControlFile(fh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info));
 
                     if (NT_SUCCESS(Status)) {
                         sizes[0] += bii2.inline_length;
@@ -167,7 +167,7 @@ HRESULT BtrfsPropSheet::check_file(const wstring& fn, UINT i, UINT num_files, UI
     NTSTATUS Status;
     FILE_ACCESS_INFORMATION fai;
     BY_HANDLE_FILE_INFORMATION bhfi;
-    btrfs_inode_info2 bii2;
+    btrfs_inode_info bii2;
 
     h = CreateFileW(fn.c_str(), MAXIMUM_ALLOWED, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
                     OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
@@ -192,7 +192,7 @@ HRESULT BtrfsPropSheet::check_file(const wstring& fn, UINT i, UINT num_files, UI
 
     memset(&bii2, 0, sizeof(bii2));
 
-    Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info2));
+    Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info));
 
     if (NT_SUCCESS(Status) && !bii2.top) {
         LARGE_INTEGER filesize;
@@ -396,7 +396,7 @@ void BtrfsPropSheet::set_cmdline(const wstring& cmdline) {
     NTSTATUS Status;
     UINT sv = 0;
     BY_HANDLE_FILE_INFORMATION bhfi;
-    btrfs_inode_info2 bii2;
+    btrfs_inode_info bii2;
     FILE_ACCESS_INFORMATION fai;
 
     min_mode = 0;
@@ -430,7 +430,7 @@ void BtrfsPropSheet::set_cmdline(const wstring& cmdline) {
 
     memset(&bii2, 0, sizeof(bii2));
 
-    Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info2));
+    Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info));
 
     if (NT_SUCCESS(Status) && !bii2.top) {
         LARGE_INTEGER filesize;
@@ -583,7 +583,7 @@ void BtrfsPropSheet::apply_changes_file(HWND hDlg, const wstring& fn) {
     IO_STATUS_BLOCK iosb;
     NTSTATUS Status;
     btrfs_set_inode_info bsii;
-    btrfs_inode_info2 bii2;
+    btrfs_inode_info bii2;
     ULONG perms = FILE_TRAVERSE | FILE_READ_ATTRIBUTES;
 
     if (flags_changed || ro_changed)
@@ -603,7 +603,7 @@ void BtrfsPropSheet::apply_changes_file(HWND hDlg, const wstring& fn) {
 
     ZeroMemory(&bsii, sizeof(btrfs_set_inode_info));
 
-    Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info2));
+    Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info));
 
     if (!NT_SUCCESS(Status))
         throw ntstatus_error(Status);
diff --git a/drivers/filesystems/btrfs/CMakeLists.txt b/drivers/filesystems/btrfs/CMakeLists.txt
index cd4c76e3501..14e78425fed 100644
--- a/drivers/filesystems/btrfs/CMakeLists.txt
+++ b/drivers/filesystems/btrfs/CMakeLists.txt
@@ -5,6 +5,7 @@ include_directories(${REACTOS_SOURCE_DIR}/sdk/include/reactos/drivers
 
 list(APPEND SOURCE
     balance.c
+    boot.c
     btrfs.c
     cache.c
     calcthread.c
@@ -19,6 +20,7 @@ list(APPEND SOURCE
     flushthread.c
     free-space.c
     fsctl.c
+    fsrtl.c
     galois.c
     guid.c
     pnp.c
@@ -55,6 +57,6 @@ add_library(btrfs MODULE ${SOURCE} btrfs.rc)
 
 add_definitions(-D__KERNEL__)
 set_module_type(btrfs kernelmodedriver)
-target_link_libraries(btrfs rtlver ntoskrnl_vista zlib_solo chkstk wdmguid ${PSEH_LIB})
+target_link_libraries(btrfs rtlver zlib_solo chkstk wdmguid ${PSEH_LIB})
 add_importlibs(btrfs ntoskrnl hal)
 add_cd_file(TARGET btrfs DESTINATION reactos/system32/drivers NO_CAB FOR all)
diff --git a/drivers/filesystems/btrfs/balance.c b/drivers/filesystems/btrfs/balance.c
index 83546f03717..b7794125deb 100644
--- a/drivers/filesystems/btrfs/balance.c
+++ b/drivers/filesystems/btrfs/balance.c
@@ -20,19 +20,19 @@
 #include <ntddstor.h>
 
 typedef struct {
-    UINT64 address;
-    UINT64 new_address;
+    uint64_t address;
+    uint64_t new_address;
     tree_header* data;
     EXTENT_ITEM* ei;
     tree* t;
-    BOOL system;
+    bool system;
     LIST_ENTRY refs;
     LIST_ENTRY list_entry;
 } metadata_reloc;
 
 typedef struct {
-    UINT8 type;
-    UINT64 hash;
+    uint8_t type;
+    uint64_t hash;
 
     union {
         TREE_BLOCK_REF tbr;
@@ -40,14 +40,14 @@ typedef struct {
     };
 
     metadata_reloc* parent;
-    BOOL top;
+    bool top;
     LIST_ENTRY list_entry;
 } metadata_reloc_ref;
 
 typedef struct {
-    UINT64 address;
-    UINT64 size;
-    UINT64 new_address;
+    uint64_t address;
+    uint64_t size;
+    uint64_t new_address;
     chunk* newchunk;
     EXTENT_ITEM* ei;
     LIST_ENTRY refs;
@@ -55,8 +55,8 @@ typedef struct {
 } data_reloc;
 
 typedef struct {
-    UINT8 type;
-    UINT64 hash;
+    uint8_t type;
+    uint64_t hash;
 
     union {
         EXTENT_DATA_REF edr;
@@ -67,22 +67,20 @@ typedef struct {
     LIST_ENTRY list_entry;
 } data_reloc_ref;
 
-#ifndef __REACTOS__
 #ifndef _MSC_VER // not in mingw yet
 #define DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED 0x80000000
 #endif
-#endif
 
 #define BALANCE_UNIT 0x100000 // only read 1 MB at a time
 
 static NTSTATUS add_metadata_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, LIST_ENTRY* items, traverse_ptr* tp,
-                                   BOOL skinny, metadata_reloc** mr2, chunk* c, LIST_ENTRY* rollback) {
+                                   bool skinny, metadata_reloc** mr2, chunk* c, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     metadata_reloc* mr;
     EXTENT_ITEM* ei;
-    UINT16 len;
-    UINT64 inline_rc;
-    UINT8* ptr;
+    uint16_t len;
+    uint64_t inline_rc;
+    uint8_t* ptr;
 
     mr = ExAllocatePoolWithTag(PagedPool, sizeof(metadata_reloc), ALLOC_TAG);
     if (!mr) {
@@ -93,7 +91,7 @@ static NTSTATUS add_metadata_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_l
     mr->address = tp->item->key.obj_id;
     mr->data = NULL;
     mr->ei = (EXTENT_ITEM*)tp->item->data;
-    mr->system = FALSE;
+    mr->system = false;
     InitializeListHead(&mr->refs);
 
     Status = delete_tree_item(Vcb, tp);
@@ -120,26 +118,26 @@ static NTSTATUS add_metadata_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_l
     inline_rc = 0;
 
     len = tp->item->size - sizeof(EXTENT_ITEM);
-    ptr = (UINT8*)tp->item->data + sizeof(EXTENT_ITEM);
+    ptr = (uint8_t*)tp->item->data + sizeof(EXTENT_ITEM);
     if (!skinny) {
         len -= sizeof(EXTENT_ITEM2);
         ptr += sizeof(EXTENT_ITEM2);
     }
 
     while (len > 0) {
-        UINT8 secttype = *ptr;
-        UINT16 sectlen = secttype == TYPE_TREE_BLOCK_REF ? sizeof(TREE_BLOCK_REF) : (secttype == TYPE_SHARED_BLOCK_REF ? sizeof(SHARED_BLOCK_REF) : 0);
+        uint8_t secttype = *ptr;
+        uint16_t sectlen = secttype == TYPE_TREE_BLOCK_REF ? sizeof(TREE_BLOCK_REF) : (secttype == TYPE_SHARED_BLOCK_REF ? sizeof(SHARED_BLOCK_REF) : 0);
         metadata_reloc_ref* ref;
 
         len--;
 
         if (sectlen > len) {
-            ERR("(%llx,%x,%llx): %x bytes left, expecting at least %x\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset, len, sectlen);
+            ERR("(%I64x,%x,%I64x): %x bytes left, expecting at least %x\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset, len, sectlen);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (sectlen == 0) {
-            ERR("(%llx,%x,%llx): unrecognized extent type %x\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset, secttype);
+            ERR("(%I64x,%x,%I64x): unrecognized extent type %x\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset, secttype);
             return STATUS_INTERNAL_ERROR;
         }
 
@@ -151,11 +149,11 @@ static NTSTATUS add_metadata_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_l
 
         if (secttype == TYPE_TREE_BLOCK_REF) {
             ref->type = TYPE_TREE_BLOCK_REF;
-            RtlCopyMemory(&ref->tbr, ptr + sizeof(UINT8), sizeof(TREE_BLOCK_REF));
+            RtlCopyMemory(&ref->tbr, ptr + sizeof(uint8_t), sizeof(TREE_BLOCK_REF));
             inline_rc++;
         } else if (secttype == TYPE_SHARED_BLOCK_REF) {
             ref->type = TYPE_SHARED_BLOCK_REF;
-            RtlCopyMemory(&ref->sbr, ptr + sizeof(UINT8), sizeof(SHARED_BLOCK_REF));
+            RtlCopyMemory(&ref->sbr, ptr + sizeof(uint8_t), sizeof(SHARED_BLOCK_REF));
             inline_rc++;
         } else {
             ERR("unexpected tree type %x\n", secttype);
@@ -164,17 +162,17 @@ static NTSTATUS add_metadata_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_l
         }
 
         ref->parent = NULL;
-        ref->top = FALSE;
+        ref->top = false;
         InsertTailList(&mr->refs, &ref->list_entry);
 
         len -= sectlen;
-        ptr += sizeof(UINT8) + sectlen;
+        ptr += sizeof(uint8_t) + sectlen;
     }
 
     if (inline_rc < ei->refcount) { // look for non-inline entries
         traverse_ptr tp2 = *tp, next_tp;
 
-        while (find_next_item(Vcb, &tp2, &next_tp, FALSE, NULL)) {
+        while (find_next_item(Vcb, &tp2, &next_tp, false, NULL)) {
             tp2 = next_tp;
 
             if (tp2.item->key.obj_id == tp->item->key.obj_id) {
@@ -188,7 +186,7 @@ static NTSTATUS add_metadata_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_l
                     ref->type = TYPE_TREE_BLOCK_REF;
                     ref->tbr.offset = tp2.item->key.offset;
                     ref->parent = NULL;
-                    ref->top = FALSE;
+                    ref->top = false;
                     InsertTailList(&mr->refs, &ref->list_entry);
 
                     Status = delete_tree_item(Vcb, &tp2);
@@ -206,7 +204,7 @@ static NTSTATUS add_metadata_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_l
                     ref->type = TYPE_SHARED_BLOCK_REF;
                     ref->sbr.offset = tp2.item->key.offset;
                     ref->parent = NULL;
-                    ref->top = FALSE;
+                    ref->top = false;
                     InsertTailList(&mr->refs, &ref->list_entry);
 
                     Status = delete_tree_item(Vcb, &tp2);
@@ -229,11 +227,11 @@ static NTSTATUS add_metadata_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_l
 }
 
 static NTSTATUS add_metadata_reloc_parent(_Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, LIST_ENTRY* items,
-                                          UINT64 address, metadata_reloc** mr2, LIST_ENTRY* rollback) {
+                                          uint64_t address, metadata_reloc** mr2, LIST_ENTRY* rollback) {
     LIST_ENTRY* le;
     KEY searchkey;
     traverse_ptr tp;
-    BOOL skinny = FALSE;
+    bool skinny = false;
     NTSTATUS Status;
 
     le = items->Flink;
@@ -252,24 +250,24 @@ static NTSTATUS add_metadata_reloc_parent(_Requires_exclusive_lock_held_(_Curr_-
     searchkey.obj_type = TYPE_METADATA_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
     }
 
     if (tp.item->key.obj_id == address && tp.item->key.obj_type == TYPE_METADATA_ITEM && tp.item->size >= sizeof(EXTENT_ITEM))
-        skinny = TRUE;
+        skinny = true;
     else if (tp.item->key.obj_id == address && tp.item->key.obj_type == TYPE_EXTENT_ITEM && tp.item->key.offset == Vcb->superblock.node_size &&
              tp.item->size >= sizeof(EXTENT_ITEM)) {
         EXTENT_ITEM* ei = (EXTENT_ITEM*)tp.item->data;
 
         if (!(ei->flags & EXTENT_ITEM_TREE_BLOCK)) {
-            ERR("EXTENT_ITEM for %llx found, but tree flag not set\n", address);
+            ERR("EXTENT_ITEM for %I64x found, but tree flag not set\n", address);
             return STATUS_INTERNAL_ERROR;
         }
     } else {
-        ERR("could not find valid EXTENT_ITEM for address %llx\n", address);
+        ERR("could not find valid EXTENT_ITEM for address %I64x\n", address);
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -294,7 +292,7 @@ static void sort_metadata_reloc_refs(metadata_reloc* mr) {
 
     while (!IsListEmpty(&mr->refs)) {
         metadata_reloc_ref* ref = CONTAINING_RECORD(RemoveHeadList(&mr->refs), metadata_reloc_ref, list_entry);
-        BOOL inserted = FALSE;
+        bool inserted = false;
 
         if (ref->type == TYPE_TREE_BLOCK_REF)
             ref->hash = ref->tbr.offset;
@@ -307,7 +305,7 @@ static void sort_metadata_reloc_refs(metadata_reloc* mr) {
 
             if (ref->type < ref2->type || (ref->type == ref2->type && ref->hash > ref2->hash)) {
                 InsertHeadList(le->Blink, &ref->list_entry);
-                inserted = TRUE;
+                inserted = true;
                 break;
             }
 
@@ -327,12 +325,12 @@ static void sort_metadata_reloc_refs(metadata_reloc* mr) {
 static NTSTATUS add_metadata_reloc_extent_item(_Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, metadata_reloc* mr) {
     NTSTATUS Status;
     LIST_ENTRY* le;
-    UINT64 rc = 0;
-    UINT16 inline_len;
-    BOOL all_inline = TRUE;
+    uint64_t rc = 0;
+    uint16_t inline_len;
+    bool all_inline = true;
     metadata_reloc_ref* first_noninline = NULL;
     EXTENT_ITEM* ei;
-    UINT8* ptr;
+    uint8_t* ptr;
 
     inline_len = sizeof(EXTENT_ITEM);
     if (!(Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA))
@@ -343,7 +341,7 @@ static NTSTATUS add_metadata_reloc_extent_item(_Requires_exclusive_lock_held_(_C
     le = mr->refs.Flink;
     while (le != &mr->refs) {
         metadata_reloc_ref* ref = CONTAINING_RECORD(le, metadata_reloc_ref, list_entry);
-        UINT16 extlen = 0;
+        uint16_t extlen = 0;
 
         rc++;
 
@@ -354,7 +352,7 @@ static NTSTATUS add_metadata_reloc_extent_item(_Requires_exclusive_lock_held_(_C
 
         if (all_inline) {
             if ((ULONG)(inline_len + 1 + extlen) > (Vcb->superblock.node_size >> 2)) {
-                all_inline = FALSE;
+                all_inline = false;
                 first_noninline = ref;
             } else
                 inline_len += extlen + 1;
@@ -372,7 +370,7 @@ static NTSTATUS add_metadata_reloc_extent_item(_Requires_exclusive_lock_held_(_C
     ei->refcount = rc;
     ei->generation = mr->ei->generation;
     ei->flags = mr->ei->flags;
-    ptr = (UINT8*)&ei[1];
+    ptr = (uint8_t*)&ei[1];
 
     if (!(Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA)) {
         EXTENT_ITEM2* ei2 = (EXTENT_ITEM2*)ptr;
@@ -447,11 +445,11 @@ static NTSTATUS add_metadata_reloc_extent_item(_Requires_exclusive_lock_held_(_C
 
     if (ei->flags & EXTENT_ITEM_SHARED_BACKREFS || mr->data->flags & HEADER_FLAG_SHARED_BACKREF || !(mr->data->flags & HEADER_FLAG_MIXED_BACKREF)) {
         if (mr->data->level > 0) {
-            UINT16 i;
+            uint16_t i;
             internal_node* in = (internal_node*)&mr->data[1];
 
             for (i = 0; i < mr->data->num_items; i++) {
-                UINT64 sbrrc = find_extent_shared_tree_refcount(Vcb, in[i].address, mr->address, NULL);
+                uint64_t sbrrc = find_extent_shared_tree_refcount(Vcb, in[i].address, mr->address, NULL);
 
                 if (sbrrc > 0) {
                     SHARED_BLOCK_REF sbr;
@@ -467,7 +465,7 @@ static NTSTATUS add_metadata_reloc_extent_item(_Requires_exclusive_lock_held_(_C
                     sbr.offset = mr->address;
 
                     Status = decrease_extent_refcount(Vcb, in[i].address, Vcb->superblock.node_size, TYPE_SHARED_BLOCK_REF, &sbr, NULL, 0,
-                                                      sbr.offset, FALSE, NULL);
+                                                      sbr.offset, false, NULL);
                     if (!NT_SUCCESS(Status)) {
                         ERR("decrease_extent_refcount returned %08x\n", Status);
                         return Status;
@@ -475,18 +473,18 @@ static NTSTATUS add_metadata_reloc_extent_item(_Requires_exclusive_lock_held_(_C
                 }
             }
         } else {
-            UINT16 i;
+            uint16_t i;
             leaf_node* ln = (leaf_node*)&mr->data[1];
 
             for (i = 0; i < mr->data->num_items; i++) {
                 if (ln[i].key.obj_type == TYPE_EXTENT_DATA && ln[i].size >= sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2)) {
-                    EXTENT_DATA* ed = (EXTENT_DATA*)((UINT8*)mr->data + sizeof(tree_header) + ln[i].offset);
+                    EXTENT_DATA* ed = (EXTENT_DATA*)((uint8_t*)mr->data + sizeof(tree_header) + ln[i].offset);
 
                     if (ed->type == EXTENT_TYPE_REGULAR || ed->type == EXTENT_TYPE_PREALLOC) {
                         EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ed->data;
 
                         if (ed2->size > 0) { // not sparse
-                            UINT32 sdrrc = find_extent_shared_data_refcount(Vcb, ed2->address, mr->address, NULL);
+                            uint32_t sdrrc = find_extent_shared_data_refcount(Vcb, ed2->address, mr->address, NULL);
 
                             if (sdrrc > 0) {
                                 SHARED_DATA_REF sdr;
@@ -504,7 +502,7 @@ static NTSTATUS add_metadata_reloc_extent_item(_Requires_exclusive_lock_held_(_C
                                 sdr.offset = mr->address;
 
                                 Status = decrease_extent_refcount(Vcb, ed2->address, ed2->size, TYPE_SHARED_DATA_REF, &sdr, NULL, 0,
-                                                                  sdr.offset, FALSE, NULL);
+                                                                  sdr.offset, false, NULL);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("decrease_extent_refcount returned %08x\n", Status);
                                     return Status;
@@ -515,7 +513,7 @@ static NTSTATUS add_metadata_reloc_extent_item(_Requires_exclusive_lock_held_(_C
                                 if (c) {
                                     // check changed_extents
 
-                                    ExAcquireResourceExclusiveLite(&c->changed_extents_lock, TRUE);
+                                    ExAcquireResourceExclusiveLite(&c->changed_extents_lock, true);
 
                                     le = c->changed_extents.Flink;
 
@@ -573,7 +571,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
     LIST_ENTRY tree_writes, *le;
     NTSTATUS Status;
     traverse_ptr tp;
-    UINT8 level, max_level = 0;
+    uint8_t level, max_level = 0;
     chunk* newchunk = NULL;
 
     InitializeListHead(&tree_writes);
@@ -590,26 +588,26 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
             return STATUS_INSUFFICIENT_RESOURCES;
         }
 
-        Status = read_data(Vcb, mr->address, Vcb->superblock.node_size, NULL, TRUE, (UINT8*)mr->data,
-                           c && mr->address >= c->offset && mr->address < c->offset + c->chunk_item->size ? c : NULL, &pc, NULL, 0, FALSE, NormalPagePriority);
+        Status = read_data(Vcb, mr->address, Vcb->superblock.node_size, NULL, true, (uint8_t*)mr->data,
+                           c && mr->address >= c->offset && mr->address < c->offset + c->chunk_item->size ? c : NULL, &pc, NULL, 0, false, NormalPagePriority);
         if (!NT_SUCCESS(Status)) {
             ERR("read_data returned %08x\n", Status);
             return Status;
         }
 
         if (pc->chunk_item->type & BLOCK_FLAG_SYSTEM)
-            mr->system = TRUE;
+            mr->system = true;
 
         if (data_items && mr->data->level == 0) {
             le2 = data_items->Flink;
             while (le2 != data_items) {
                 data_reloc* dr = CONTAINING_RECORD(le2, data_reloc, list_entry);
                 leaf_node* ln = (leaf_node*)&mr->data[1];
-                UINT16 i;
+                uint16_t i;
 
                 for (i = 0; i < mr->data->num_items; i++) {
                     if (ln[i].key.obj_type == TYPE_EXTENT_DATA && ln[i].size >= sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2)) {
-                        EXTENT_DATA* ed = (EXTENT_DATA*)((UINT8*)mr->data + sizeof(tree_header) + ln[i].offset);
+                        EXTENT_DATA* ed = (EXTENT_DATA*)((uint8_t*)mr->data + sizeof(tree_header) + ln[i].offset);
 
                         if (ed->type == EXTENT_TYPE_REGULAR || ed->type == EXTENT_TYPE_PREALLOC) {
                             EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ed->data;
@@ -652,11 +650,11 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
                 }
 
                 if (!r) {
-                    ERR("could not find subvol with id %llx\n", ref->tbr.offset);
+                    ERR("could not find subvol with id %I64x\n", ref->tbr.offset);
                     return STATUS_INTERNAL_ERROR;
                 }
 
-                Status = find_item_to_level(Vcb, r, &tp, firstitem, FALSE, mr->data->level + 1, NULL);
+                Status = find_item_to_level(Vcb, r, &tp, firstitem, false, mr->data->level + 1, NULL);
                 if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND) {
                     ERR("find_item_to_level returned %08x\n", Status);
                     return Status;
@@ -668,7 +666,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
                 }
 
                 if (!t)
-                    ref->top = TRUE;
+                    ref->top = true;
                 else {
                     metadata_reloc* mr2;
 
@@ -702,11 +700,11 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
     while (le != items) {
         metadata_reloc* mr = CONTAINING_RECORD(le, metadata_reloc, list_entry);
         LIST_ENTRY* le2;
-        UINT32 hash;
+        uint32_t hash;
 
         mr->t = NULL;
 
-        hash = calc_crc32c(0xffffffff, (UINT8*)&mr->address, sizeof(UINT64));
+        hash = calc_crc32c(0xffffffff, (uint8_t*)&mr->address, sizeof(uint64_t));
 
         le2 = Vcb->trees_ptrs[hash >> 24];
 
@@ -733,10 +731,10 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
             metadata_reloc* mr = CONTAINING_RECORD(le, metadata_reloc, list_entry);
 
             if (mr->data->level == level) {
-                BOOL done = FALSE;
+                bool done = false;
                 LIST_ENTRY* le2;
                 tree_write* tw;
-                UINT64 flags;
+                uint64_t flags;
                 tree* t3;
 
                 if (mr->system)
@@ -751,15 +749,15 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
 
                     if (newchunk->chunk_item->type == flags && find_metadata_address_in_chunk(Vcb, newchunk, &mr->new_address)) {
                         newchunk->used += Vcb->superblock.node_size;
-                        space_list_subtract(newchunk, FALSE, mr->new_address, Vcb->superblock.node_size, rollback);
-                        done = TRUE;
+                        space_list_subtract(newchunk, false, mr->new_address, Vcb->superblock.node_size, rollback);
+                        done = true;
                     }
 
                     release_chunk_lock(newchunk, Vcb);
                 }
 
                 if (!done) {
-                    ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE);
+                    ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
                     le2 = Vcb->chunks.Flink;
                     while (le2 != &Vcb->chunks) {
@@ -771,10 +769,10 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
                             if ((c2->chunk_item->size - c2->used) >= Vcb->superblock.node_size) {
                                 if (find_metadata_address_in_chunk(Vcb, c2, &mr->new_address)) {
                                     c2->used += Vcb->superblock.node_size;
-                                    space_list_subtract(c2, FALSE, mr->new_address, Vcb->superblock.node_size, rollback);
+                                    space_list_subtract(c2, false, mr->new_address, Vcb->superblock.node_size, rollback);
                                     release_chunk_lock(c2, Vcb);
                                     newchunk = c2;
-                                    done = TRUE;
+                                    done = true;
                                     break;
                                 }
                             }
@@ -787,7 +785,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
 
                     // allocate new chunk if necessary
                     if (!done) {
-                        Status = alloc_chunk(Vcb, flags, &newchunk, FALSE);
+                        Status = alloc_chunk(Vcb, flags, &newchunk, false);
 
                         if (!NT_SUCCESS(Status)) {
                             ERR("alloc_chunk returned %08x\n", Status);
@@ -807,7 +805,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
                             goto end;
                         } else {
                             newchunk->used += Vcb->superblock.node_size;
-                            space_list_subtract(newchunk, FALSE, mr->new_address, Vcb->superblock.node_size, rollback);
+                            space_list_subtract(newchunk, false, mr->new_address, Vcb->superblock.node_size, rollback);
                         }
 
                         release_chunk_lock(newchunk, Vcb);
@@ -822,7 +820,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
                     metadata_reloc_ref* ref = CONTAINING_RECORD(le2, metadata_reloc_ref, list_entry);
 
                     if (ref->parent) {
-                        UINT16 i;
+                        uint16_t i;
                         internal_node* in = (internal_node*)&ref->parent->data[1];
 
                         for (i = 0; i < ref->parent->data->num_items; i++) {
@@ -880,14 +878,14 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
                                 searchkey.obj_type = TYPE_ROOT_ITEM;
                                 searchkey.offset = 0xffffffffffffffff;
 
-                                Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, NULL);
+                                Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, NULL);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("find_item returned %08x\n", Status);
                                     goto end;
                                 }
 
                                 if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-                                    ERR("could not find ROOT_ITEM for tree %llx\n", searchkey.obj_id);
+                                    ERR("could not find ROOT_ITEM for tree %I64x\n", searchkey.obj_id);
                                     Status = STATUS_INTERNAL_ERROR;
                                     goto end;
                                 }
@@ -924,8 +922,8 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
                 t3 = mr->t;
 
                 while (t3) {
-                    UINT8 h;
-                    BOOL inserted;
+                    uint8_t h;
+                    bool inserted;
                     tree* t4 = NULL;
 
                     // check if tree loaded more than once
@@ -955,11 +953,11 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
 
                     RemoveEntryList(&t3->list_entry_hash);
 
-                    t3->hash = calc_crc32c(0xffffffff, (UINT8*)&t3->header.address, sizeof(UINT64));
+                    t3->hash = calc_crc32c(0xffffffff, (uint8_t*)&t3->header.address, sizeof(uint64_t));
                     h = t3->hash >> 24;
 
                     if (!Vcb->trees_ptrs[h]) {
-                        UINT8 h2 = h;
+                        uint8_t h2 = h;
 
                         le2 = Vcb->trees_hash.Flink;
 
@@ -977,13 +975,13 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
                     } else
                         le2 = Vcb->trees_ptrs[h];
 
-                    inserted = FALSE;
+                    inserted = false;
                     while (le2 != &Vcb->trees_hash) {
                         tree* t2 = CONTAINING_RECORD(le2, tree, list_entry_hash);
 
                         if (t2->hash >= t3->hash) {
                             InsertHeadList(le2->Blink, &t3->list_entry_hash);
-                            inserted = TRUE;
+                            inserted = true;
                             break;
                         }
 
@@ -1027,7 +1025,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
                     t3 = t4;
                 }
 
-                *((UINT32*)mr->data) = ~calc_crc32c(0xffffffff, (UINT8*)&mr->data->fs_uuid, Vcb->superblock.node_size - sizeof(mr->data->csum));
+                *((uint32_t*)mr->data) = ~calc_crc32c(0xffffffff, (uint8_t*)&mr->data->fs_uuid, Vcb->superblock.node_size - sizeof(mr->data->csum));
 
                 tw = ExAllocatePoolWithTag(PagedPool, sizeof(tree_write), ALLOC_TAG);
                 if (!tw) {
@@ -1038,12 +1036,12 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
 
                 tw->address = mr->new_address;
                 tw->length = Vcb->superblock.node_size;
-                tw->data = (UINT8*)mr->data;
+                tw->data = (uint8_t*)mr->data;
 
                 if (IsListEmpty(&tree_writes))
                     InsertTailList(&tree_writes, &tw->list_entry);
                 else {
-                    BOOL inserted = FALSE;
+                    bool inserted = false;
 
                     le2 = tree_writes.Flink;
                     while (le2 != &tree_writes) {
@@ -1051,7 +1049,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
 
                         if (tw2->address > tw->address) {
                             InsertHeadList(le2->Blink, &tw->list_entry);
-                            inserted = TRUE;
+                            inserted = true;
                             break;
                         }
 
@@ -1067,7 +1065,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree
         }
     }
 
-    Status = do_tree_writes(Vcb, &tree_writes, TRUE);
+    Status = do_tree_writes(Vcb, &tree_writes, true);
     if (!NT_SUCCESS(Status)) {
         ERR("do_tree_writes returned %08x\n", Status);
         goto end;
@@ -1097,26 +1095,26 @@ end:
     return Status;
 }
 
-static NTSTATUS balance_metadata_chunk(device_extension* Vcb, chunk* c, BOOL* changed) {
+static NTSTATUS balance_metadata_chunk(device_extension* Vcb, chunk* c, bool* changed) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
-    BOOL b;
+    bool b;
     LIST_ENTRY items, rollback;
-    UINT32 loaded = 0;
+    uint32_t loaded = 0;
 
-    TRACE("chunk %llx\n", c->offset);
+    TRACE("chunk %I64x\n", c->offset);
 
     InitializeListHead(&rollback);
     InitializeListHead(&items);
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     searchkey.obj_id = c->offset;
     searchkey.obj_type = TYPE_METADATA_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         goto end;
@@ -1129,17 +1127,17 @@ static NTSTATUS balance_metadata_chunk(device_extension* Vcb, chunk* c, BOOL* ch
             break;
 
         if (tp.item->key.obj_id >= c->offset && (tp.item->key.obj_type == TYPE_EXTENT_ITEM || tp.item->key.obj_type == TYPE_METADATA_ITEM)) {
-            BOOL tree = FALSE, skinny = FALSE;
+            bool tree = false, skinny = false;
 
             if (tp.item->key.obj_type == TYPE_METADATA_ITEM && tp.item->size >= sizeof(EXTENT_ITEM)) {
-                tree = TRUE;
-                skinny = TRUE;
+                tree = true;
+                skinny = true;
             } else if (tp.item->key.obj_type == TYPE_EXTENT_ITEM && tp.item->key.offset == Vcb->superblock.node_size &&
                        tp.item->size >= sizeof(EXTENT_ITEM)) {
                 EXTENT_ITEM* ei = (EXTENT_ITEM*)tp.item->data;
 
                 if (ei->flags & EXTENT_ITEM_TREE_BLOCK)
-                    tree = TRUE;
+                    tree = true;
             }
 
             if (tree) {
@@ -1157,18 +1155,18 @@ static NTSTATUS balance_metadata_chunk(device_extension* Vcb, chunk* c, BOOL* ch
             }
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, NULL);
+        b = find_next_item(Vcb, &tp, &next_tp, false, NULL);
 
         if (b)
             tp = next_tp;
     } while (b);
 
     if (IsListEmpty(&items)) {
-        *changed = FALSE;
+        *changed = false;
         Status = STATUS_SUCCESS;
         goto end;
     } else
-        *changed = TRUE;
+        *changed = true;
 
     Status = write_metadata_items(Vcb, &items, NULL, c, &rollback);
     if (!NT_SUCCESS(Status)) {
@@ -1178,7 +1176,7 @@ static NTSTATUS balance_metadata_chunk(device_extension* Vcb, chunk* c, BOOL* ch
 
     Status = STATUS_SUCCESS;
 
-    Vcb->need_write = TRUE;
+    Vcb->need_write = true;
 
 end:
     if (NT_SUCCESS(Status)) {
@@ -1219,7 +1217,7 @@ static NTSTATUS data_reloc_add_tree_edr(_Requires_lock_held_(_Curr_->tree_lock)
     traverse_ptr tp;
     root* r = NULL;
     metadata_reloc* mr;
-    UINT64 last_tree = 0;
+    uint64_t last_tree = 0;
     data_reloc_ref* ref;
 
     le = Vcb->roots.Flink;
@@ -1235,7 +1233,7 @@ static NTSTATUS data_reloc_add_tree_edr(_Requires_lock_held_(_Curr_->tree_lock)
     }
 
     if (!r) {
-        ERR("could not find subvol %llx\n", edr->count);
+        ERR("could not find subvol %I64x\n", edr->count);
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -1243,7 +1241,7 @@ static NTSTATUS data_reloc_add_tree_edr(_Requires_lock_held_(_Curr_->tree_lock)
     searchkey.obj_type = TYPE_EXTENT_DATA;
     searchkey.offset = 0;
 
-    Status = find_item(Vcb, r, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, r, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
@@ -1252,10 +1250,10 @@ static NTSTATUS data_reloc_add_tree_edr(_Requires_lock_held_(_Curr_->tree_lock)
     if (tp.item->key.obj_id < searchkey.obj_id || (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type < searchkey.obj_type)) {
         traverse_ptr tp2;
 
-        if (find_next_item(Vcb, &tp, &tp2, FALSE, NULL))
+        if (find_next_item(Vcb, &tp, &tp2, false, NULL))
             tp = tp2;
         else {
-            ERR("could not find EXTENT_DATA for inode %llx in root %llx\n", searchkey.obj_id, r->id);
+            ERR("could not find EXTENT_DATA for inode %I64x in root %I64x\n", searchkey.obj_id, r->id);
             return STATUS_INTERNAL_ERROR;
         }
     }
@@ -1301,7 +1299,7 @@ static NTSTATUS data_reloc_add_tree_edr(_Requires_lock_held_(_Curr_->tree_lock)
             }
         }
 
-        if (find_next_item(Vcb, &tp, &tp2, FALSE, NULL))
+        if (find_next_item(Vcb, &tp, &tp2, false, NULL))
             tp = tp2;
         else
             break;
@@ -1315,9 +1313,9 @@ static NTSTATUS add_data_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
     NTSTATUS Status;
     data_reloc* dr;
     EXTENT_ITEM* ei;
-    UINT16 len;
-    UINT64 inline_rc;
-    UINT8* ptr;
+    uint16_t len;
+    uint64_t inline_rc;
+    uint8_t* ptr;
 
     dr = ExAllocatePoolWithTag(PagedPool, sizeof(data_reloc), ALLOC_TAG);
     if (!dr) {
@@ -1353,26 +1351,26 @@ static NTSTATUS add_data_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
     inline_rc = 0;
 
     len = tp->item->size - sizeof(EXTENT_ITEM);
-    ptr = (UINT8*)tp->item->data + sizeof(EXTENT_ITEM);
+    ptr = (uint8_t*)tp->item->data + sizeof(EXTENT_ITEM);
 
     while (len > 0) {
-        UINT8 secttype = *ptr;
-        UINT16 sectlen = secttype == TYPE_EXTENT_DATA_REF ? sizeof(EXTENT_DATA_REF) : (secttype == TYPE_SHARED_DATA_REF ? sizeof(SHARED_DATA_REF) : 0);
+        uint8_t secttype = *ptr;
+        uint16_t sectlen = secttype == TYPE_EXTENT_DATA_REF ? sizeof(EXTENT_DATA_REF) : (secttype == TYPE_SHARED_DATA_REF ? sizeof(SHARED_DATA_REF) : 0);
 
         len--;
 
         if (sectlen > len) {
-            ERR("(%llx,%x,%llx): %x bytes left, expecting at least %x\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset, len, sectlen);
+            ERR("(%I64x,%x,%I64x): %x bytes left, expecting at least %x\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset, len, sectlen);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (sectlen == 0) {
-            ERR("(%llx,%x,%llx): unrecognized extent type %x\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset, secttype);
+            ERR("(%I64x,%x,%I64x): unrecognized extent type %x\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset, secttype);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (secttype == TYPE_EXTENT_DATA_REF) {
-            EXTENT_DATA_REF* edr = (EXTENT_DATA_REF*)(ptr + sizeof(UINT8));
+            EXTENT_DATA_REF* edr = (EXTENT_DATA_REF*)(ptr + sizeof(uint8_t));
 
             inline_rc += edr->count;
 
@@ -1392,7 +1390,7 @@ static NTSTATUS add_data_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
             }
 
             ref->type = TYPE_SHARED_DATA_REF;
-            RtlCopyMemory(&ref->sdr, ptr + sizeof(UINT8), sizeof(SHARED_DATA_REF));
+            RtlCopyMemory(&ref->sdr, ptr + sizeof(uint8_t), sizeof(SHARED_DATA_REF));
             inline_rc += ref->sdr.count;
 
             Status = add_metadata_reloc_parent(Vcb, metadata_items, ref->sdr.offset, &mr, rollback);
@@ -1412,13 +1410,13 @@ static NTSTATUS add_data_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
 
 
         len -= sectlen;
-        ptr += sizeof(UINT8) + sectlen;
+        ptr += sizeof(uint8_t) + sectlen;
     }
 
     if (inline_rc < ei->refcount) { // look for non-inline entries
         traverse_ptr tp2 = *tp, next_tp;
 
-        while (find_next_item(Vcb, &tp2, &next_tp, FALSE, NULL)) {
+        while (find_next_item(Vcb, &tp2, &next_tp, false, NULL)) {
             tp2 = next_tp;
 
             if (tp2.item->key.obj_id == tp->item->key.obj_id) {
@@ -1434,7 +1432,7 @@ static NTSTATUS add_data_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
                         ERR("delete_tree_item returned %08x\n", Status);
                         return Status;
                     }
-                } else if (tp2.item->key.obj_type == TYPE_SHARED_DATA_REF && tp2.item->size >= sizeof(UINT32)) {
+                } else if (tp2.item->key.obj_type == TYPE_SHARED_DATA_REF && tp2.item->size >= sizeof(uint32_t)) {
                     metadata_reloc* mr;
                     data_reloc_ref* ref;
 
@@ -1446,7 +1444,7 @@ static NTSTATUS add_data_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
 
                     ref->type = TYPE_SHARED_DATA_REF;
                     ref->sdr.offset = tp2.item->key.offset;
-                    ref->sdr.count = *((UINT32*)tp2.item->data);
+                    ref->sdr.count = *((uint32_t*)tp2.item->data);
 
                     Status = add_metadata_reloc_parent(Vcb, metadata_items, ref->sdr.offset, &mr, rollback);
                     if (!NT_SUCCESS(Status)) {
@@ -1486,7 +1484,7 @@ static void sort_data_reloc_refs(data_reloc* dr) {
 
     while (!IsListEmpty(&dr->refs)) {
         data_reloc_ref* ref = CONTAINING_RECORD(RemoveHeadList(&dr->refs), data_reloc_ref, list_entry);
-        BOOL inserted = FALSE;
+        bool inserted = false;
 
         if (ref->type == TYPE_EXTENT_DATA_REF)
             ref->hash = get_extent_data_ref_hash2(ref->edr.root, ref->edr.objid, ref->edr.offset);
@@ -1499,7 +1497,7 @@ static void sort_data_reloc_refs(data_reloc* dr) {
 
             if (ref->type < ref2->type || (ref->type == ref2->type && ref->hash > ref2->hash)) {
                 InsertHeadList(le->Blink, &ref->list_entry);
-                inserted = TRUE;
+                inserted = true;
                 break;
             }
 
@@ -1538,12 +1536,12 @@ static void sort_data_reloc_refs(data_reloc* dr) {
 static NTSTATUS add_data_reloc_extent_item(_Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, data_reloc* dr) {
     NTSTATUS Status;
     LIST_ENTRY* le;
-    UINT64 rc = 0;
-    UINT16 inline_len;
-    BOOL all_inline = TRUE;
+    uint64_t rc = 0;
+    uint16_t inline_len;
+    bool all_inline = true;
     data_reloc_ref* first_noninline = NULL;
     EXTENT_ITEM* ei;
-    UINT8* ptr;
+    uint8_t* ptr;
 
     inline_len = sizeof(EXTENT_ITEM);
 
@@ -1552,7 +1550,7 @@ static NTSTATUS add_data_reloc_extent_item(_Requires_exclusive_lock_held_(_Curr_
     le = dr->refs.Flink;
     while (le != &dr->refs) {
         data_reloc_ref* ref = CONTAINING_RECORD(le, data_reloc_ref, list_entry);
-        UINT16 extlen = 0;
+        uint16_t extlen = 0;
 
         if (ref->type == TYPE_EXTENT_DATA_REF) {
             extlen += sizeof(EXTENT_DATA_REF);
@@ -1564,7 +1562,7 @@ static NTSTATUS add_data_reloc_extent_item(_Requires_exclusive_lock_held_(_Curr_
 
         if (all_inline) {
             if ((ULONG)(inline_len + 1 + extlen) > (Vcb->superblock.node_size >> 2)) {
-                all_inline = FALSE;
+                all_inline = false;
                 first_noninline = ref;
             } else
                 inline_len += extlen + 1;
@@ -1582,7 +1580,7 @@ static NTSTATUS add_data_reloc_extent_item(_Requires_exclusive_lock_held_(_Curr_
     ei->refcount = rc;
     ei->generation = dr->ei->generation;
     ei->flags = dr->ei->flags;
-    ptr = (UINT8*)&ei[1];
+    ptr = (uint8_t*)&ei[1];
 
     le = dr->refs.Flink;
     while (le != &dr->refs) {
@@ -1641,9 +1639,9 @@ static NTSTATUS add_data_reloc_extent_item(_Requires_exclusive_lock_held_(_Curr_
                     return Status;
                 }
             } else if (ref->type == TYPE_SHARED_DATA_REF) {
-                UINT32* sdr;
+                uint32_t* sdr;
 
-                sdr = ExAllocatePoolWithTag(PagedPool, sizeof(UINT32), ALLOC_TAG);
+                sdr = ExAllocatePoolWithTag(PagedPool, sizeof(uint32_t), ALLOC_TAG);
                 if (!sdr) {
                     ERR("out of memory\n");
                     return STATUS_INSUFFICIENT_RESOURCES;
@@ -1651,7 +1649,7 @@ static NTSTATUS add_data_reloc_extent_item(_Requires_exclusive_lock_held_(_Curr_
 
                 *sdr = ref->sdr.count;
 
-                Status = insert_tree_item(Vcb, Vcb->extent_root, dr->new_address, TYPE_SHARED_DATA_REF, ref->parent->new_address, sdr, sizeof(UINT32), NULL, NULL);
+                Status = insert_tree_item(Vcb, Vcb->extent_root, dr->new_address, TYPE_SHARED_DATA_REF, ref->parent->new_address, sdr, sizeof(uint32_t), NULL, NULL);
                 if (!NT_SUCCESS(Status)) {
                     ERR("insert_tree_item returned %08x\n", Status);
                     return Status;
@@ -1665,29 +1663,29 @@ static NTSTATUS add_data_reloc_extent_item(_Requires_exclusive_lock_held_(_Curr_
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* changed) {
+static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, bool* changed) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
-    BOOL b;
+    bool b;
     LIST_ENTRY items, metadata_items, rollback, *le;
-    UINT64 loaded = 0, num_loaded = 0;
+    uint64_t loaded = 0, num_loaded = 0;
     chunk* newchunk = NULL;
-    UINT8* data = NULL;
+    uint8_t* data = NULL;
 
-    TRACE("chunk %llx\n", c->offset);
+    TRACE("chunk %I64x\n", c->offset);
 
     InitializeListHead(&rollback);
     InitializeListHead(&items);
     InitializeListHead(&metadata_items);
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     searchkey.obj_id = c->offset;
     searchkey.obj_type = TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         goto end;
@@ -1700,13 +1698,13 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
             break;
 
         if (tp.item->key.obj_id >= c->offset && tp.item->key.obj_type == TYPE_EXTENT_ITEM) {
-            BOOL tree = FALSE;
+            bool tree = false;
 
             if (tp.item->key.obj_type == TYPE_EXTENT_ITEM && tp.item->size >= sizeof(EXTENT_ITEM)) {
                 EXTENT_ITEM* ei = (EXTENT_ITEM*)tp.item->data;
 
                 if (ei->flags & EXTENT_ITEM_TREE_BLOCK)
-                    tree = TRUE;
+                    tree = true;
             }
 
             if (!tree) {
@@ -1725,18 +1723,18 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
             }
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, NULL);
+        b = find_next_item(Vcb, &tp, &next_tp, false, NULL);
 
         if (b)
             tp = next_tp;
     } while (b);
 
     if (IsListEmpty(&items)) {
-        *changed = FALSE;
+        *changed = false;
         Status = STATUS_SUCCESS;
         goto end;
     } else
-        *changed = TRUE;
+        *changed = true;
 
     data = ExAllocatePoolWithTag(PagedPool, BALANCE_UNIT, ALLOC_TAG);
     if (!data) {
@@ -1748,27 +1746,27 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
     le = items.Flink;
     while (le != &items) {
         data_reloc* dr = CONTAINING_RECORD(le, data_reloc, list_entry);
-        BOOL done = FALSE;
+        bool done = false;
         LIST_ENTRY* le2;
-        UINT32* csum;
+        uint32_t* csum;
         RTL_BITMAP bmp;
         ULONG* bmparr;
-        ULONG runlength, index, lastoff;
+        ULONG bmplen, runlength, index, lastoff;
 
         if (newchunk) {
             acquire_chunk_lock(newchunk, Vcb);
 
             if (find_data_address_in_chunk(Vcb, newchunk, dr->size, &dr->new_address)) {
                 newchunk->used += dr->size;
-                space_list_subtract(newchunk, FALSE, dr->new_address, dr->size, &rollback);
-                done = TRUE;
+                space_list_subtract(newchunk, false, dr->new_address, dr->size, &rollback);
+                done = true;
             }
 
             release_chunk_lock(newchunk, Vcb);
         }
 
         if (!done) {
-            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
             le2 = Vcb->chunks.Flink;
             while (le2 != &Vcb->chunks) {
@@ -1780,10 +1778,10 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
                     if ((c2->chunk_item->size - c2->used) >= dr->size) {
                         if (find_data_address_in_chunk(Vcb, c2, dr->size, &dr->new_address)) {
                             c2->used += dr->size;
-                            space_list_subtract(c2, FALSE, dr->new_address, dr->size, &rollback);
+                            space_list_subtract(c2, false, dr->new_address, dr->size, &rollback);
                             release_chunk_lock(c2, Vcb);
                             newchunk = c2;
-                            done = TRUE;
+                            done = true;
                             break;
                         }
                     }
@@ -1796,7 +1794,7 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
 
             // allocate new chunk if necessary
             if (!done) {
-                Status = alloc_chunk(Vcb, Vcb->data_flags, &newchunk, FALSE);
+                Status = alloc_chunk(Vcb, Vcb->data_flags, &newchunk, false);
 
                 if (!NT_SUCCESS(Status)) {
                     ERR("alloc_chunk returned %08x\n", Status);
@@ -1816,7 +1814,7 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
                     goto end;
                 } else {
                     newchunk->used += dr->size;
-                    space_list_subtract(newchunk, FALSE, dr->new_address, dr->size, &rollback);
+                    space_list_subtract(newchunk, false, dr->new_address, dr->size, &rollback);
                 }
 
                 release_chunk_lock(newchunk, Vcb);
@@ -1827,14 +1825,16 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
 
         dr->newchunk = newchunk;
 
-        bmparr = ExAllocatePoolWithTag(PagedPool, (ULONG)sector_align((dr->size / Vcb->superblock.sector_size) + 1, sizeof(ULONG)), ALLOC_TAG);
+        bmplen = (ULONG)(dr->size / Vcb->superblock.sector_size);
+
+        bmparr = ExAllocatePoolWithTag(PagedPool, (ULONG)sector_align(bmplen + 1, sizeof(ULONG)), ALLOC_TAG);
         if (!bmparr) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
             goto end;
         }
 
-        csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(dr->size * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+        csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(dr->size * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
         if (!csum) {
             ERR("out of memory\n");
             ExFreePool(bmparr);
@@ -1842,14 +1842,14 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
             goto end;
         }
 
-        RtlInitializeBitMap(&bmp, bmparr, (ULONG)(dr->size / Vcb->superblock.sector_size));
+        RtlInitializeBitMap(&bmp, bmparr, bmplen);
         RtlSetAllBits(&bmp); // 1 = no csum, 0 = csum
 
         searchkey.obj_id = EXTENT_CSUM_ID;
         searchkey.obj_type = TYPE_EXTENT_CSUM;
         searchkey.offset = dr->address;
 
-        Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, FALSE, NULL);
+        Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, NULL);
         if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND) {
             ERR("find_item returned %08x\n", Status);
             ExFreePool(csum);
@@ -1864,13 +1864,13 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
                 if (tp.item->key.obj_type == TYPE_EXTENT_CSUM) {
                     if (tp.item->key.offset >= dr->address + dr->size)
                         break;
-                    else if (tp.item->size >= sizeof(UINT32) && tp.item->key.offset + (tp.item->size * Vcb->superblock.sector_size / sizeof(UINT32)) >= dr->address) {
-                        UINT64 cs = max(dr->address, tp.item->key.offset);
-                        UINT64 ce = min(dr->address + dr->size, tp.item->key.offset + (tp.item->size * Vcb->superblock.sector_size / sizeof(UINT32)));
+                    else if (tp.item->size >= sizeof(uint32_t) && tp.item->key.offset + (tp.item->size * Vcb->superblock.sector_size / sizeof(uint32_t)) >= dr->address) {
+                        uint64_t cs = max(dr->address, tp.item->key.offset);
+                        uint64_t ce = min(dr->address + dr->size, tp.item->key.offset + (tp.item->size * Vcb->superblock.sector_size / sizeof(uint32_t)));
 
                         RtlCopyMemory(csum + ((cs - dr->address) / Vcb->superblock.sector_size),
-                                      tp.item->data + ((cs - tp.item->key.offset) * sizeof(UINT32) / Vcb->superblock.sector_size),
-                                      (ULONG)((ce - cs) * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                      tp.item->data + ((cs - tp.item->key.offset) * sizeof(uint32_t) / Vcb->superblock.sector_size),
+                                      (ULONG)((ce - cs) * sizeof(uint32_t) / Vcb->superblock.sector_size));
 
                         RtlClearBits(&bmp, (ULONG)((cs - dr->address) / Vcb->superblock.sector_size), (ULONG)((ce - cs) / Vcb->superblock.sector_size));
 
@@ -1879,17 +1879,27 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
                     }
                 }
 
-                if (find_next_item(Vcb, &tp, &next_tp, FALSE, NULL))
+                if (find_next_item(Vcb, &tp, &next_tp, false, NULL))
                     tp = next_tp;
                 else
                     break;
-            } while (TRUE);
+            } while (true);
         }
 
         lastoff = 0;
         runlength = RtlFindFirstRunClear(&bmp, &index);
 
         while (runlength != 0) {
+            if (index >= bmplen)
+                break;
+
+            if (index + runlength >= bmplen) {
+                runlength = bmplen - index;
+
+                if (runlength == 0)
+                    break;
+            }
+
             if (index > lastoff) {
                 ULONG off = lastoff;
                 ULONG size = index - lastoff;
@@ -1903,8 +1913,8 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
                     else
                         rl = size;
 
-                    Status = read_data(Vcb, dr->address + (off * Vcb->superblock.sector_size), rl * Vcb->superblock.sector_size, NULL, FALSE, data,
-                                       c, NULL, NULL, 0, FALSE, NormalPagePriority);
+                    Status = read_data(Vcb, dr->address + (off * Vcb->superblock.sector_size), rl * Vcb->superblock.sector_size, NULL, false, data,
+                                       c, NULL, NULL, 0, false, NormalPagePriority);
                     if (!NT_SUCCESS(Status)) {
                         ERR("read_data returned %08x\n", Status);
                         ExFreePool(csum);
@@ -1913,7 +1923,7 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
                     }
 
                     Status = write_data_complete(Vcb, dr->new_address + (off * Vcb->superblock.sector_size), data, rl * Vcb->superblock.sector_size,
-                                                 NULL, newchunk, FALSE, 0, NormalPagePriority);
+                                                 NULL, newchunk, false, 0, NormalPagePriority);
                     if (!NT_SUCCESS(Status)) {
                         ERR("write_data_complete returned %08x\n", Status);
                         ExFreePool(csum);
@@ -1938,8 +1948,8 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
                 else
                     rl = runlength;
 
-                Status = read_data(Vcb, dr->address + (index * Vcb->superblock.sector_size), rl * Vcb->superblock.sector_size, &csum[index], FALSE, data,
-                                   c, NULL, NULL, 0, FALSE, NormalPagePriority);
+                Status = read_data(Vcb, dr->address + (index * Vcb->superblock.sector_size), rl * Vcb->superblock.sector_size, &csum[index], false, data,
+                                   c, NULL, NULL, 0, false, NormalPagePriority);
                 if (!NT_SUCCESS(Status)) {
                     ERR("read_data returned %08x\n", Status);
                     ExFreePool(csum);
@@ -1948,7 +1958,7 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
                 }
 
                 Status = write_data_complete(Vcb, dr->new_address + (index * Vcb->superblock.sector_size), data, rl * Vcb->superblock.sector_size,
-                                             NULL, newchunk, FALSE, 0, NormalPagePriority);
+                                             NULL, newchunk, false, 0, NormalPagePriority);
                 if (!NT_SUCCESS(Status)) {
                     ERR("write_data_complete returned %08x\n", Status);
                     ExFreePool(csum);
@@ -1980,15 +1990,15 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
                 else
                     rl = size;
 
-                Status = read_data(Vcb, dr->address + (off * Vcb->superblock.sector_size), rl * Vcb->superblock.sector_size, NULL, FALSE, data,
-                                   c, NULL, NULL, 0, FALSE, NormalPagePriority);
+                Status = read_data(Vcb, dr->address + (off * Vcb->superblock.sector_size), rl * Vcb->superblock.sector_size, NULL, false, data,
+                                   c, NULL, NULL, 0, false, NormalPagePriority);
                 if (!NT_SUCCESS(Status)) {
                     ERR("read_data returned %08x\n", Status);
                     goto end;
                 }
 
                 Status = write_data_complete(Vcb, dr->new_address + (off * Vcb->superblock.sector_size), data, rl * Vcb->superblock.sector_size,
-                                             NULL, newchunk, FALSE, 0, NormalPagePriority);
+                                             NULL, newchunk, false, 0, NormalPagePriority);
                 if (!NT_SUCCESS(Status)) {
                     ERR("write_data_complete returned %08x\n", Status);
                     goto end;
@@ -2050,7 +2060,7 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change
 
     Status = STATUS_SUCCESS;
 
-    Vcb->need_write = TRUE;
+    Vcb->need_write = true;
 
 end:
     if (NT_SUCCESS(Status)) {
@@ -2062,7 +2072,7 @@ end:
             if (c2->cache) {
                 LIST_ENTRY* le2;
 
-                ExAcquireResourceExclusiveLite(c2->cache->Header.Resource, TRUE);
+                ExAcquireResourceExclusiveLite(c2->cache->Header.Resource, true);
 
                 le2 = c2->cache->extents.Flink;
                 while (le2 != &c2->cache->extents) {
@@ -2113,7 +2123,7 @@ end:
             struct _fcb* fcb = CONTAINING_RECORD(le, struct _fcb, list_entry_all);
             LIST_ENTRY* le2;
 
-            ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+            ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
             le2 = fcb->extents.Flink;
             while (le2 != &fcb->extents) {
@@ -2183,7 +2193,7 @@ end:
     return Status;
 }
 
-static __inline UINT64 get_chunk_dup_type(chunk* c) {
+static __inline uint64_t get_chunk_dup_type(chunk* c) {
     if (c->chunk_item->type & BLOCK_FLAG_RAID0)
         return BLOCK_FLAG_RAID0;
     else if (c->chunk_item->type & BLOCK_FLAG_RAID1)
@@ -2200,42 +2210,42 @@ static __inline UINT64 get_chunk_dup_type(chunk* c) {
         return BLOCK_FLAG_SINGLE;
 }
 
-static BOOL should_balance_chunk(device_extension* Vcb, UINT8 sort, chunk* c) {
+static bool should_balance_chunk(device_extension* Vcb, uint8_t sort, chunk* c) {
     btrfs_balance_opts* opts;
 
     opts = &Vcb->balance.opts[sort];
 
     if (!(opts->flags & BTRFS_BALANCE_OPTS_ENABLED))
-        return FALSE;
+        return false;
 
     if (opts->flags & BTRFS_BALANCE_OPTS_PROFILES) {
-        UINT64 type = get_chunk_dup_type(c);
+        uint64_t type = get_chunk_dup_type(c);
 
         if (!(type & opts->profiles))
-            return FALSE;
+            return false;
     }
 
     if (opts->flags & BTRFS_BALANCE_OPTS_DEVID) {
-        UINT16 i;
+        uint16_t i;
         CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
-        BOOL b = FALSE;
+        bool b = false;
 
         for (i = 0; i < c->chunk_item->num_stripes; i++) {
             if (cis[i].dev_id == opts->devid) {
-                b = TRUE;
+                b = true;
                 break;
             }
         }
 
         if (!b)
-            return FALSE;
+            return false;
     }
 
     if (opts->flags & BTRFS_BALANCE_OPTS_DRANGE) {
-        UINT16 i, factor;
-        UINT64 physsize;
+        uint16_t i, factor;
+        uint64_t physsize;
         CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
-        BOOL b = FALSE;
+        bool b = false;
 
         if (c->chunk_item->type & BLOCK_FLAG_RAID0)
             factor = c->chunk_item->num_stripes;
@@ -2253,44 +2263,44 @@ static BOOL should_balance_chunk(device_extension* Vcb, UINT8 sort, chunk* c) {
         for (i = 0; i < c->chunk_item->num_stripes; i++) {
             if (cis[i].offset < opts->drange_end && cis[i].offset + physsize >= opts->drange_start &&
                 (!(opts->flags & BTRFS_BALANCE_OPTS_DEVID) || cis[i].dev_id == opts->devid)) {
-                b = TRUE;
+                b = true;
                 break;
             }
         }
 
         if (!b)
-            return FALSE;
+            return false;
     }
 
     if (opts->flags & BTRFS_BALANCE_OPTS_VRANGE) {
         if (c->offset + c->chunk_item->size <= opts->vrange_start || c->offset > opts->vrange_end)
-            return FALSE;
+            return false;
     }
 
     if (opts->flags & BTRFS_BALANCE_OPTS_STRIPES) {
         if (c->chunk_item->num_stripes < opts->stripes_start || c->chunk_item->num_stripes < opts->stripes_end)
-            return FALSE;
+            return false;
     }
 
     if (opts->flags & BTRFS_BALANCE_OPTS_USAGE) {
-        UINT64 usage = c->used * 100 / c->chunk_item->size;
+        uint64_t usage = c->used * 100 / c->chunk_item->size;
 
         // usage == 0 should mean completely empty, not just that usage rounds to 0%
         if (c->used > 0 && usage == 0)
             usage = 1;
 
         if (usage < opts->usage_start || usage > opts->usage_end)
-            return FALSE;
+            return false;
     }
 
     if (opts->flags & BTRFS_BALANCE_OPTS_CONVERT && opts->flags & BTRFS_BALANCE_OPTS_SOFT) {
-        UINT64 type = get_chunk_dup_type(c);
+        uint64_t type = get_chunk_dup_type(c);
 
         if (type == opts->convert)
-            return FALSE;
+            return false;
     }
 
-    return TRUE;
+    return true;
 }
 
 static void copy_balance_args(btrfs_balance_opts* opts, BALANCE_ARGS* args) {
@@ -2338,8 +2348,8 @@ static void copy_balance_args(btrfs_balance_opts* opts, BALANCE_ARGS* args) {
     if (opts->flags & BTRFS_BALANCE_OPTS_LIMIT) {
         if (args->limit_start == 0) {
             args->flags |= BALANCE_ARGS_FLAGS_LIMIT_RANGE;
-            args->limit_start = (UINT32)opts->limit_start;
-            args->limit_end = (UINT32)opts->limit_end;
+            args->limit_start = (uint32_t)opts->limit_start;
+            args->limit_end = (uint32_t)opts->limit_end;
         } else {
             args->flags |= BALANCE_ARGS_FLAGS_LIMIT;
             args->limit = opts->limit_end;
@@ -2363,9 +2373,9 @@ static NTSTATUS add_balance_item(device_extension* Vcb) {
     searchkey.obj_type = TYPE_TEMP_ITEM;
     searchkey.offset = 0;
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         goto end;
@@ -2435,9 +2445,9 @@ static NTSTATUS remove_balance_item(device_extension* Vcb) {
     searchkey.obj_type = TYPE_TEMP_ITEM;
     searchkey.offset = 0;
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         goto end;
@@ -2479,12 +2489,12 @@ static void load_balance_args(btrfs_balance_opts* opts, BALANCE_ARGS* args) {
         opts->flags |= BTRFS_BALANCE_OPTS_USAGE;
 
         opts->usage_start = 0;
-        opts->usage_end = (UINT8)args->usage;
+        opts->usage_end = (uint8_t)args->usage;
     } else if (args->flags & BALANCE_ARGS_FLAGS_USAGE_RANGE) {
         opts->flags |= BTRFS_BALANCE_OPTS_USAGE;
 
-        opts->usage_start = (UINT8)args->usage_start;
-        opts->usage_end = (UINT8)args->usage_end;
+        opts->usage_start = (uint8_t)args->usage_start;
+        opts->usage_end = (uint8_t)args->usage_end;
     }
 
     if (args->flags & BALANCE_ARGS_FLAGS_DEVID) {
@@ -2519,8 +2529,8 @@ static void load_balance_args(btrfs_balance_opts* opts, BALANCE_ARGS* args) {
     if (args->flags & BALANCE_ARGS_FLAGS_STRIPES_RANGE) {
         opts->flags |= BTRFS_BALANCE_OPTS_STRIPES;
 
-        opts->stripes_start = (UINT16)args->stripes_start;
-        opts->stripes_end = (UINT16)args->stripes_end;
+        opts->stripes_start = (uint16_t)args->stripes_start;
+        opts->stripes_end = (uint16_t)args->stripes_end;
     }
 
     if (args->flags & BALANCE_ARGS_FLAGS_CONVERT) {
@@ -2546,7 +2556,7 @@ static NTSTATUS remove_superblocks(device* dev) {
     RtlZeroMemory(sb, sizeof(superblock));
 
     while (superblock_addrs[i] > 0 && dev->devitem.num_bytes >= superblock_addrs[i] + sizeof(superblock)) {
-        Status = write_data_phys(dev->devobj, superblock_addrs[i], sb, sizeof(superblock));
+        Status = write_data_phys(dev->devobj, dev->fileobj, superblock_addrs[i], sb, sizeof(superblock));
 
         if (!NT_SUCCESS(Status)) {
             ExFreePool(sb);
@@ -2587,7 +2597,7 @@ static NTSTATUS finish_removing_device(_Requires_exclusive_lock_held_(_Curr_->tr
     searchkey.obj_type = TYPE_DEV_ITEM;
     searchkey.offset = dev->devitem.dev_id;
 
-    Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
@@ -2608,7 +2618,7 @@ static NTSTATUS finish_removing_device(_Requires_exclusive_lock_held_(_Curr_->tr
     searchkey.obj_type = TYPE_DEV_STATS;
     searchkey.offset = dev->devitem.dev_id;
 
-    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
@@ -2655,7 +2665,7 @@ static NTSTATUS finish_removing_device(_Requires_exclusive_lock_held_(_Curr_->tr
     if (dev->devobj) {
         pdo_device_extension* pdode = vde->pdode;
 
-        ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
 
         le = pdode->children.Flink;
         while (le != &pdode->children) {
@@ -2676,7 +2686,7 @@ static NTSTATUS finish_removing_device(_Requires_exclusive_lock_held_(_Curr_->tr
                     else {
                         MOUNTDEV_NAME mdn;
 
-                        Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), TRUE, NULL);
+                        Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), true, NULL);
                         if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
                             ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
                         else {
@@ -2687,7 +2697,7 @@ static NTSTATUS finish_removing_device(_Requires_exclusive_lock_held_(_Curr_->tr
                             if (!mdn2)
                                 ERR("out of memory\n");
                             else {
-                                Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, TRUE, NULL);
+                                Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, true, NULL);
                                 if (!NT_SUCCESS(Status))
                                     ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
                                 else {
@@ -2757,14 +2767,14 @@ static NTSTATUS finish_removing_device(_Requires_exclusive_lock_held_(_Curr_->tr
     ExFreePool(dev);
 
     if (Vcb->trim) {
-        Vcb->trim = FALSE;
+        Vcb->trim = false;
 
         le = Vcb->devices.Flink;
         while (le != &Vcb->devices) {
             device* dev2 = CONTAINING_RECORD(le, device, list_entry);
 
             if (dev2->trim) {
-                Vcb->trim = TRUE;
+                Vcb->trim = true;
                 break;
             }
 
@@ -2784,8 +2794,8 @@ static void trim_unalloc_space(_Requires_lock_held_(_Curr_->tree_lock) device_ex
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
-    BOOL b;
-    UINT64 lastoff = 0x100000; // don't TRIM the first megabyte, in case someone has been daft enough to install GRUB there
+    bool b;
+    uint64_t lastoff = 0x100000; // don't TRIM the first megabyte, in case someone has been daft enough to install GRUB there
     LIST_ENTRY* le;
 
     dev->num_trim_entries = 0;
@@ -2794,7 +2804,7 @@ static void trim_unalloc_space(_Requires_lock_held_(_Curr_->tree_lock) device_ex
     searchkey.obj_type = TYPE_DEV_EXTENT;
     searchkey.offset = 0;
 
-    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return;
@@ -2812,12 +2822,12 @@ static void trim_unalloc_space(_Requires_lock_held_(_Curr_->tree_lock) device_ex
 
                 lastoff = tp.item->key.offset + de->length;
             } else {
-                ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DEV_EXTENT));
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DEV_EXTENT));
                 return;
             }
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, NULL);
+        b = find_next_item(Vcb, &tp, &next_tp, false, NULL);
 
         if (b) {
             tp = next_tp;
@@ -2832,7 +2842,7 @@ static void trim_unalloc_space(_Requires_lock_held_(_Curr_->tree_lock) device_ex
     if (dev->num_trim_entries == 0)
         return;
 
-    datalen = (ULONG)sector_align(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), sizeof(UINT64)) + (dev->num_trim_entries * sizeof(DEVICE_DATA_SET_RANGE));
+    datalen = (ULONG)sector_align(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), sizeof(uint64_t)) + (dev->num_trim_entries * sizeof(DEVICE_DATA_SET_RANGE));
 
     dmdsa = ExAllocatePoolWithTag(PagedPool, datalen, ALLOC_TAG);
     if (!dmdsa) {
@@ -2845,10 +2855,10 @@ static void trim_unalloc_space(_Requires_lock_held_(_Curr_->tree_lock) device_ex
     dmdsa->Flags = DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED;
     dmdsa->ParameterBlockOffset = 0;
     dmdsa->ParameterBlockLength = 0;
-    dmdsa->DataSetRangesOffset = (ULONG)sector_align(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), sizeof(UINT64));
+    dmdsa->DataSetRangesOffset = (ULONG)sector_align(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), sizeof(uint64_t));
     dmdsa->DataSetRangesLength = dev->num_trim_entries * sizeof(DEVICE_DATA_SET_RANGE);
 
-    ranges = (DEVICE_DATA_SET_RANGE*)((UINT8*)dmdsa + dmdsa->DataSetRangesOffset);
+    ranges = (DEVICE_DATA_SET_RANGE*)((uint8_t*)dmdsa + dmdsa->DataSetRangesOffset);
 
     i = 0;
     le = dev->trim_list.Flink;
@@ -2862,7 +2872,7 @@ static void trim_unalloc_space(_Requires_lock_held_(_Curr_->tree_lock) device_ex
         le = le->Flink;
     }
 
-    Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES, dmdsa, datalen, NULL, 0, TRUE, NULL);
+    Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES, dmdsa, datalen, NULL, 0, true, NULL);
     if (!NT_SUCCESS(Status))
         WARN("IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES returned %08x\n", Status);
 
@@ -2877,20 +2887,20 @@ end:
     dev->num_trim_entries = 0;
 }
 
-static NTSTATUS try_consolidation(device_extension* Vcb, UINT64 flags, chunk** newchunk) {
+static NTSTATUS try_consolidation(device_extension* Vcb, uint64_t flags, chunk** newchunk) {
     NTSTATUS Status;
-    BOOL changed;
+    bool changed;
     LIST_ENTRY* le;
     chunk* rc;
 
     // FIXME - allow with metadata chunks?
 
-    while (TRUE) {
+    while (true) {
         rc = NULL;
 
-        ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+        ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-        ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+        ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
         // choose the least-used chunk we haven't looked at yet
         le = Vcb->chunks.Flink;
@@ -2917,26 +2927,26 @@ static NTSTATUS try_consolidation(device_extension* Vcb, UINT64 flags, chunk** n
         }
 
         rc->list_entry_balance.Flink = (LIST_ENTRY*)1; // so it doesn't get dropped
-        rc->reloc = TRUE;
+        rc->reloc = true;
 
         ExReleaseResourceLite(&Vcb->tree_lock);
 
         do {
-            changed = FALSE;
+            changed = false;
 
             Status = balance_data_chunk(Vcb, rc, &changed);
             if (!NT_SUCCESS(Status)) {
                 ERR("balance_data_chunk returned %08x\n", Status);
                 Vcb->balance.status = Status;
                 rc->list_entry_balance.Flink = NULL;
-                rc->reloc = FALSE;
+                rc->reloc = false;
                 return Status;
             }
 
-            KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, FALSE, NULL);
+            KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, false, NULL);
 
             if (Vcb->readonly)
-                Vcb->balance.stopping = TRUE;
+                Vcb->balance.stopping = true;
 
             if (Vcb->balance.stopping)
                 return STATUS_SUCCESS;
@@ -2944,8 +2954,8 @@ static NTSTATUS try_consolidation(device_extension* Vcb, UINT64 flags, chunk** n
 
         rc->list_entry_balance.Flink = NULL;
 
-        rc->changed = TRUE;
-        rc->space_changed = TRUE;
+        rc->changed = true;
+        rc->space_changed = true;
         rc->balance_num = Vcb->balance.balance_num;
 
         Status = do_write(Vcb, NULL);
@@ -2957,9 +2967,9 @@ static NTSTATUS try_consolidation(device_extension* Vcb, UINT64 flags, chunk** n
         free_trees(Vcb);
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
-    Status = alloc_chunk(Vcb, flags, &rc, TRUE);
+    Status = alloc_chunk(Vcb, flags, &rc, true);
 
     ExReleaseResourceLite(&Vcb->chunk_lock);
 
@@ -2987,16 +2997,16 @@ static NTSTATUS regenerate_space_list(device_extension* Vcb, device* dev) {
 
     le = Vcb->chunks.Flink;
     while (le != &Vcb->chunks) {
-        UINT16 n;
+        uint16_t n;
         chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
         CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
 
         for (n = 0; n < c->chunk_item->num_stripes; n++) {
-            UINT64 stripe_size = 0;
+            uint64_t stripe_size = 0;
 
             if (cis[n].dev_id == dev->devitem.dev_id) {
                 if (stripe_size == 0) {
-                    UINT16 factor;
+                    uint16_t factor;
 
                     if (c->chunk_item->type & BLOCK_FLAG_RAID0)
                         factor = c->chunk_item->num_stripes;
@@ -3023,22 +3033,18 @@ static NTSTATUS regenerate_space_list(device_extension* Vcb, device* dev) {
 }
 
 _Function_class_(KSTART_ROUTINE)
-#ifndef __REACTOS__
-void balance_thread(void* context) {
-#else
-void NTAPI balance_thread(void* context) {
-#endif
+void __stdcall balance_thread(void* context) {
     device_extension* Vcb = (device_extension*)context;
     LIST_ENTRY chunks;
     LIST_ENTRY* le;
-    UINT64 num_chunks[3], okay_metadata_chunks = 0, okay_data_chunks = 0, okay_system_chunks = 0;
-    UINT64 old_data_flags = 0, old_metadata_flags = 0, old_system_flags = 0;
+    uint64_t num_chunks[3], okay_metadata_chunks = 0, okay_data_chunks = 0, okay_system_chunks = 0;
+    uint64_t old_data_flags = 0, old_metadata_flags = 0, old_system_flags = 0;
     NTSTATUS Status;
 
     Vcb->balance.balance_num++;
 
-    Vcb->balance.stopping = FALSE;
-    KeInitializeEvent(&Vcb->balance.finished, NotificationEvent, FALSE);
+    Vcb->balance.stopping = false;
+    KeInitializeEvent(&Vcb->balance.finished, NotificationEvent, false);
 
     if (Vcb->balance.opts[BALANCE_OPTS_DATA].flags & BTRFS_BALANCE_OPTS_ENABLED && Vcb->balance.opts[BALANCE_OPTS_DATA].flags & BTRFS_BALANCE_OPTS_CONVERT) {
         old_data_flags = Vcb->data_flags;
@@ -3094,17 +3100,17 @@ void NTAPI balance_thread(void* context) {
         }
     }
 
-    KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, FALSE, NULL);
+    KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, false, NULL);
 
     if (Vcb->balance.stopping)
         goto end;
 
-    ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
     le = Vcb->chunks.Flink;
     while (le != &Vcb->chunks) {
         chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
-        UINT8 sort;
+        uint8_t sort;
 
         acquire_chunk_lock(c, Vcb);
 
@@ -3115,7 +3121,7 @@ void NTAPI balance_thread(void* context) {
         else if (c->chunk_item->type & BLOCK_FLAG_SYSTEM)
             sort = BALANCE_OPTS_SYSTEM;
         else {
-            ERR("unexpected chunk type %llx\n", c->chunk_item->type);
+            ERR("unexpected chunk type %I64x\n", c->chunk_item->type);
             release_chunk_lock(c, Vcb);
             break;
         }
@@ -3155,13 +3161,13 @@ void NTAPI balance_thread(void* context) {
 
     // If we're doing a full balance, try and allocate a new chunk now, before we mess things up
     if (okay_metadata_chunks == 0 || okay_data_chunks == 0 || okay_system_chunks == 0) {
-        BOOL consolidated = FALSE;
+        bool consolidated = false;
         chunk* c;
 
         if (okay_metadata_chunks == 0) {
-            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
-            Status = alloc_chunk(Vcb, Vcb->metadata_flags, &c, TRUE);
+            Status = alloc_chunk(Vcb, Vcb->metadata_flags, &c, true);
             if (NT_SUCCESS(Status))
                 c->balance_num = Vcb->balance.balance_num;
             else if (Status != STATUS_DISK_FULL || consolidated) {
@@ -3182,7 +3188,7 @@ void NTAPI balance_thread(void* context) {
                 } else
                     c->balance_num = Vcb->balance.balance_num;
 
-                consolidated = TRUE;
+                consolidated = true;
 
                 if (Vcb->balance.stopping)
                     goto end;
@@ -3190,9 +3196,9 @@ void NTAPI balance_thread(void* context) {
         }
 
         if (okay_data_chunks == 0) {
-            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
-            Status = alloc_chunk(Vcb, Vcb->data_flags, &c, TRUE);
+            Status = alloc_chunk(Vcb, Vcb->data_flags, &c, true);
             if (NT_SUCCESS(Status))
                 c->balance_num = Vcb->balance.balance_num;
             else if (Status != STATUS_DISK_FULL || consolidated) {
@@ -3213,7 +3219,7 @@ void NTAPI balance_thread(void* context) {
                 } else
                     c->balance_num = Vcb->balance.balance_num;
 
-                consolidated = TRUE;
+                consolidated = true;
 
                 if (Vcb->balance.stopping)
                     goto end;
@@ -3221,9 +3227,9 @@ void NTAPI balance_thread(void* context) {
         }
 
         if (okay_system_chunks == 0) {
-            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
-            Status = alloc_chunk(Vcb, Vcb->system_flags, &c, TRUE);
+            Status = alloc_chunk(Vcb, Vcb->system_flags, &c, true);
             if (NT_SUCCESS(Status))
                 c->balance_num = Vcb->balance.balance_num;
             else if (Status != STATUS_DISK_FULL || consolidated) {
@@ -3244,7 +3250,7 @@ void NTAPI balance_thread(void* context) {
                 } else
                     c->balance_num = Vcb->balance.balance_num;
 
-                consolidated = TRUE;
+                consolidated = true;
 
                 if (Vcb->balance.stopping)
                     goto end;
@@ -3252,13 +3258,13 @@ void NTAPI balance_thread(void* context) {
         }
     }
 
-    ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
     le = chunks.Flink;
     while (le != &chunks) {
         chunk* c = CONTAINING_RECORD(le, chunk, list_entry_balance);
 
-        c->reloc = TRUE;
+        c->reloc = true;
 
         le = le->Flink;
     }
@@ -3272,10 +3278,10 @@ void NTAPI balance_thread(void* context) {
         LIST_ENTRY* le2 = le->Flink;
 
         if (c->chunk_item->type & BLOCK_FLAG_DATA) {
-            BOOL changed;
+            bool changed;
 
             do {
-                changed = FALSE;
+                changed = false;
 
                 Status = balance_data_chunk(Vcb, c, &changed);
                 if (!NT_SUCCESS(Status)) {
@@ -3284,17 +3290,17 @@ void NTAPI balance_thread(void* context) {
                     goto end;
                 }
 
-                KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, FALSE, NULL);
+                KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, false, NULL);
 
                 if (Vcb->readonly)
-                    Vcb->balance.stopping = TRUE;
+                    Vcb->balance.stopping = true;
 
                 if (Vcb->balance.stopping)
                     break;
             } while (changed);
 
-            c->changed = TRUE;
-            c->space_changed = TRUE;
+            c->changed = true;
+            c->space_changed = true;
         }
 
         if (Vcb->balance.stopping)
@@ -3314,7 +3320,7 @@ void NTAPI balance_thread(void* context) {
     // do metadata chunks
     while (!IsListEmpty(&chunks)) {
         chunk* c;
-        BOOL changed;
+        bool changed;
 
         le = RemoveHeadList(&chunks);
         c = CONTAINING_RECORD(le, chunk, list_entry_balance);
@@ -3328,17 +3334,17 @@ void NTAPI balance_thread(void* context) {
                     goto end;
                 }
 
-                KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, FALSE, NULL);
+                KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, false, NULL);
 
                 if (Vcb->readonly)
-                    Vcb->balance.stopping = TRUE;
+                    Vcb->balance.stopping = true;
 
                 if (Vcb->balance.stopping)
                     break;
             } while (changed);
 
-            c->changed = TRUE;
-            c->space_changed = TRUE;
+            c->changed = true;
+            c->space_changed = true;
         }
 
         if (Vcb->balance.stopping)
@@ -3355,7 +3361,7 @@ end:
             le = chunks.Flink;
             while (le != &chunks) {
                 chunk* c = CONTAINING_RECORD(le, chunk, list_entry_balance);
-                c->reloc = FALSE;
+                c->reloc = false;
 
                 le = le->Flink;
                 c->list_entry_balance.Flink = NULL;
@@ -3374,7 +3380,7 @@ end:
         if (Vcb->balance.removing) {
             device* dev = NULL;
 
-            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
             le = Vcb->devices.Flink;
             while (le != &Vcb->devices) {
@@ -3394,17 +3400,17 @@ end:
 
                     if (!NT_SUCCESS(Status)) {
                         ERR("finish_removing_device returned %08x\n", Status);
-                        dev->reloc = FALSE;
+                        dev->reloc = false;
                     }
                 } else
-                    dev->reloc = FALSE;
+                    dev->reloc = false;
             }
 
             ExReleaseResourceLite(&Vcb->tree_lock);
         } else if (Vcb->balance.shrinking) {
             device* dev = NULL;
 
-            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
             le = Vcb->devices.Flink;
             while (le != &Vcb->devices) {
@@ -3419,7 +3425,7 @@ end:
             }
 
             if (!dev) {
-                ERR("could not find device %llx\n", Vcb->balance.opts[0].devid);
+                ERR("could not find device %I64x\n", Vcb->balance.opts[0].devid);
                 Vcb->balance.status = STATUS_INTERNAL_ERROR;
             }
 
@@ -3430,7 +3436,7 @@ end:
                         WARN("regenerate_space_list returned %08x\n", Status);
                 }
             } else {
-                UINT64 old_size;
+                uint64_t old_size;
 
                 old_size = dev->devitem.num_bytes;
                 dev->devitem.num_bytes = Vcb->balance.opts[0].drange_start;
@@ -3468,7 +3474,7 @@ end:
         }
 
         if (Vcb->trim && !Vcb->options.no_trim) {
-            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
             le = Vcb->devices.Flink;
             while (le != &Vcb->devices) {
@@ -3487,13 +3493,13 @@ end:
     ZwClose(Vcb->balance.thread);
     Vcb->balance.thread = NULL;
 
-    KeSetEvent(&Vcb->balance.finished, 0, FALSE);
+    KeSetEvent(&Vcb->balance.finished, 0, false);
 }
 
 NTSTATUS start_balance(device_extension* Vcb, void* data, ULONG length, KPROCESSOR_MODE processor_mode) {
     NTSTATUS Status;
     btrfs_start_balance* bsb = (btrfs_start_balance*)data;
-    UINT8 i;
+    uint8_t i;
 
     if (length < sizeof(btrfs_start_balance) || !data)
         return STATUS_INVALID_PARAMETER;
@@ -3587,9 +3593,9 @@ NTSTATUS start_balance(device_extension* Vcb, void* data, ULONG length, KPROCESS
     RtlCopyMemory(&Vcb->balance.opts[BALANCE_OPTS_METADATA], &bsb->opts[BALANCE_OPTS_METADATA], sizeof(btrfs_balance_opts));
     RtlCopyMemory(&Vcb->balance.opts[BALANCE_OPTS_SYSTEM], &bsb->opts[BALANCE_OPTS_SYSTEM], sizeof(btrfs_balance_opts));
 
-    Vcb->balance.paused = FALSE;
-    Vcb->balance.removing = FALSE;
-    Vcb->balance.shrinking = FALSE;
+    Vcb->balance.paused = false;
+    Vcb->balance.removing = false;
+    Vcb->balance.shrinking = false;
     Vcb->balance.status = STATUS_SUCCESS;
     KeInitializeEvent(&Vcb->balance.event, NotificationEvent, !Vcb->balance.paused);
 
@@ -3613,7 +3619,7 @@ NTSTATUS look_for_balance_item(_Requires_lock_held_(_Curr_->tree_lock) device_ex
     searchkey.obj_type = TYPE_TEMP_ITEM;
     searchkey.offset = 0;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
@@ -3625,7 +3631,7 @@ NTSTATUS look_for_balance_item(_Requires_lock_held_(_Curr_->tree_lock) device_ex
     }
 
     if (tp.item->size < sizeof(BALANCE_ITEM)) {
-        WARN("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+        WARN("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
              tp.item->size, sizeof(BALANCE_ITEM));
         return STATUS_INTERNAL_ERROR;
     }
@@ -3664,12 +3670,12 @@ NTSTATUS look_for_balance_item(_Requires_lock_held_(_Curr_->tree_lock) device_ex
     }
 
     if (Vcb->readonly || Vcb->options.skip_balance)
-        Vcb->balance.paused = TRUE;
+        Vcb->balance.paused = true;
     else
-        Vcb->balance.paused = FALSE;
+        Vcb->balance.paused = false;
 
-    Vcb->balance.removing = FALSE;
-    Vcb->balance.shrinking = FALSE;
+    Vcb->balance.removing = false;
+    Vcb->balance.shrinking = false;
     Vcb->balance.status = STATUS_SUCCESS;
     KeInitializeEvent(&Vcb->balance.event, NotificationEvent, !Vcb->balance.paused);
 
@@ -3730,7 +3736,7 @@ NTSTATUS pause_balance(device_extension* Vcb, KPROCESSOR_MODE processor_mode) {
     if (Vcb->balance.paused)
         return STATUS_DEVICE_NOT_READY;
 
-    Vcb->balance.paused = TRUE;
+    Vcb->balance.paused = true;
     KeClearEvent(&Vcb->balance.event);
 
     return STATUS_SUCCESS;
@@ -3749,8 +3755,8 @@ NTSTATUS resume_balance(device_extension* Vcb, KPROCESSOR_MODE processor_mode) {
     if (Vcb->readonly)
         return STATUS_MEDIA_WRITE_PROTECTED;
 
-    Vcb->balance.paused = FALSE;
-    KeSetEvent(&Vcb->balance.event, 0, FALSE);
+    Vcb->balance.paused = false;
+    KeSetEvent(&Vcb->balance.event, 0, false);
 
     return STATUS_SUCCESS;
 }
@@ -3762,33 +3768,33 @@ NTSTATUS stop_balance(device_extension* Vcb, KPROCESSOR_MODE processor_mode) {
     if (!Vcb->balance.thread)
         return STATUS_DEVICE_NOT_READY;
 
-    Vcb->balance.paused = FALSE;
-    Vcb->balance.stopping = TRUE;
+    Vcb->balance.paused = false;
+    Vcb->balance.stopping = true;
     Vcb->balance.status = STATUS_SUCCESS;
-    KeSetEvent(&Vcb->balance.event, 0, FALSE);
+    KeSetEvent(&Vcb->balance.event, 0, false);
 
     return STATUS_SUCCESS;
 }
 
 NTSTATUS remove_device(device_extension* Vcb, void* data, ULONG length, KPROCESSOR_MODE processor_mode) {
-    UINT64 devid;
+    uint64_t devid;
     LIST_ENTRY* le;
     device* dev = NULL;
     NTSTATUS Status;
     int i;
-    UINT64 num_rw_devices;
+    uint64_t num_rw_devices;
 
     TRACE("(%p, %p, %x)\n", Vcb, data, length);
 
     if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), processor_mode))
         return STATUS_PRIVILEGE_NOT_HELD;
 
-    if (length < sizeof(UINT64))
+    if (length < sizeof(uint64_t))
         return STATUS_INVALID_PARAMETER;
 
-    devid = *(UINT64*)data;
+    devid = *(uint64_t*)data;
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
     if (Vcb->readonly) {
         ExReleaseResourceLite(&Vcb->tree_lock);
@@ -3812,7 +3818,7 @@ NTSTATUS remove_device(device_extension* Vcb, void* data, ULONG length, KPROCESS
 
     if (!dev) {
         ExReleaseResourceLite(&Vcb->tree_lock);
-        WARN("device %llx not found\n", devid);
+        WARN("device %I64x not found\n", devid);
         return STATUS_NOT_FOUND;
     }
 
@@ -3855,7 +3861,7 @@ NTSTATUS remove_device(device_extension* Vcb, void* data, ULONG length, KPROCESS
         return STATUS_DEVICE_NOT_READY;
     }
 
-    dev->reloc = TRUE;
+    dev->reloc = true;
 
     RtlZeroMemory(Vcb->balance.opts, sizeof(btrfs_balance_opts) * 3);
 
@@ -3864,16 +3870,16 @@ NTSTATUS remove_device(device_extension* Vcb, void* data, ULONG length, KPROCESS
         Vcb->balance.opts[i].devid = devid;
     }
 
-    Vcb->balance.paused = FALSE;
-    Vcb->balance.removing = TRUE;
-    Vcb->balance.shrinking = FALSE;
+    Vcb->balance.paused = false;
+    Vcb->balance.removing = true;
+    Vcb->balance.shrinking = false;
     Vcb->balance.status = STATUS_SUCCESS;
     KeInitializeEvent(&Vcb->balance.event, NotificationEvent, !Vcb->balance.paused);
 
     Status = PsCreateSystemThread(&Vcb->balance.thread, 0, NULL, NULL, NULL, balance_thread, Vcb);
     if (!NT_SUCCESS(Status)) {
         ERR("PsCreateSystemThread returned %08x\n", Status);
-        dev->reloc = FALSE;
+        dev->reloc = false;
         return Status;
     }
 
diff --git a/drivers/filesystems/btrfs/boot.c b/drivers/filesystems/btrfs/boot.c
new file mode 100755
index 00000000000..f73fc38b4e8
--- /dev/null
+++ b/drivers/filesystems/btrfs/boot.c
@@ -0,0 +1,248 @@
+/* Copyright (c) Mark Harmstone 2019
+ *
+ * This file is part of WinBtrfs.
+ *
+ * WinBtrfs is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public Licence as published by
+ * the Free Software Foundation, either version 3 of the Licence, or
+ * (at your option) any later version.
+ *
+ * WinBtrfs is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public Licence for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public Licence
+ * along with WinBtrfs.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include "btrfs_drv.h"
+
+#ifndef __REACTOS__
+#ifdef _MSC_VER
+#include <ntstrsafe.h>
+#endif
+#else
+#include <ntstrsafe.h>
+#endif
+
+extern ERESOURCE pdo_list_lock;
+extern LIST_ENTRY pdo_list;
+
+#ifndef _MSC_VER
+NTSTATUS RtlUnicodeStringPrintf(PUNICODE_STRING DestinationString, const WCHAR* pszFormat, ...); // not in mingw
+#endif
+
+static bool get_system_root_partition(uint32_t* disk_num, uint32_t* partition_num) {
+    NTSTATUS Status;
+    HANDLE h;
+    UNICODE_STRING us, target;
+    OBJECT_ATTRIBUTES objatt;
+    WCHAR* s;
+    ULONG retlen = 0, left;
+
+    static const WCHAR system_root[] = L"\\SystemRoot";
+    static const WCHAR arc_prefix[] = L"\\ArcName\\multi(0)disk(0)rdisk(";
+    static const WCHAR arc_middle[] = L")partition(";
+
+    us.Buffer = (WCHAR*)system_root;
+    us.Length = us.MaximumLength = sizeof(system_root) - sizeof(WCHAR);
+
+    InitializeObjectAttributes(&objatt, &us, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
+
+    Status = ZwOpenSymbolicLinkObject(&h, GENERIC_READ, &objatt);
+    if (!NT_SUCCESS(Status)) {
+        ERR("ZwOpenSymbolicLinkObject returned %08x\n", Status);
+        return false;
+    }
+
+    target.Length = target.MaximumLength = 0;
+
+    Status = ZwQuerySymbolicLinkObject(h, &target, &retlen);
+    if (Status != STATUS_BUFFER_TOO_SMALL) {
+        ERR("ZwQuerySymbolicLinkObject returned %08x\n", Status);
+        NtClose(h);
+        return false;
+    }
+
+    if (retlen == 0) {
+        NtClose(h);
+        return false;
+    }
+
+    target.Buffer = ExAllocatePoolWithTag(NonPagedPool, retlen, ALLOC_TAG);
+    if (!target.Buffer) {
+        ERR("out of memory\n");
+        NtClose(h);
+        return false;
+    }
+
+    target.Length = target.MaximumLength = (USHORT)retlen;
+
+    Status = ZwQuerySymbolicLinkObject(h, &target, NULL);
+    if (!NT_SUCCESS(Status)) {
+        ERR("ZwQuerySymbolicLinkObject returned %08x\n", Status);
+        NtClose(h);
+        ExFreePool(target.Buffer);
+        return false;
+    }
+
+    NtClose(h);
+
+    TRACE("system root is %.*S\n", target.Length / sizeof(WCHAR), target.Buffer);
+
+    if (target.Length <= sizeof(arc_prefix) - sizeof(WCHAR) ||
+        RtlCompareMemory(target.Buffer, arc_prefix, sizeof(arc_prefix) - sizeof(WCHAR)) != sizeof(arc_prefix) - sizeof(WCHAR)) {
+        ExFreePool(target.Buffer);
+        return false;
+    }
+
+    s = &target.Buffer[(sizeof(arc_prefix) / sizeof(WCHAR)) - 1];
+    left = ((target.Length - sizeof(arc_prefix)) / sizeof(WCHAR)) + 1;
+
+    if (left == 0 || s[0] < '0' || s[0] > '9') {
+        ExFreePool(target.Buffer);
+        return false;
+    }
+
+    *disk_num = 0;
+
+    while (left > 0 && s[0] >= '0' && s[0] <= '9') {
+        *disk_num *= 10;
+        *disk_num += s[0] - '0';
+        s++;
+        left--;
+    }
+
+    if (left <= (sizeof(arc_middle) / sizeof(WCHAR)) - 1 ||
+        RtlCompareMemory(s, arc_middle, sizeof(arc_middle) - sizeof(WCHAR)) != sizeof(arc_middle) - sizeof(WCHAR)) {
+        ExFreePool(target.Buffer);
+        return false;
+    }
+
+    s = &s[(sizeof(arc_middle) / sizeof(WCHAR)) - 1];
+    left -= (sizeof(arc_middle) / sizeof(WCHAR)) - 1;
+
+    if (left == 0 || s[0] < '0' || s[0] > '9') {
+        ExFreePool(target.Buffer);
+        return false;
+    }
+
+    *partition_num = 0;
+
+    while (left > 0 && s[0] >= '0' && s[0] <= '9') {
+        *partition_num *= 10;
+        *partition_num += s[0] - '0';
+        s++;
+        left--;
+    }
+
+    ExFreePool(target.Buffer);
+
+    return true;
+}
+
+static void change_symlink(uint32_t disk_num, uint32_t partition_num, BTRFS_UUID* uuid) {
+    NTSTATUS Status;
+    UNICODE_STRING us, us2;
+    WCHAR symlink[60], target[(sizeof(BTRFS_VOLUME_PREFIX) / sizeof(WCHAR)) + 36], *w;
+#ifdef __REACTOS__
+    unsigned int i;
+#endif
+
+    us.Buffer = symlink;
+    us.Length = 0;
+    us.MaximumLength = sizeof(symlink);
+
+    Status = RtlUnicodeStringPrintf(&us, L"\\Device\\Harddisk%u\\Partition%u", disk_num, partition_num);
+    if (!NT_SUCCESS(Status)) {
+        ERR("RtlUnicodeStringPrintf returned %08x\n", Status);
+        return;
+    }
+
+    Status = IoDeleteSymbolicLink(&us);
+    if (!NT_SUCCESS(Status))
+        ERR("IoDeleteSymbolicLink returned %08x\n", Status);
+
+    RtlCopyMemory(target, BTRFS_VOLUME_PREFIX, sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR));
+
+    w = &target[(sizeof(BTRFS_VOLUME_PREFIX) / sizeof(WCHAR)) - 1];
+
+#ifndef __REACTOS__
+    for (unsigned int i = 0; i < 16; i++) {
+#else
+    for (i = 0; i < 16; i++) {
+#endif
+        *w = hex_digit(uuid->uuid[i] >> 4); w++;
+        *w = hex_digit(uuid->uuid[i] & 0xf); w++;
+
+        if (i == 3 || i == 5 || i == 7 || i == 9) {
+            *w = L'-';
+            w++;
+        }
+    }
+
+    *w = L'}';
+
+    us2.Buffer = target;
+    us2.Length = us2.MaximumLength = sizeof(target);
+
+    Status = IoCreateSymbolicLink(&us, &us2);
+    if (!NT_SUCCESS(Status))
+        ERR("IoCreateSymbolicLink returned %08x\n", Status);
+}
+
+/* If booting from Btrfs, Windows will pass the device object for the raw partition to
+ * mount_vol - which is no good to us, as we only use the \Device\Btrfs{} devices we
+ * create so that RAID works correctly.
+ * At the time check_system_root gets called, \SystemRoot is a symlink to the ARC device,
+ * e.g. \ArcName\multi(0)disk(0)rdisk(0)partition(1)\Windows. We can't change the symlink,
+ * as it gets clobbered by IopReassignSystemRoot shortly afterwards, and we can't touch
+ * the \ArcName symlinks as they haven't been created yet. Instead, we need to change the
+ * symlink \Device\HarddiskX\PartitionY, which is what the ArcName symlink will shortly
+ * point to.
+ */
+void __stdcall check_system_root(PDRIVER_OBJECT DriverObject, PVOID Context, ULONG Count) {
+    uint32_t disk_num, partition_num;
+    LIST_ENTRY* le;
+    bool done = false;
+
+    TRACE("(%p, %p, %u)\n", DriverObject, Context, Count);
+
+    if (!get_system_root_partition(&disk_num, &partition_num))
+        return;
+
+    TRACE("system boot partition is disk %u, partition %u\n", disk_num, partition_num);
+
+    ExAcquireResourceSharedLite(&pdo_list_lock, true);
+
+    le = pdo_list.Flink;
+    while (le != &pdo_list) {
+        LIST_ENTRY* le2;
+        pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
+
+        ExAcquireResourceSharedLite(&pdode->child_lock, true);
+
+        le2 = pdode->children.Flink;
+
+        while (le2 != &pdode->children) {
+            volume_child* vc = CONTAINING_RECORD(le2, volume_child, list_entry);
+
+            if (vc->disk_num == disk_num && vc->part_num == partition_num) {
+                change_symlink(disk_num, partition_num, &pdode->uuid);
+                done = true;
+                break;
+            }
+
+            le2 = le2->Flink;
+        }
+
+        ExReleaseResourceLite(&pdode->child_lock);
+
+        if (done)
+            break;
+
+        le = le->Flink;
+    }
+
+    ExReleaseResourceLite(&pdo_list_lock);
+}
diff --git a/drivers/filesystems/btrfs/btrfs.c b/drivers/filesystems/btrfs/btrfs.c
index c480d9f0502..61f3dc666db 100644
--- a/drivers/filesystems/btrfs/btrfs.c
+++ b/drivers/filesystems/btrfs/btrfs.c
@@ -46,6 +46,12 @@
 #undef INITGUID
 #endif
 
+#ifdef _MSC_VER
+#include <ntstrsafe.h>
+#else
+NTSTATUS RtlStringCbVPrintfA(char* pszDest, size_t cbDest, const char* pszFormat, va_list argList); // not in mingw
+#endif
+
 #define INCOMPAT_SUPPORTED (BTRFS_INCOMPAT_FLAGS_MIXED_BACKREF | BTRFS_INCOMPAT_FLAGS_DEFAULT_SUBVOL | BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS | \
                             BTRFS_INCOMPAT_FLAGS_COMPRESS_LZO | BTRFS_INCOMPAT_FLAGS_BIG_METADATA | BTRFS_INCOMPAT_FLAGS_RAID56 | \
                             BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF | BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA | BTRFS_INCOMPAT_FLAGS_NO_HOLES | \
@@ -58,45 +64,49 @@ static const WCHAR dosdevice_name[] = {'\\','D','o','s','D','e','v','i','c','e',
 DEFINE_GUID(BtrfsBusInterface, 0x4d414874, 0x6865, 0x6761, 0x6d, 0x65, 0x83, 0x69, 0x17, 0x9a, 0x7d, 0x1d);
 
 PDRIVER_OBJECT drvobj;
-PDEVICE_OBJECT master_devobj;
+PDEVICE_OBJECT master_devobj, busobj;
 #ifndef __REACTOS__
-BOOL have_sse42 = FALSE, have_sse2 = FALSE;
+bool have_sse42 = false, have_sse2 = false;
 #endif
-UINT64 num_reads = 0;
+uint64_t num_reads = 0;
 LIST_ENTRY uid_map_list, gid_map_list;
 LIST_ENTRY VcbList;
 ERESOURCE global_loading_lock;
-UINT32 debug_log_level = 0;
-UINT32 mount_compress = 0;
-UINT32 mount_compress_force = 0;
-UINT32 mount_compress_type = 0;
-UINT32 mount_zlib_level = 3;
-UINT32 mount_zstd_level = 3;
-UINT32 mount_flush_interval = 30;
-UINT32 mount_max_inline = 2048;
-UINT32 mount_skip_balance = 0;
-UINT32 mount_no_barrier = 0;
-UINT32 mount_no_trim = 0;
-UINT32 mount_clear_cache = 0;
-UINT32 mount_allow_degraded = 0;
-UINT32 mount_readonly = 0;
-UINT32 no_pnp = 0;
-BOOL log_started = FALSE;
+uint32_t debug_log_level = 0;
+uint32_t mount_compress = 0;
+uint32_t mount_compress_force = 0;
+uint32_t mount_compress_type = 0;
+uint32_t mount_zlib_level = 3;
+uint32_t mount_zstd_level = 3;
+uint32_t mount_flush_interval = 30;
+uint32_t mount_max_inline = 2048;
+uint32_t mount_skip_balance = 0;
+uint32_t mount_no_barrier = 0;
+uint32_t mount_no_trim = 0;
+uint32_t mount_clear_cache = 0;
+uint32_t mount_allow_degraded = 0;
+uint32_t mount_readonly = 0;
+uint32_t no_pnp = 0;
+bool log_started = false;
 UNICODE_STRING log_device, log_file, registry_path;
 tPsUpdateDiskCounters fPsUpdateDiskCounters;
 tCcCopyReadEx fCcCopyReadEx;
 tCcCopyWriteEx fCcCopyWriteEx;
 tCcSetAdditionalCacheAttributesEx fCcSetAdditionalCacheAttributesEx;
 tFsRtlUpdateDiskCounters fFsRtlUpdateDiskCounters;
-BOOL diskacc = FALSE;
+tIoUnregisterPlugPlayNotificationEx fIoUnregisterPlugPlayNotificationEx;
+tFsRtlGetEcpListFromIrp fFsRtlGetEcpListFromIrp;
+tFsRtlGetNextExtraCreateParameter fFsRtlGetNextExtraCreateParameter;
+tFsRtlValidateReparsePointBuffer fFsRtlValidateReparsePointBuffer;
+bool diskacc = false;
 void *notification_entry = NULL, *notification_entry2 = NULL, *notification_entry3 = NULL;
 ERESOURCE pdo_list_lock, mapping_lock;
 LIST_ENTRY pdo_list;
-BOOL finished_probing = FALSE;
+bool finished_probing = false;
 HANDLE degraded_wait_handle = NULL, mountmgr_thread_handle = NULL;
-BOOL degraded_wait = TRUE;
+bool degraded_wait = true;
 KEVENT mountmgr_thread_event;
-BOOL shutting_down = FALSE;
+bool shutting_down = false;
 
 #ifdef _DEBUG
 PFILE_OBJECT comfo = NULL;
@@ -105,7 +115,7 @@ HANDLE log_handle = NULL;
 ERESOURCE log_lock;
 HANDLE serial_thread_handle = NULL;
 
-static void init_serial(BOOL first_time);
+static void init_serial(bool first_time);
 #endif
 
 static NTSTATUS close_file(_In_ PFILE_OBJECT FileObject, _In_ PIRP Irp);
@@ -115,19 +125,24 @@ typedef struct {
     IO_STATUS_BLOCK iosb;
 } read_context;
 
+// no longer in Windows headers??
+extern BOOLEAN WdmlibRtlIsNtDdiVersionAvailable(ULONG Version);
+
 #ifdef _DEBUG
 _Function_class_(IO_COMPLETION_ROUTINE)
-static NTSTATUS dbg_completion(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PVOID conptr) {
+static NTSTATUS __stdcall dbg_completion(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PVOID conptr) {
     read_context* context = conptr;
 
     UNUSED(DeviceObject);
 
     context->iosb = Irp->IoStatus;
-    KeSetEvent(&context->Event, 0, FALSE);
+    KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
 
+#define DEBUG_MESSAGE_LEN 1024
+
 #ifdef DEBUG_LONG_MESSAGES
 void _debug_message(_In_ const char* func, _In_ const char* file, _In_ unsigned int line, _In_ char* s, ...) {
 #else
@@ -140,9 +155,9 @@ void _debug_message(_In_ const char* func, _In_ char* s, ...) {
     va_list ap;
     char *buf2, *buf;
     read_context context;
-    UINT32 length;
+    uint32_t length;
 
-    buf2 = ExAllocatePoolWithTag(NonPagedPool, 1024, ALLOC_TAG);
+    buf2 = ExAllocatePoolWithTag(NonPagedPool, DEBUG_MESSAGE_LEN, ALLOC_TAG);
 
     if (!buf2) {
         DbgPrint("Couldn't allocate buffer in debug_message\n");
@@ -157,29 +172,29 @@ void _debug_message(_In_ const char* func, _In_ char* s, ...) {
     buf = &buf2[strlen(buf2)];
 
     va_start(ap, s);
-    vsprintf(buf, s, ap);
 
-    ExAcquireResourceSharedLite(&log_lock, TRUE);
+    RtlStringCbVPrintfA(buf, DEBUG_MESSAGE_LEN - strlen(buf2), s, ap);
+
+    ExAcquireResourceSharedLite(&log_lock, true);
 
     if (!log_started || (log_device.Length == 0 && log_file.Length == 0)) {
         DbgPrint(buf2);
     } else if (log_device.Length > 0) {
         if (!comdo) {
-            DbgPrint("comdo is NULL :-(\n");
             DbgPrint(buf2);
             goto exit2;
         }
 
-        length = (UINT32)strlen(buf2);
+        length = (uint32_t)strlen(buf2);
 
         offset.u.LowPart = 0;
         offset.u.HighPart = 0;
 
         RtlZeroMemory(&context, sizeof(read_context));
 
-        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+        KeInitializeEvent(&context.Event, NotificationEvent, false);
 
-        Irp = IoAllocateIrp(comdo->StackSize, FALSE);
+        Irp = IoAllocateIrp(comdo->StackSize, false);
 
         if (!Irp) {
             DbgPrint("IoAllocateIrp failed\n");
@@ -188,13 +203,14 @@ void _debug_message(_In_ const char* func, _In_ char* s, ...) {
 
         IrpSp = IoGetNextIrpStackLocation(Irp);
         IrpSp->MajorFunction = IRP_MJ_WRITE;
+        IrpSp->FileObject = comfo;
 
         if (comdo->Flags & DO_BUFFERED_IO) {
             Irp->AssociatedIrp.SystemBuffer = buf2;
 
             Irp->Flags = IRP_BUFFERED_IO;
         } else if (comdo->Flags & DO_DIRECT_IO) {
-            Irp->MdlAddress = IoAllocateMdl(buf2, length, FALSE, FALSE, NULL);
+            Irp->MdlAddress = IoAllocateMdl(buf2, length, false, false, NULL);
             if (!Irp->MdlAddress) {
                 DbgPrint("IoAllocateMdl failed\n");
                 goto exit;
@@ -212,12 +228,12 @@ void _debug_message(_In_ const char* func, _In_ char* s, ...) {
 
         Irp->UserEvent = &context.Event;
 
-        IoSetCompletionRoutine(Irp, dbg_completion, &context, TRUE, TRUE, TRUE);
+        IoSetCompletionRoutine(Irp, dbg_completion, &context, true, true, true);
 
         Status = IoCallDriver(comdo, Irp);
 
         if (Status == STATUS_PENDING) {
-            KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+            KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
             Status = context.iosb.Status;
         }
 
@@ -234,7 +250,7 @@ exit:
     } else if (log_handle != NULL) {
         IO_STATUS_BLOCK iosb;
 
-        length = (UINT32)strlen(buf2);
+        length = (uint32_t)strlen(buf2);
 
         Status = ZwWriteFile(log_handle, NULL, NULL, NULL, &iosb, buf2, length, NULL, NULL);
 
@@ -253,49 +269,45 @@ exit2:
 }
 #endif
 
-BOOL is_top_level(_In_ PIRP Irp) {
+bool is_top_level(_In_ PIRP Irp) {
     if (!IoGetTopLevelIrp()) {
         IoSetTopLevelIrp(Irp);
-        return TRUE;
+        return true;
     }
 
-    return FALSE;
+    return false;
 }
 
 _Function_class_(DRIVER_UNLOAD)
-#ifdef __REACTOS__
-static void NTAPI DriverUnload(_In_ PDRIVER_OBJECT DriverObject) {
-#else
-static void DriverUnload(_In_ PDRIVER_OBJECT DriverObject) {
-#endif
+static void __stdcall DriverUnload(_In_ PDRIVER_OBJECT DriverObject) {
     UNICODE_STRING dosdevice_nameW;
 
-    TRACE("(%p)\n");
+    TRACE("(%p)\n", DriverObject);
 
     free_cache();
 
     IoUnregisterFileSystem(DriverObject->DeviceObject);
 
-    if (notification_entry2)
-#ifdef __REACTOS__
-        IoUnregisterPlugPlayNotification(notification_entry2);
-#else
-        IoUnregisterPlugPlayNotificationEx(notification_entry2);
-#endif
+    if (notification_entry2) {
+        if (fIoUnregisterPlugPlayNotificationEx)
+            fIoUnregisterPlugPlayNotificationEx(notification_entry2);
+        else
+            IoUnregisterPlugPlayNotification(notification_entry2);
+    }
 
-    if (notification_entry3)
-#ifdef __REACTOS__
-        IoUnregisterPlugPlayNotification(notification_entry3);
-#else
-        IoUnregisterPlugPlayNotificationEx(notification_entry3);
-#endif
+    if (notification_entry3) {
+        if (fIoUnregisterPlugPlayNotificationEx)
+            fIoUnregisterPlugPlayNotificationEx(notification_entry3);
+        else
+            IoUnregisterPlugPlayNotification(notification_entry3);
+    }
 
-    if (notification_entry)
-#ifdef __REACTOS__
-        IoUnregisterPlugPlayNotification(notification_entry);
-#else
-        IoUnregisterPlugPlayNotificationEx(notification_entry);
-#endif
+    if (notification_entry) {
+        if (fIoUnregisterPlugPlayNotificationEx)
+            fIoUnregisterPlugPlayNotificationEx(notification_entry);
+        else
+            IoUnregisterPlugPlayNotification(notification_entry);
+    }
 
     dosdevice_nameW.Buffer = (WCHAR*)dosdevice_name;
     dosdevice_nameW.Length = dosdevice_nameW.MaximumLength = sizeof(dosdevice_name) - sizeof(WCHAR);
@@ -347,7 +359,7 @@ static void DriverUnload(_In_ PDRIVER_OBJECT DriverObject) {
     ExDeleteResourceLite(&mapping_lock);
 }
 
-static BOOL get_last_inode(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _In_opt_ PIRP Irp) {
+static bool get_last_inode(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _In_opt_ PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp, prev_tp;
     NTSTATUS Status;
@@ -357,46 +369,46 @@ static BOOL get_last_inode(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock
     searchkey.obj_type = 0xff;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, r, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, r, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
     if (tp.item->key.obj_type == TYPE_INODE_ITEM || (tp.item->key.obj_type == TYPE_ROOT_ITEM && !(tp.item->key.obj_id & 0x8000000000000000))) {
         r->lastinode = tp.item->key.obj_id;
-        TRACE("last inode for tree %llx is %llx\n", r->id, r->lastinode);
-        return TRUE;
+        TRACE("last inode for tree %I64x is %I64x\n", r->id, r->lastinode);
+        return true;
     }
 
     while (find_prev_item(Vcb, &tp, &prev_tp, Irp)) {
         tp = prev_tp;
 
-        TRACE("moving on to %llx,%x,%llx\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+        TRACE("moving on to %I64x,%x,%I64x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
 
         if (tp.item->key.obj_type == TYPE_INODE_ITEM || (tp.item->key.obj_type == TYPE_ROOT_ITEM && !(tp.item->key.obj_id & 0x8000000000000000))) {
             r->lastinode = tp.item->key.obj_id;
-            TRACE("last inode for tree %llx is %llx\n", r->id, r->lastinode);
-            return TRUE;
+            TRACE("last inode for tree %I64x is %I64x\n", r->id, r->lastinode);
+            return true;
         }
     }
 
     r->lastinode = SUBVOL_ROOT_INODE;
 
-    WARN("no INODE_ITEMs in tree %llx\n", r->id);
+    WARN("no INODE_ITEMs in tree %I64x\n", r->id);
 
-    return TRUE;
+    return true;
 }
 
 _Success_(return)
-static BOOL extract_xattr(_In_reads_bytes_(size) void* item, _In_ USHORT size, _In_z_ char* name, _Out_ UINT8** data, _Out_ UINT16* datalen) {
+static bool extract_xattr(_In_reads_bytes_(size) void* item, _In_ USHORT size, _In_z_ char* name, _Out_ uint8_t** data, _Out_ uint16_t* datalen) {
     DIR_ITEM* xa = (DIR_ITEM*)item;
     USHORT xasize;
 
-    while (TRUE) {
+    while (true) {
         if (size < sizeof(DIR_ITEM) || size < (sizeof(DIR_ITEM) - 1 + xa->m + xa->n)) {
             WARN("DIR_ITEM is truncated\n");
-            return FALSE;
+            return false;
         }
 
         if (xa->n == strlen(name) && RtlCompareMemory(name, xa->name, xa->n) == xa->n) {
@@ -408,14 +420,14 @@ static BOOL extract_xattr(_In_reads_bytes_(size) void* item, _In_ USHORT size, _
                 *data = ExAllocatePoolWithTag(PagedPool, xa->m, ALLOC_TAG);
                 if (!*data) {
                     ERR("out of memory\n");
-                    return FALSE;
+                    return false;
                 }
 
                 RtlCopyMemory(*data, &xa->name[xa->n], xa->m);
             } else
                 *data = NULL;
 
-            return TRUE;
+            return true;
         }
 
         xasize = sizeof(DIR_ITEM) - 1 + xa->m + xa->n;
@@ -429,36 +441,36 @@ static BOOL extract_xattr(_In_reads_bytes_(size) void* item, _In_ USHORT size, _
 
     TRACE("xattr %s not found\n", name);
 
-    return FALSE;
+    return false;
 }
 
 _Success_(return)
-BOOL get_xattr(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* subvol, _In_ UINT64 inode, _In_z_ char* name, _In_ UINT32 crc32,
-               _Out_ UINT8** data, _Out_ UINT16* datalen, _In_opt_ PIRP Irp) {
+bool get_xattr(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* subvol, _In_ uint64_t inode, _In_z_ char* name, _In_ uint32_t crc32,
+               _Out_ uint8_t** data, _Out_ uint16_t* datalen, _In_opt_ PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
 
-    TRACE("(%p, %llx, %llx, %s, %08x, %p, %p)\n", Vcb, subvol->id, inode, name, crc32, data, datalen);
+    TRACE("(%p, %I64x, %I64x, %s, %08x, %p, %p)\n", Vcb, subvol->id, inode, name, crc32, data, datalen);
 
     searchkey.obj_id = inode;
     searchkey.obj_type = TYPE_XATTR_ITEM;
     searchkey.offset = crc32;
 
-    Status = find_item(Vcb, subvol, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, subvol, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
     if (keycmp(tp.item->key, searchkey)) {
-        TRACE("could not find item (%llx,%x,%llx)\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
-        return FALSE;
+        TRACE("could not find item (%I64x,%x,%I64x)\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+        return false;
     }
 
     if (tp.item->size < sizeof(DIR_ITEM)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DIR_ITEM));
-        return FALSE;
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DIR_ITEM));
+        return false;
     }
 
     return extract_xattr(tp.item->data, tp.item->size, name, data, datalen);
@@ -466,15 +478,11 @@ BOOL get_xattr(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
 
 _Dispatch_type_(IRP_MJ_CLOSE)
 _Function_class_(DRIVER_DISPATCH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI drv_close(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#else
-static NTSTATUS drv_close(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#endif
+static NTSTATUS __stdcall drv_close(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp;
     device_extension* Vcb = DeviceObject->DeviceExtension;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -519,17 +527,13 @@ end:
 
 _Dispatch_type_(IRP_MJ_FLUSH_BUFFERS)
 _Function_class_(DRIVER_DISPATCH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI drv_flush_buffers(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#else
-static NTSTATUS drv_flush_buffers(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#endif
+static NTSTATUS __stdcall drv_flush_buffers(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     fcb* fcb = FileObject->FsContext;
     device_extension* Vcb = DeviceObject->DeviceExtension;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -541,18 +545,18 @@ static NTSTATUS drv_flush_buffers(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Ir
         Status = vol_flush_buffers(DeviceObject, Irp);
         goto end;
     } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
-        Status = STATUS_INVALID_PARAMETER;
+        Status = STATUS_SUCCESS;
         goto end;
     }
 
     if (!fcb) {
         ERR("fcb was NULL\n");
-        Status = STATUS_INVALID_PARAMETER;
+        Status = STATUS_SUCCESS;
         goto end;
     }
 
     if (fcb == Vcb->volume_fcb) {
-        Status = STATUS_INVALID_PARAMETER;
+        Status = STATUS_SUCCESS;
         goto end;
     }
 
@@ -564,10 +568,10 @@ static NTSTATUS drv_flush_buffers(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Ir
     Irp->IoStatus.Status = Status;
 
     if (fcb->type != BTRFS_TYPE_DIRECTORY) {
-        CcFlushCache(&fcb->nonpaged->segment_object, NULL, 0, &Irp->IoStatus);
+        CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, &Irp->IoStatus);
 
         if (fcb->Header.PagingIoResource) {
-            ExAcquireResourceExclusiveLite(fcb->Header.PagingIoResource, TRUE);
+            ExAcquireResourceExclusiveLite(fcb->Header.PagingIoResource, true);
             ExReleaseResourceLite(fcb->Header.PagingIoResource);
         }
 
@@ -587,8 +591,8 @@ end:
     return Status;
 }
 
-static void calculate_total_space(_In_ device_extension* Vcb, _Out_ UINT64* totalsize, _Out_ UINT64* freespace) {
-    UINT64 nfactor, dfactor, sectors_used;
+static void calculate_total_space(_In_ device_extension* Vcb, _Out_ uint64_t* totalsize, _Out_ uint64_t* freespace) {
+    uint64_t nfactor, dfactor, sectors_used;
 
     if (Vcb->data_flags & BLOCK_FLAG_DUPLICATE || Vcb->data_flags & BLOCK_FLAG_RAID1 || Vcb->data_flags & BLOCK_FLAG_RAID10) {
         nfactor = 1;
@@ -617,7 +621,7 @@ static void calculate_total_space(_In_ device_extension* Vcb, _Out_ UINT64* tota
 // The command mklink refuses to create hard links on anything other than NTFS, so we have to
 // blacklist cmd.exe too.
 
-static BOOL lie_about_fs_type() {
+static bool lie_about_fs_type() {
     NTSTATUS Status;
     PROCESS_BASIC_INFORMATION pbi;
     PPEB peb;
@@ -640,34 +644,34 @@ static BOOL lie_about_fs_type() {
     fsutilus.Length = fsutilus.MaximumLength = sizeof(fsutil) - sizeof(WCHAR);
 
     if (!PsGetCurrentProcess())
-        return FALSE;
+        return false;
 
 #ifdef _AMD64_
     Status = ZwQueryInformationProcess(NtCurrentProcess(), ProcessWow64Information, &wow64info, sizeof(wow64info), NULL);
 
     if (NT_SUCCESS(Status) && wow64info != 0)
-        return TRUE;
+        return true;
 #endif
 
     Status = ZwQueryInformationProcess(NtCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), &retlen);
 
     if (!NT_SUCCESS(Status)) {
         ERR("ZwQueryInformationProcess returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
     if (!pbi.PebBaseAddress)
-        return FALSE;
+        return false;
 
     peb = pbi.PebBaseAddress;
 
     if (!peb->Ldr)
-        return FALSE;
+        return false;
 
     le = peb->Ldr->InMemoryOrderModuleList.Flink;
     while (le != &peb->Ldr->InMemoryOrderModuleList) {
         LDR_DATA_TABLE_ENTRY* entry = CONTAINING_RECORD(le, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks);
-        BOOL blacklist = FALSE;
+        bool blacklist = false;
 
         if (entry->FullDllName.Length >= mprus.Length) {
             UNICODE_STRING name;
@@ -675,7 +679,7 @@ static BOOL lie_about_fs_type() {
             name.Buffer = &entry->FullDllName.Buffer[(entry->FullDllName.Length - mprus.Length) / sizeof(WCHAR)];
             name.Length = name.MaximumLength = mprus.Length;
 
-            blacklist = FsRtlAreNamesEqual(&name, &mprus, TRUE, NULL);
+            blacklist = FsRtlAreNamesEqual(&name, &mprus, true, NULL);
         }
 
         if (!blacklist && entry->FullDllName.Length >= cmdus.Length) {
@@ -684,7 +688,7 @@ static BOOL lie_about_fs_type() {
             name.Buffer = &entry->FullDllName.Buffer[(entry->FullDllName.Length - cmdus.Length) / sizeof(WCHAR)];
             name.Length = name.MaximumLength = cmdus.Length;
 
-            blacklist = FsRtlAreNamesEqual(&name, &cmdus, TRUE, NULL);
+            blacklist = FsRtlAreNamesEqual(&name, &cmdus, true, NULL);
         }
 
         if (!blacklist && entry->FullDllName.Length >= fsutilus.Length) {
@@ -693,7 +697,7 @@ static BOOL lie_about_fs_type() {
             name.Buffer = &entry->FullDllName.Buffer[(entry->FullDllName.Length - fsutilus.Length) / sizeof(WCHAR)];
             name.Length = name.MaximumLength = fsutilus.Length;
 
-            blacklist = FsRtlAreNamesEqual(&name, &fsutilus, TRUE, NULL);
+            blacklist = FsRtlAreNamesEqual(&name, &fsutilus, true, NULL);
         }
 
         if (blacklist) {
@@ -703,7 +707,7 @@ static BOOL lie_about_fs_type() {
             frames = ExAllocatePoolWithTag(PagedPool, 256 * sizeof(void*), ALLOC_TAG);
             if (!frames) {
                 ERR("out of memory\n");
-                return FALSE;
+                return false;
             }
 
             num_frames = RtlWalkFrameChain(frames, 256, 1);
@@ -712,7 +716,7 @@ static BOOL lie_about_fs_type() {
                 // entry->Reserved3[1] appears to be the image size
                 if (frames[i] >= entry->DllBase && (ULONG_PTR)frames[i] <= (ULONG_PTR)entry->DllBase + (ULONG_PTR)entry->Reserved3[1]) {
                     ExFreePool(frames);
-                    return TRUE;
+                    return true;
                 }
             }
 
@@ -722,22 +726,217 @@ static BOOL lie_about_fs_type() {
         le = le->Flink;
     }
 
-    return FALSE;
+    return false;
 }
 #endif
 
-_Dispatch_type_(IRP_MJ_QUERY_VOLUME_INFORMATION)
-_Function_class_(DRIVER_DISPATCH)
+// version of RtlUTF8ToUnicodeN for Vista and below
+NTSTATUS utf8_to_utf16(WCHAR* dest, ULONG dest_max, ULONG* dest_len, char* src, ULONG src_len) {
+    NTSTATUS Status = STATUS_SUCCESS;
+    uint8_t* in = (uint8_t*)src;
+    uint16_t* out = (uint16_t*)dest;
+    ULONG needed = 0, left = dest_max / sizeof(uint16_t);
+#ifdef __REACTOS__
+    ULONG i;
+
+    for (i = 0; i < src_len; ++i) {
+#else
+
+    for (ULONG i = 0; i < src_len; i++) {
+#endif
+        uint32_t cp;
+
+        if (!(in[i] & 0x80))
+            cp = in[i];
+        else if ((in[i] & 0xe0) == 0xc0) {
+            if (i == src_len - 1 || (in[i+1] & 0xc0) != 0x80) {
+                cp = 0xfffd;
+                Status = STATUS_SOME_NOT_MAPPED;
+            } else {
+                cp = ((in[i] & 0x1f) << 6) | (in[i+1] & 0x3f);
+                i++;
+            }
+        } else if ((in[i] & 0xf0) == 0xe0) {
+            if (i >= src_len - 2 || (in[i+1] & 0xc0) != 0x80 || (in[i+2] & 0xc0) != 0x80) {
+                cp = 0xfffd;
+                Status = STATUS_SOME_NOT_MAPPED;
+            } else {
+                cp = ((in[i] & 0xf) << 12) | ((in[i+1] & 0x3f) << 6) | (in[i+2] & 0x3f);
+                i += 2;
+            }
+        } else if ((in[i] & 0xf8) == 0xf0) {
+            if (i >= src_len - 3 || (in[i+1] & 0xc0) != 0x80 || (in[i+2] & 0xc0) != 0x80 || (in[i+3] & 0xc0) != 0x80) {
+                cp = 0xfffd;
+                Status = STATUS_SOME_NOT_MAPPED;
+            } else {
+                cp = ((in[i] & 0x7) << 18) | ((in[i+1] & 0x3f) << 12) | ((in[i+2] & 0x3f) << 6) | (in[i+3] & 0x3f);
+                i += 3;
+            }
+        } else {
+            cp = 0xfffd;
+            Status = STATUS_SOME_NOT_MAPPED;
+        }
+
+        if (cp > 0x10ffff) {
+            cp = 0xfffd;
+            Status = STATUS_SOME_NOT_MAPPED;
+        }
+
+        if (dest) {
+            if (cp <= 0xffff) {
+                if (left < 1)
+                    return STATUS_BUFFER_OVERFLOW;
+
+                *out = (uint16_t)cp;
+                out++;
+
+                left--;
+            } else {
+                if (left < 2)
+                    return STATUS_BUFFER_OVERFLOW;
+
+                cp -= 0x10000;
+
+                *out = 0xd800 | ((cp & 0xffc00) >> 10);
+                out++;
+
+                *out = 0xdc00 | (cp & 0x3ff);
+                out++;
+
+                left -= 2;
+            }
+        }
+
+        if (cp <= 0xffff)
+            needed += sizeof(uint16_t);
+        else
+            needed += 2 * sizeof(uint16_t);
+    }
+
+    if (dest_len)
+        *dest_len = needed;
+
+    return Status;
+}
+
+// version of RtlUnicodeToUTF8N for Vista and below
+NTSTATUS utf16_to_utf8(char* dest, ULONG dest_max, ULONG* dest_len, WCHAR* src, ULONG src_len) {
+    NTSTATUS Status = STATUS_SUCCESS;
+    uint16_t* in = (uint16_t*)src;
+    uint8_t* out = (uint8_t*)dest;
+    ULONG in_len = src_len / sizeof(uint16_t);
+    ULONG needed = 0, left = dest_max;
 #ifdef __REACTOS__
-static NTSTATUS NTAPI drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
+    ULONG i = 0;
+
+    for (i = 0; i < in_len; i++) {
 #else
-static NTSTATUS drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
+
+    for (ULONG i = 0; i < in_len; i++) {
 #endif
+        uint32_t cp = *in;
+        in++;
+
+        if ((cp & 0xfc00) == 0xd800) {
+            if (i == in_len - 1 || (*in & 0xfc00) != 0xdc00) {
+                cp = 0xfffd;
+                Status = STATUS_SOME_NOT_MAPPED;
+            } else {
+                cp = (cp & 0x3ff) << 10;
+                cp |= *in & 0x3ff;
+                cp += 0x10000;
+
+                in++;
+                i++;
+            }
+        } else if ((cp & 0xfc00) == 0xdc00) {
+            cp = 0xfffd;
+            Status = STATUS_SOME_NOT_MAPPED;
+        }
+
+        if (cp > 0x10ffff) {
+            cp = 0xfffd;
+            Status = STATUS_SOME_NOT_MAPPED;
+        }
+
+        if (dest) {
+            if (cp < 0x80) {
+                if (left < 1)
+                    return STATUS_BUFFER_OVERFLOW;
+
+                *out = (uint8_t)cp;
+                out++;
+
+                left--;
+            } else if (cp < 0x800) {
+                if (left < 2)
+                    return STATUS_BUFFER_OVERFLOW;
+
+                *out = 0xc0 | ((cp & 0x7c0) >> 6);
+                out++;
+
+                *out = 0x80 | (cp & 0x3f);
+                out++;
+
+                left -= 2;
+            } else if (cp < 0x10000) {
+                if (left < 3)
+                    return STATUS_BUFFER_OVERFLOW;
+
+                *out = 0xe0 | ((cp & 0xf000) >> 12);
+                out++;
+
+                *out = 0x80 | ((cp & 0xfc0) >> 6);
+                out++;
+
+                *out = 0x80 | (cp & 0x3f);
+                out++;
+
+                left -= 3;
+            } else {
+                if (left < 4)
+                    return STATUS_BUFFER_OVERFLOW;
+
+                *out = 0xf0 | ((cp & 0x1c0000) >> 18);
+                out++;
+
+                *out = 0x80 | ((cp & 0x3f000) >> 12);
+                out++;
+
+                *out = 0x80 | ((cp & 0xfc0) >> 6);
+                out++;
+
+                *out = 0x80 | (cp & 0x3f);
+                out++;
+
+                left -= 4;
+            }
+        }
+
+        if (cp < 0x80)
+            needed++;
+        else if (cp < 0x800)
+            needed += 2;
+        else if (cp < 0x10000)
+            needed += 3;
+        else
+            needed += 4;
+    }
+
+    if (dest_len)
+        *dest_len = needed;
+
+    return Status;
+}
+
+_Dispatch_type_(IRP_MJ_QUERY_VOLUME_INFORMATION)
+_Function_class_(DRIVER_DISPATCH)
+static NTSTATUS __stdcall drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     PIO_STACK_LOCATION IrpSp;
     NTSTATUS Status;
     ULONG BytesCopied = 0;
     device_extension* Vcb = DeviceObject->DeviceExtension;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -760,7 +959,7 @@ static NTSTATUS drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _
         case FileFsAttributeInformation:
         {
             FILE_FS_ATTRIBUTE_INFORMATION* data = Irp->AssociatedIrp.SystemBuffer;
-            BOOL overflow = FALSE;
+            bool overflow = false;
 #ifndef __REACTOS__
             static const WCHAR ntfs[] = L"NTFS";
 #endif
@@ -789,7 +988,7 @@ static NTSTATUS drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _
                 else
                     fs_name_len = 0;
 
-                overflow = TRUE;
+                overflow = true;
             }
 
             data->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES | FILE_CASE_SENSITIVE_SEARCH |
@@ -818,7 +1017,7 @@ static NTSTATUS drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _
 
             ffdi->DeviceType = FILE_DEVICE_DISK;
 
-            ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
             ffdi->Characteristics = Vcb->Vpb->RealDevice->Characteristics;
             ExReleaseResourceLite(&Vcb->tree_lock);
 
@@ -839,10 +1038,10 @@ static NTSTATUS drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _
 
             TRACE("FileFsFullSizeInformation\n");
 
-            calculate_total_space(Vcb, (UINT64*)&ffsi->TotalAllocationUnits.QuadPart, (UINT64*)&ffsi->ActualAvailableAllocationUnits.QuadPart);
+            calculate_total_space(Vcb, (uint64_t*)&ffsi->TotalAllocationUnits.QuadPart, (uint64_t*)&ffsi->ActualAvailableAllocationUnits.QuadPart);
             ffsi->CallerAvailableAllocationUnits.QuadPart = ffsi->ActualAvailableAllocationUnits.QuadPart;
-            ffsi->SectorsPerAllocationUnit = 1;
-            ffsi->BytesPerSector = Vcb->superblock.sector_size;
+            ffsi->SectorsPerAllocationUnit = Vcb->superblock.sector_size / 512;
+            ffsi->BytesPerSector = 512;
 
             BytesCopied = sizeof(FILE_FS_FULL_SIZE_INFORMATION);
             Status = STATUS_SUCCESS;
@@ -871,9 +1070,9 @@ static NTSTATUS drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _
 
             TRACE("FileFsSizeInformation\n");
 
-            calculate_total_space(Vcb, (UINT64*)&ffsi->TotalAllocationUnits.QuadPart, (UINT64*)&ffsi->AvailableAllocationUnits.QuadPart);
-            ffsi->SectorsPerAllocationUnit = 1;
-            ffsi->BytesPerSector = Vcb->superblock.sector_size;
+            calculate_total_space(Vcb, (uint64_t*)&ffsi->TotalAllocationUnits.QuadPart, (uint64_t*)&ffsi->AvailableAllocationUnits.QuadPart);
+            ffsi->SectorsPerAllocationUnit = Vcb->superblock.sector_size / 512;
+            ffsi->BytesPerSector = 512;
 
             BytesCopied = sizeof(FILE_FS_SIZE_INFORMATION);
             Status = STATUS_SUCCESS;
@@ -885,17 +1084,17 @@ static NTSTATUS drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _
         {
             FILE_FS_VOLUME_INFORMATION* data = Irp->AssociatedIrp.SystemBuffer;
             FILE_FS_VOLUME_INFORMATION ffvi;
-            BOOL overflow = FALSE;
+            bool overflow = false;
             ULONG label_len, orig_label_len;
 
             TRACE("FileFsVolumeInformation\n");
             TRACE("max length = %u\n", IrpSp->Parameters.QueryVolume.Length);
 
-            ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-            Status = RtlUTF8ToUnicodeN(NULL, 0, &label_len, Vcb->superblock.label, (ULONG)strlen(Vcb->superblock.label));
+            Status = utf8_to_utf16(NULL, 0, &label_len, Vcb->superblock.label, (ULONG)strlen(Vcb->superblock.label));
             if (!NT_SUCCESS(Status)) {
-                ERR("RtlUTF8ToUnicodeN returned %08x\n", Status);
+                ERR("utf8_to_utf16 returned %08x\n", Status);
                 ExReleaseResourceLite(&Vcb->tree_lock);
                 break;
             }
@@ -908,7 +1107,7 @@ static NTSTATUS drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _
                 else
                     label_len = 0;
 
-                overflow = TRUE;
+                overflow = true;
             }
 
             TRACE("label_len = %u\n", label_len);
@@ -916,16 +1115,16 @@ static NTSTATUS drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _
             ffvi.VolumeCreationTime.QuadPart = 0; // FIXME
             ffvi.VolumeSerialNumber = Vcb->superblock.uuid.uuid[12] << 24 | Vcb->superblock.uuid.uuid[13] << 16 | Vcb->superblock.uuid.uuid[14] << 8 | Vcb->superblock.uuid.uuid[15];
             ffvi.VolumeLabelLength = orig_label_len;
-            ffvi.SupportsObjects = FALSE;
+            ffvi.SupportsObjects = false;
 
             RtlCopyMemory(data, &ffvi, min(sizeof(FILE_FS_VOLUME_INFORMATION) - sizeof(WCHAR), IrpSp->Parameters.QueryVolume.Length));
 
             if (label_len > 0) {
                 ULONG bytecount;
 
-                Status = RtlUTF8ToUnicodeN(&data->VolumeLabel[0], label_len, &bytecount, Vcb->superblock.label, (ULONG)strlen(Vcb->superblock.label));
+                Status = utf8_to_utf16(&data->VolumeLabel[0], label_len, &bytecount, Vcb->superblock.label, (ULONG)strlen(Vcb->superblock.label));
                 if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL) {
-                    ERR("RtlUTF8ToUnicodeN returned %08x\n", Status);
+                    ERR("utf8_to_utf16 returned %08x\n", Status);
                     ExReleaseResourceLite(&Vcb->tree_lock);
                     break;
                 }
@@ -992,23 +1191,19 @@ end:
 }
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI read_completion(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PVOID conptr) {
-#else
-static NTSTATUS read_completion(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PVOID conptr) {
-#endif
+static NTSTATUS __stdcall read_completion(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PVOID conptr) {
     read_context* context = conptr;
 
     UNUSED(DeviceObject);
 
     context->iosb = Irp->IoStatus;
-    KeSetEvent(&context->Event, 0, FALSE);
+    KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
 
-NTSTATUS create_root(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ UINT64 id,
-                     _Out_ root** rootptr, _In_ BOOL no_tree, _In_ UINT64 offset, _In_opt_ PIRP Irp) {
+NTSTATUS create_root(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ uint64_t id,
+                     _Out_ root** rootptr, _In_ bool no_tree, _In_ uint64_t offset, _In_opt_ PIRP Irp) {
     NTSTATUS Status;
     root* r;
     tree* t = NULL;
@@ -1039,8 +1234,8 @@ NTSTATUS create_root(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) devi
 
         t->nonpaged = NULL;
 
-        t->is_unique = TRUE;
-        t->uniqueness_determined = TRUE;
+        t->is_unique = true;
+        t->uniqueness_determined = true;
         t->buf = NULL;
     }
 
@@ -1061,15 +1256,15 @@ NTSTATUS create_root(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) devi
     r->treeholder.generation = Vcb->superblock.generation;
     r->treeholder.tree = t;
     r->lastinode = 0;
-    r->dirty = FALSE;
-    r->received = FALSE;
+    r->dirty = false;
+    r->received = false;
     r->reserved = NULL;
     r->parent = 0;
     r->send_ops = 0;
     RtlZeroMemory(&r->root_item, sizeof(ROOT_ITEM));
     r->root_item.num_references = 1;
     r->fcbs_version = 0;
-    r->checked_for_orphans = TRUE;
+    r->checked_for_orphans = true;
     InitializeListHead(&r->fcbs);
     RtlZeroMemory(r->fcbs_ptrs, sizeof(LIST_ENTRY*) * 256);
 
@@ -1106,7 +1301,7 @@ NTSTATUS create_root(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) devi
         t->header.num_items = 0;
         t->header.level = 0;
 
-        t->has_address = FALSE;
+        t->has_address = false;
         t->size = 0;
         t->Vcb = Vcb;
         t->parent = NULL;
@@ -1116,14 +1311,14 @@ NTSTATUS create_root(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) devi
         InitializeListHead(&t->itemlist);
 
         t->new_address = 0;
-        t->has_new_address = FALSE;
-        t->updated_extents = FALSE;
+        t->has_new_address = false;
+        t->updated_extents = false;
 
         InsertTailList(&Vcb->trees, &t->list_entry);
         t->list_entry_hash.Flink = NULL;
 
-        t->write = TRUE;
-        Vcb->need_write = TRUE;
+        t->write = true;
+        Vcb->need_write = true;
     }
 
     *rootptr = r;
@@ -1153,7 +1348,7 @@ static NTSTATUS set_label(_In_ device_extension* Vcb, _In_ FILE_FS_LABEL_INFORMA
     if (vollen == 0) {
         utf8len = 0;
     } else {
-        Status = RtlUnicodeToUTF8N(NULL, 0, &utf8len, ffli->VolumeLabel, vollen);
+        Status = utf16_to_utf8(NULL, 0, &utf8len, ffli->VolumeLabel, vollen);
         if (!NT_SUCCESS(Status))
             goto end;
 
@@ -1163,10 +1358,10 @@ static NTSTATUS set_label(_In_ device_extension* Vcb, _In_ FILE_FS_LABEL_INFORMA
         }
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     if (utf8len > 0) {
-        Status = RtlUnicodeToUTF8N((PCHAR)&Vcb->superblock.label, MAX_LABEL_SIZE, &utf8len, ffli->VolumeLabel, vollen);
+        Status = utf16_to_utf8((PCHAR)&Vcb->superblock.label, MAX_LABEL_SIZE, &utf8len, ffli->VolumeLabel, vollen);
         if (!NT_SUCCESS(Status))
             goto release;
     } else
@@ -1175,7 +1370,7 @@ static NTSTATUS set_label(_In_ device_extension* Vcb, _In_ FILE_FS_LABEL_INFORMA
     if (utf8len < MAX_LABEL_SIZE)
         RtlZeroMemory(Vcb->superblock.label + utf8len, MAX_LABEL_SIZE - utf8len);
 
-    Vcb->need_write = TRUE;
+    Vcb->need_write = true;
 
 release:
     ExReleaseResourceLite(&Vcb->tree_lock);
@@ -1188,15 +1383,11 @@ end:
 
 _Dispatch_type_(IRP_MJ_SET_VOLUME_INFORMATION)
 _Function_class_(DRIVER_DISPATCH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI drv_set_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#else
-static NTSTATUS drv_set_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#endif
+static NTSTATUS __stdcall drv_set_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     device_extension* Vcb = DeviceObject->DeviceExtension;
     NTSTATUS Status;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -1280,7 +1471,7 @@ static WCHAR* file_desc_fcb(_In_ fcb* fcb) {
     // GCC doesn't like %llx in sprintf, and MSVC won't let us use swprintf
     // without the CRT, which breaks drivers.
 
-    sprintf(s, "subvol %x, inode %x", (UINT32)fcb->subvol->id, (UINT32)fcb->inode);
+    sprintf(s, "subvol %x, inode %x", (uint32_t)fcb->subvol->id, (uint32_t)fcb->inode);
 
     as.Buffer = s;
     as.Length = as.MaximumLength = (USHORT)strlen(s);
@@ -1289,7 +1480,7 @@ static WCHAR* file_desc_fcb(_In_ fcb* fcb) {
     us.MaximumLength = 60 * sizeof(WCHAR);
     us.Length = 0;
 
-    Status = RtlAnsiStringToUnicodeString(&us, &as, FALSE);
+    Status = RtlAnsiStringToUnicodeString(&us, &as, false);
     if (!NT_SUCCESS(Status))
         return L"(RtlAnsiStringToUnicodeString error)";
 
@@ -1340,6 +1531,9 @@ WCHAR* file_desc(_In_ PFILE_OBJECT FileObject) {
     ccb* ccb = FileObject->FsContext2;
     file_ref* fileref = ccb ? ccb->fileref : NULL;
 
+    if (fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE)
+        return L"(paging file)";
+
     if (fileref)
         return file_desc_fileref(fileref);
     else
@@ -1397,7 +1591,7 @@ void send_notification_fcb(_In_ file_ref* fileref, _In_ ULONG filter_match, _In_
         return;
     }
 
-    ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, true);
 
     le = fcb->hardlinks.Flink;
     while (le != &fcb->hardlinks) {
@@ -1472,7 +1666,7 @@ void mark_fcb_dirty(_In_ fcb* fcb) {
 #ifdef DEBUG_FCB_REFCOUNTS
         LONG rc;
 #endif
-        fcb->dirty = TRUE;
+        fcb->dirty = true;
 
 #ifdef DEBUG_FCB_REFCOUNTS
         rc = InterlockedIncrement(&fcb->refcount);
@@ -1481,25 +1675,25 @@ void mark_fcb_dirty(_In_ fcb* fcb) {
         InterlockedIncrement(&fcb->refcount);
 #endif
 
-        ExAcquireResourceExclusiveLite(&fcb->Vcb->dirty_fcbs_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&fcb->Vcb->dirty_fcbs_lock, true);
         InsertTailList(&fcb->Vcb->dirty_fcbs, &fcb->list_entry_dirty);
         ExReleaseResourceLite(&fcb->Vcb->dirty_fcbs_lock);
     }
 
-    fcb->Vcb->need_write = TRUE;
+    fcb->Vcb->need_write = true;
 }
 
 void mark_fileref_dirty(_In_ file_ref* fileref) {
     if (!fileref->dirty) {
-        fileref->dirty = TRUE;
+        fileref->dirty = true;
         increase_fileref_refcount(fileref);
 
-        ExAcquireResourceExclusiveLite(&fileref->fcb->Vcb->dirty_filerefs_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&fileref->fcb->Vcb->dirty_filerefs_lock, true);
         InsertTailList(&fileref->fcb->Vcb->dirty_filerefs, &fileref->list_entry_dirty);
         ExReleaseResourceLite(&fileref->fcb->Vcb->dirty_filerefs_lock);
     }
 
-    fileref->fcb->Vcb->need_write = TRUE;
+    fileref->fcb->Vcb->need_write = true;
 }
 
 #ifdef DEBUG_FCB_REFCOUNTS
@@ -1511,16 +1705,12 @@ void free_fcb(_Inout_ fcb* fcb) {
 #endif
 
 #ifdef DEBUG_FCB_REFCOUNTS
-#ifdef DEBUG_LONG_MESSAGES
-    ERR("fcb %p (%s): refcount now %i (subvol %llx, inode %llx)\n", fcb, func, rc, fcb->subvol ? fcb->subvol->id : 0, fcb->inode);
-#else
-    ERR("fcb %p (%s): refcount now %i (subvol %llx, inode %llx)\n", fcb, func, rc, fcb->subvol ? fcb->subvol->id : 0, fcb->inode);
-#endif
+    ERR("fcb %p (%s): refcount now %i (subvol %I64x, inode %I64x)\n", fcb, func, rc, fcb->subvol ? fcb->subvol->id : 0, fcb->inode);
 #endif
 }
 
 void reap_fcb(fcb* fcb) {
-    UINT8 c = fcb->hash >> 24;
+    uint8_t c = fcb->hash >> 24;
 
     if (fcb->subvol && fcb->subvol->fcbs_ptrs[c] == &fcb->list_entry) {
         if (fcb->list_entry.Flink != &fcb->subvol->fcbs && (CONTAINING_RECORD(fcb->list_entry.Flink, struct _fcb, list_entry)->hash >> 24) == c)
@@ -1736,21 +1926,21 @@ static NTSTATUS close_file(_In_ PFILE_OBJECT FileObject, _In_ PIRP Irp) {
         fileref = ccb->fileref;
 
         if (fcb->Vcb->running_sends > 0) {
-            BOOL send_cancelled = FALSE;
+            bool send_cancelled = false;
 
-            ExAcquireResourceExclusiveLite(&fcb->Vcb->send_load_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&fcb->Vcb->send_load_lock, true);
 
             if (ccb->send) {
-                ccb->send->cancelling = TRUE;
-                send_cancelled = TRUE;
-                KeSetEvent(&ccb->send->cleared_event, 0, FALSE);
+                ccb->send->cancelling = true;
+                send_cancelled = true;
+                KeSetEvent(&ccb->send->cleared_event, 0, false);
             }
 
             ExReleaseResourceLite(&fcb->Vcb->send_load_lock);
 
             if (send_cancelled) {
                 while (ccb->send) {
-                    ExAcquireResourceExclusiveLite(&fcb->Vcb->send_load_lock, TRUE);
+                    ExAcquireResourceExclusiveLite(&fcb->Vcb->send_load_lock, true);
                     ExReleaseResourceLite(&fcb->Vcb->send_load_lock);
                 }
             }
@@ -1778,15 +1968,15 @@ static NTSTATUS close_file(_In_ PFILE_OBJECT FileObject, _In_ PIRP Irp) {
 }
 
 void uninit(_In_ device_extension* Vcb) {
-    UINT64 i;
+    uint64_t i;
     KIRQL irql;
     NTSTATUS Status;
     LIST_ENTRY* le;
     LARGE_INTEGER time;
 
     if (!Vcb->removing) {
-        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
-        Vcb->removing = TRUE;
+        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
+        Vcb->removing = true;
         ExReleaseResourceLite(&Vcb->tree_lock);
     }
 
@@ -1798,33 +1988,33 @@ void uninit(_In_ device_extension* Vcb) {
     RemoveEntryList(&Vcb->list_entry);
 
     if (Vcb->balance.thread) {
-        Vcb->balance.paused = FALSE;
-        Vcb->balance.stopping = TRUE;
-        KeSetEvent(&Vcb->balance.event, 0, FALSE);
-        KeWaitForSingleObject(&Vcb->balance.finished, Executive, KernelMode, FALSE, NULL);
+        Vcb->balance.paused = false;
+        Vcb->balance.stopping = true;
+        KeSetEvent(&Vcb->balance.event, 0, false);
+        KeWaitForSingleObject(&Vcb->balance.finished, Executive, KernelMode, false, NULL);
     }
 
     if (Vcb->scrub.thread) {
-        Vcb->scrub.paused = FALSE;
-        Vcb->scrub.stopping = TRUE;
-        KeSetEvent(&Vcb->scrub.event, 0, FALSE);
-        KeWaitForSingleObject(&Vcb->scrub.finished, Executive, KernelMode, FALSE, NULL);
+        Vcb->scrub.paused = false;
+        Vcb->scrub.stopping = true;
+        KeSetEvent(&Vcb->scrub.event, 0, false);
+        KeWaitForSingleObject(&Vcb->scrub.finished, Executive, KernelMode, false, NULL);
     }
 
     if (Vcb->running_sends != 0) {
-        BOOL send_cancelled = FALSE;
+        bool send_cancelled = false;
 
-        ExAcquireResourceExclusiveLite(&Vcb->send_load_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&Vcb->send_load_lock, true);
 
         le = Vcb->send_ops.Flink;
         while (le != &Vcb->send_ops) {
             send_info* send = CONTAINING_RECORD(le, send_info, list_entry);
 
             if (!send->cancelling) {
-                send->cancelling = TRUE;
-                send_cancelled = TRUE;
+                send->cancelling = true;
+                send_cancelled = true;
                 send->ccb = NULL;
-                KeSetEvent(&send->cleared_event, 0, FALSE);
+                KeSetEvent(&send->cleared_event, 0, false);
             }
 
             le = le->Flink;
@@ -1834,7 +2024,7 @@ void uninit(_In_ device_extension* Vcb) {
 
         if (send_cancelled) {
             while (Vcb->running_sends != 0) {
-                ExAcquireResourceExclusiveLite(&Vcb->send_load_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&Vcb->send_load_lock, true);
                 ExReleaseResourceLite(&Vcb->send_load_lock);
             }
         }
@@ -1845,13 +2035,13 @@ void uninit(_In_ device_extension* Vcb) {
         WARN("registry_mark_volume_unmounted returned %08x\n", Status);
 
     for (i = 0; i < Vcb->calcthreads.num_threads; i++) {
-        Vcb->calcthreads.threads[i].quit = TRUE;
+        Vcb->calcthreads.threads[i].quit = true;
     }
 
-    KeSetEvent(&Vcb->calcthreads.event, 0, FALSE);
+    KeSetEvent(&Vcb->calcthreads.event, 0, false);
 
     for (i = 0; i < Vcb->calcthreads.num_threads; i++) {
-        KeWaitForSingleObject(&Vcb->calcthreads.threads[i].finished, Executive, KernelMode, FALSE, NULL);
+        KeWaitForSingleObject(&Vcb->calcthreads.threads[i].finished, Executive, KernelMode, false, NULL);
 
         ZwClose(Vcb->calcthreads.threads[i].handle);
     }
@@ -1861,7 +2051,7 @@ void uninit(_In_ device_extension* Vcb) {
 
     time.QuadPart = 0;
     KeSetTimer(&Vcb->flush_thread_timer, time, NULL); // trigger the timer early
-    KeWaitForSingleObject(&Vcb->flush_thread_finished, Executive, KernelMode, FALSE, NULL);
+    KeWaitForSingleObject(&Vcb->flush_thread_finished, Executive, KernelMode, false, NULL);
 
     reap_fcb(Vcb->volume_fcb);
     reap_fcb(Vcb->dummy_fcb);
@@ -1936,7 +2126,7 @@ void uninit(_In_ device_extension* Vcb) {
         ExFreePool(dev);
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, true);
     while (!IsListEmpty(&Vcb->scrub.errors)) {
         scrub_error* err = CONTAINING_RECORD(RemoveHeadList(&Vcb->scrub.errors), scrub_error, list_entry);
 
@@ -2007,14 +2197,14 @@ static NTSTATUS delete_fileref_fcb(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT
         }
     }
 
-    fileref->fcb->deleted = TRUE;
+    fileref->fcb->deleted = true;
 
     le = fileref->children.Flink;
     while (le != &fileref->children) {
         file_ref* fr2 = CONTAINING_RECORD(le, file_ref, list_entry);
 
         if (fr2->fcb->ads) {
-            fr2->fcb->deleted = TRUE;
+            fr2->fcb->deleted = true;
             mark_fcb_dirty(fr2->fcb);
         }
 
@@ -2024,7 +2214,7 @@ static NTSTATUS delete_fileref_fcb(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT
     return STATUS_SUCCESS;
 }
 
-NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject, _In_ BOOL make_orphan, _In_opt_ PIRP Irp, _In_ LIST_ENTRY* rollback) {
+NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject, _In_ bool make_orphan, _In_opt_ PIRP Irp, _In_ LIST_ENTRY* rollback) {
     LARGE_INTEGER newlength, time;
     BTRFS_TIME now;
     NTSTATUS Status;
@@ -2033,7 +2223,7 @@ NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject
     KeQuerySystemTime(&time);
     win_time_to_unix(time, &now);
 
-    ExAcquireResourceExclusiveLite(fileref->fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fileref->fcb->Header.Resource, true);
 
     if (fileref->deleted) {
         ExReleaseResourceLite(fileref->fcb->Header.Resource);
@@ -2045,7 +2235,7 @@ NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject
         return STATUS_ACCESS_DENIED;
     }
 
-    fileref->deleted = TRUE;
+    fileref->deleted = true;
     mark_fileref_dirty(fileref);
 
     // delete INODE_ITEM (0x1)
@@ -2058,7 +2248,7 @@ NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject
 
             mark_fcb_dirty(fileref->fcb);
 
-            fileref->fcb->inode_item_changed = TRUE;
+            fileref->fcb->inode_item_changed = true;
 
             if (fileref->fcb->inode_item.st_nlink > 1 || make_orphan) {
                 fileref->fcb->inode_item.st_nlink--;
@@ -2114,7 +2304,7 @@ NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject
                     file_ref* fr2 = CONTAINING_RECORD(le, file_ref, list_entry);
 
                     if (fr2->fcb->ads) {
-                        fr2->fcb->deleted = TRUE;
+                        fr2->fcb->deleted = true;
                         mark_fcb_dirty(fr2->fcb);
                     }
 
@@ -2123,7 +2313,7 @@ NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject
             }
         }
     } else {
-        fileref->fcb->deleted = TRUE;
+        fileref->fcb->deleted = true;
         mark_fcb_dirty(fileref->fcb);
     }
 
@@ -2132,7 +2322,7 @@ NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject
     if (fileref->dc) {
         TRACE("delete file %.*S\n", fileref->dc->name.Length / sizeof(WCHAR), fileref->dc->name.Buffer);
 
-        ExAcquireResourceExclusiveLite(&fileref->parent->fcb->nonpaged->dir_children_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&fileref->parent->fcb->nonpaged->dir_children_lock, true);
         RemoveEntryList(&fileref->dc->list_entry_index);
 
         if (!fileref->fcb->ads)
@@ -2158,20 +2348,20 @@ NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject
 
     // update INODE_ITEM of parent
 
-    ExAcquireResourceExclusiveLite(fileref->parent->fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fileref->parent->fcb->Header.Resource, true);
 
     fileref->parent->fcb->inode_item.transid = fileref->fcb->Vcb->superblock.generation;
     fileref->parent->fcb->inode_item.sequence++;
     fileref->parent->fcb->inode_item.st_ctime = now;
 
     if (!fileref->fcb->ads) {
-        TRACE("fileref->parent->fcb->inode_item.st_size (inode %llx) was %llx\n", fileref->parent->fcb->inode, fileref->parent->fcb->inode_item.st_size);
+        TRACE("fileref->parent->fcb->inode_item.st_size (inode %I64x) was %I64x\n", fileref->parent->fcb->inode, fileref->parent->fcb->inode_item.st_size);
         fileref->parent->fcb->inode_item.st_size -= utf8len * 2;
-        TRACE("fileref->parent->fcb->inode_item.st_size (inode %llx) now %llx\n", fileref->parent->fcb->inode, fileref->parent->fcb->inode_item.st_size);
+        TRACE("fileref->parent->fcb->inode_item.st_size (inode %I64x) now %I64x\n", fileref->parent->fcb->inode, fileref->parent->fcb->inode_item.st_size);
         fileref->parent->fcb->inode_item.st_mtime = now;
     }
 
-    fileref->parent->fcb->inode_item_changed = TRUE;
+    fileref->parent->fcb->inode_item_changed = true;
     ExReleaseResourceLite(fileref->parent->fcb->Header.Resource);
 
     if (!fileref->fcb->ads && fileref->parent->dc)
@@ -2194,17 +2384,13 @@ NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject
 
 _Dispatch_type_(IRP_MJ_CLEANUP)
 _Function_class_(DRIVER_DISPATCH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI drv_cleanup(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#else
-static NTSTATUS drv_cleanup(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#endif
+static NTSTATUS __stdcall drv_cleanup(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     device_extension* Vcb = DeviceObject->DeviceExtension;
     fcb* fcb = FileObject->FsContext;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -2243,7 +2429,7 @@ static NTSTATUS drv_cleanup(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
         LONG oc;
         ccb* ccb;
         file_ref* fileref;
-        BOOL locked = TRUE;
+        bool locked = true;
 
         ccb = FileObject->FsContext2;
         fileref = ccb ? ccb->fileref : NULL;
@@ -2251,12 +2437,14 @@ static NTSTATUS drv_cleanup(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
         TRACE("cleanup called for FileObject %p\n", FileObject);
         TRACE("fileref %p (%S), refcount = %u, open_count = %u\n", fileref, file_desc(FileObject), fileref ? fileref->refcount : 0, fileref ? fileref->open_count : 0);
 
-        ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
+        ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
 
-        ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+        ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
         IoRemoveShareAccess(FileObject, &fcb->share_access);
 
+        FsRtlFastUnlockAll(&fcb->lock, FileObject, IoGetRequestorProcess(Irp), NULL);
+
         if (ccb)
             FsRtlNotifyCleanup(fcb->Vcb->NotifySync, &fcb->Vcb->DirNotifyList, ccb);
 
@@ -2268,10 +2456,10 @@ static NTSTATUS drv_cleanup(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
         }
 
         if (ccb && ccb->options & FILE_DELETE_ON_CLOSE && fileref)
-            fileref->delete_on_close = TRUE;
+            fileref->delete_on_close = true;
 
         if (fileref && fileref->delete_on_close && fcb->type == BTRFS_TYPE_DIRECTORY && fcb->inode_item.st_size > 0 && fcb != fcb->Vcb->dummy_fcb)
-            fileref->delete_on_close = FALSE;
+            fileref->delete_on_close = false;
 
         if (fcb->Vcb->locked && fcb->Vcb->locked_fileobj == FileObject) {
             TRACE("unlocking volume\n");
@@ -2281,7 +2469,7 @@ static NTSTATUS drv_cleanup(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
 
         if (ccb && ccb->reserving) {
             fcb->subvol->reserved = NULL;
-            ccb->reserving = FALSE;
+            ccb->reserving = false;
             // FIXME - flush all of subvol's fcbs
         }
 
@@ -2318,10 +2506,10 @@ static NTSTATUS drv_cleanup(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
                     }
 
                     ExReleaseResourceLite(fcb->Header.Resource);
-                    locked = FALSE;
+                    locked = false;
 
                     // fileref_lock needs to be acquired before fcb->Header.Resource
-                    ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, TRUE);
+                    ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, true);
 
                     Status = delete_fileref(fileref, FileObject, oc > 0 && fileref->posix_delete, Irp, &rollback);
                     if (!NT_SUCCESS(Status)) {
@@ -2335,7 +2523,7 @@ static NTSTATUS drv_cleanup(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
                     ExReleaseResourceLite(&fcb->Vcb->fileref_lock);
 
                     clear_rollback(&rollback);
-                } else if (FileObject->Flags & FO_CACHE_SUPPORTED && fcb->nonpaged->segment_object.DataSectionObject) {
+                } else if (FileObject->Flags & FO_CACHE_SUPPORTED && FileObject->SectionObjectPointer->DataSectionObject) {
                     IO_STATUS_BLOCK iosb;
                     CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, &iosb);
 
@@ -2344,13 +2532,13 @@ static NTSTATUS drv_cleanup(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
                     }
 
                     if (!ExIsResourceAcquiredSharedLite(fcb->Header.PagingIoResource)) {
-                        ExAcquireResourceExclusiveLite(fcb->Header.PagingIoResource, TRUE);
+                        ExAcquireResourceExclusiveLite(fcb->Header.PagingIoResource, true);
                         ExReleaseResourceLite(fcb->Header.PagingIoResource);
                     }
 
-                    CcPurgeCacheSection(&fcb->nonpaged->segment_object, NULL, 0, FALSE);
+                    CcPurgeCacheSection(FileObject->SectionObjectPointer, NULL, 0, false);
 
-                    TRACE("flushed cache on close (FileObject = %p, fcb = %p, AllocationSize = %llx, FileSize = %llx, ValidDataLength = %llx)\n",
+                    TRACE("flushed cache on close (FileObject = %p, fcb = %p, AllocationSize = %I64x, FileSize = %I64x, ValidDataLength = %I64x)\n",
                         FileObject, fcb, fcb->Header.AllocationSize.QuadPart, fcb->Header.FileSize.QuadPart, fcb->Header.ValidDataLength.QuadPart);
                 }
             }
@@ -2386,7 +2574,7 @@ exit:
 }
 
 _Success_(return)
-BOOL get_file_attributes_from_xattr(_In_reads_bytes_(len) char* val, _In_ UINT16 len, _Out_ ULONG* atts) {
+bool get_file_attributes_from_xattr(_In_reads_bytes_(len) char* val, _In_ uint16_t len, _Out_ ULONG* atts) {
     if (len > 2 && val[0] == '0' && val[1] == 'x') {
         int i;
         ULONG dosnum = 0;
@@ -2406,19 +2594,19 @@ BOOL get_file_attributes_from_xattr(_In_reads_bytes_(len) char* val, _In_ UINT16
 
         *atts = dosnum;
 
-        return TRUE;
+        return true;
     }
 
-    return FALSE;
+    return false;
 }
 
-ULONG get_file_attributes(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _In_ UINT64 inode,
-                          _In_ UINT8 type, _In_ BOOL dotfile, _In_ BOOL ignore_xa, _In_opt_ PIRP Irp) {
+ULONG get_file_attributes(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _In_ uint64_t inode,
+                          _In_ uint8_t type, _In_ bool dotfile, _In_ bool ignore_xa, _In_opt_ PIRP Irp) {
     ULONG att;
     char* eaval;
-    UINT16 ealen;
+    uint16_t ealen;
 
-    if (!ignore_xa && get_xattr(Vcb, r, inode, EA_DOSATTRIB, EA_DOSATTRIB_HASH, (UINT8**)&eaval, &ealen, Irp)) {
+    if (!ignore_xa && get_xattr(Vcb, r, inode, EA_DOSATTRIB, EA_DOSATTRIB_HASH, (uint8_t**)&eaval, &ealen, Irp)) {
         ULONG dosnum = 0;
 
         if (get_file_attributes_from_xattr(eaval, ealen, &dosnum)) {
@@ -2481,8 +2669,8 @@ ULONG get_file_attributes(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_ex
     return att;
 }
 
-NTSTATUS sync_read_phys(_In_ PDEVICE_OBJECT DeviceObject, _In_ UINT64 StartingOffset, _In_ ULONG Length,
-                        _Out_writes_bytes_(Length) PUCHAR Buffer, _In_ BOOL override) {
+NTSTATUS sync_read_phys(_In_ PDEVICE_OBJECT DeviceObject, _In_ PFILE_OBJECT FileObject, _In_ uint64_t StartingOffset, _In_ ULONG Length,
+                        _Out_writes_bytes_(Length) PUCHAR Buffer, _In_ bool override) {
     IO_STATUS_BLOCK IoStatus;
     LARGE_INTEGER Offset;
     PIRP Irp;
@@ -2493,11 +2681,11 @@ NTSTATUS sync_read_phys(_In_ PDEVICE_OBJECT DeviceObject, _In_ UINT64 StartingOf
     num_reads++;
 
     RtlZeroMemory(&context, sizeof(read_context));
-    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&context.Event, NotificationEvent, false);
 
     Offset.QuadPart = (LONGLONG)StartingOffset;
 
-    Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
+    Irp = IoAllocateIrp(DeviceObject->StackSize, false);
 
     if (!Irp) {
         ERR("IoAllocateIrp failed\n");
@@ -2507,6 +2695,7 @@ NTSTATUS sync_read_phys(_In_ PDEVICE_OBJECT DeviceObject, _In_ UINT64 StartingOf
     Irp->Flags |= IRP_NOCACHE;
     IrpSp = IoGetNextIrpStackLocation(Irp);
     IrpSp->MajorFunction = IRP_MJ_READ;
+    IrpSp->FileObject = FileObject;
 
     if (override)
         IrpSp->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
@@ -2523,7 +2712,7 @@ NTSTATUS sync_read_phys(_In_ PDEVICE_OBJECT DeviceObject, _In_ UINT64 StartingOf
 
         Irp->UserBuffer = Buffer;
     } else if (DeviceObject->Flags & DO_DIRECT_IO) {
-        Irp->MdlAddress = IoAllocateMdl(Buffer, Length, FALSE, FALSE, NULL);
+        Irp->MdlAddress = IoAllocateMdl(Buffer, Length, false, false, NULL);
         if (!Irp->MdlAddress) {
             ERR("IoAllocateMdl failed\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2553,12 +2742,12 @@ NTSTATUS sync_read_phys(_In_ PDEVICE_OBJECT DeviceObject, _In_ UINT64 StartingOf
 
     Irp->UserEvent = &context.Event;
 
-    IoSetCompletionRoutine(Irp, read_completion, &context, TRUE, TRUE, TRUE);
+    IoSetCompletionRoutine(Irp, read_completion, &context, true, true, true);
 
     Status = IoCallDriver(DeviceObject, Irp);
 
     if (Status == STATUS_PENDING) {
-        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+        KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
         Status = context.iosb.Status;
     }
 
@@ -2573,11 +2762,11 @@ exit:
     return Status;
 }
 
-static NTSTATUS read_superblock(_In_ device_extension* Vcb, _In_ PDEVICE_OBJECT device, _In_ UINT64 length) {
+static NTSTATUS read_superblock(_In_ device_extension* Vcb, _In_ PDEVICE_OBJECT device, _In_ PFILE_OBJECT fileobj, _In_ uint64_t length) {
     NTSTATUS Status;
     superblock* sb;
     ULONG i, to_read;
-    UINT8 valid_superblocks;
+    uint8_t valid_superblocks;
 
     to_read = device->SectorSize == 0 ? sizeof(superblock) : (ULONG)sector_align(sizeof(superblock), device->SectorSize);
 
@@ -2597,12 +2786,12 @@ static NTSTATUS read_superblock(_In_ device_extension* Vcb, _In_ PDEVICE_OBJECT
     valid_superblocks = 0;
 
     while (superblock_addrs[i] > 0) {
-        UINT32 crc32;
+        uint32_t crc32;
 
         if (i > 0 && superblock_addrs[i] + to_read > length)
             break;
 
-        Status = sync_read_phys(device, superblock_addrs[i], to_read, (PUCHAR)sb, FALSE);
+        Status = sync_read_phys(device, fileobj, superblock_addrs[i], to_read, (PUCHAR)sb, false);
         if (!NT_SUCCESS(Status)) {
             ERR("Failed to read superblock %u: %08x\n", i, Status);
             ExFreePool(sb);
@@ -2618,10 +2807,10 @@ static NTSTATUS read_superblock(_In_ device_extension* Vcb, _In_ PDEVICE_OBJECT
         } else {
             TRACE("got superblock %u!\n", i);
 
-            crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
+            crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
 
-            if (crc32 != *((UINT32*)sb->checksum))
-                WARN("crc32 was %08x, expected %08x\n", crc32, *((UINT32*)sb->checksum));
+            if (crc32 != *((uint32_t*)sb->checksum))
+                WARN("crc32 was %08x, expected %08x\n", crc32, *((uint32_t*)sb->checksum));
             else if (sb->sector_size == 0)
                 WARN("superblock sector size was 0\n");
             else if (sb->node_size < sizeof(tree_header) + sizeof(internal_node) || sb->node_size > 0x10000)
@@ -2650,14 +2839,14 @@ static NTSTATUS read_superblock(_In_ device_extension* Vcb, _In_ PDEVICE_OBJECT
 }
 
 NTSTATUS dev_ioctl(_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG ControlCode, _In_reads_bytes_opt_(InputBufferSize) PVOID InputBuffer, _In_ ULONG InputBufferSize,
-                   _Out_writes_bytes_opt_(OutputBufferSize) PVOID OutputBuffer, _In_ ULONG OutputBufferSize, _In_ BOOLEAN Override, _Out_opt_ IO_STATUS_BLOCK* iosb) {
+                   _Out_writes_bytes_opt_(OutputBufferSize) PVOID OutputBuffer, _In_ ULONG OutputBufferSize, _In_ bool Override, _Out_opt_ IO_STATUS_BLOCK* iosb) {
     PIRP Irp;
     KEVENT Event;
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp;
     IO_STATUS_BLOCK IoStatus;
 
-    KeInitializeEvent(&Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&Event, NotificationEvent, false);
 
     Irp = IoBuildDeviceIoControlRequest(ControlCode,
                                         DeviceObject,
@@ -2665,7 +2854,7 @@ NTSTATUS dev_ioctl(_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG ControlCode, _In
                                         InputBufferSize,
                                         OutputBuffer,
                                         OutputBufferSize,
-                                        FALSE,
+                                        false,
                                         &Event,
                                         &IoStatus);
 
@@ -2679,7 +2868,7 @@ NTSTATUS dev_ioctl(_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG ControlCode, _In
     Status = IoCallDriver(DeviceObject, Irp);
 
     if (Status == STATUS_PENDING) {
-        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+        KeWaitForSingleObject(&Event, Executive, KernelMode, false, NULL);
         Status = IoStatus.Status;
     }
 
@@ -2690,8 +2879,8 @@ NTSTATUS dev_ioctl(_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG ControlCode, _In
 }
 
 _Requires_exclusive_lock_held_(Vcb->tree_lock)
-static NTSTATUS add_root(_Inout_ device_extension* Vcb, _In_ UINT64 id, _In_ UINT64 addr,
-                         _In_ UINT64 generation, _In_opt_ traverse_ptr* tp) {
+static NTSTATUS add_root(_Inout_ device_extension* Vcb, _In_ uint64_t id, _In_ uint64_t addr,
+                         _In_ uint64_t generation, _In_opt_ traverse_ptr* tp) {
     root* r = ExAllocatePoolWithTag(PagedPool, sizeof(root), ALLOC_TAG);
     if (!r) {
         ERR("out of memory\n");
@@ -2699,8 +2888,8 @@ static NTSTATUS add_root(_Inout_ device_extension* Vcb, _In_ UINT64 id, _In_ UIN
     }
 
     r->id = id;
-    r->dirty = FALSE;
-    r->received = FALSE;
+    r->dirty = false;
+    r->received = false;
     r->reserved = NULL;
     r->treeholder.address = addr;
     r->treeholder.tree = NULL;
@@ -2708,7 +2897,7 @@ static NTSTATUS add_root(_Inout_ device_extension* Vcb, _In_ UINT64 id, _In_ UIN
     r->parent = 0;
     r->send_ops = 0;
     r->fcbs_version = 0;
-    r->checked_for_orphans = FALSE;
+    r->checked_for_orphans = false;
     InitializeListHead(&r->fcbs);
     RtlZeroMemory(r->fcbs_ptrs, sizeof(LIST_ENTRY*) * 256);
 
@@ -2726,7 +2915,7 @@ static NTSTATUS add_root(_Inout_ device_extension* Vcb, _In_ UINT64 id, _In_ UIN
     if (tp) {
         RtlCopyMemory(&r->root_item, tp->item->data, min(sizeof(ROOT_ITEM), tp->item->size));
         if (tp->item->size < sizeof(ROOT_ITEM))
-            RtlZeroMemory(((UINT8*)&r->root_item) + tp->item->size, sizeof(ROOT_ITEM) - tp->item->size);
+            RtlZeroMemory(((uint8_t*)&r->root_item) + tp->item->size, sizeof(ROOT_ITEM) - tp->item->size);
     } else
         RtlZeroMemory(&r->root_item, sizeof(ROOT_ITEM));
 
@@ -2780,29 +2969,29 @@ static NTSTATUS add_root(_Inout_ device_extension* Vcb, _In_ UINT64 id, _In_ UIN
 static NTSTATUS look_for_roots(_Requires_exclusive_lock_held_(_Curr_->tree_lock) _In_ device_extension* Vcb, _In_opt_ PIRP Irp) {
     traverse_ptr tp, next_tp;
     KEY searchkey;
-    BOOL b;
+    bool b;
     NTSTATUS Status;
 
     searchkey.obj_id = 0;
     searchkey.obj_type = 0;
     searchkey.offset = 0;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
     }
 
     do {
-        TRACE("(%llx,%x,%llx)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+        TRACE("(%I64x,%x,%I64x)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
 
         if (tp.item->key.obj_type == TYPE_ROOT_ITEM) {
             ROOT_ITEM* ri = (ROOT_ITEM*)tp.item->data;
 
             if (tp.item->size < offsetof(ROOT_ITEM, byte_limit)) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, offsetof(ROOT_ITEM, byte_limit));
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, offsetof(ROOT_ITEM, byte_limit));
             } else {
-                TRACE("root %llx - address %llx\n", tp.item->key.obj_id, ri->block_number);
+                TRACE("root %I64x - address %I64x\n", tp.item->key.obj_id, ri->block_number);
 
                 Status = add_root(Vcb, tp.item->key.obj_id, ri->block_number, ri->generation, &tp);
                 if (!NT_SUCCESS(Status)) {
@@ -2817,7 +3006,7 @@ static NTSTATUS look_for_roots(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
                 lastroot->parent = tp.item->key.offset;
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, Irp);
+        b = find_next_item(Vcb, &tp, &next_tp, false, Irp);
 
         if (b)
             tp = next_tp;
@@ -2826,14 +3015,14 @@ static NTSTATUS look_for_roots(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
     if (!Vcb->readonly && !Vcb->data_reloc_root) {
         root* reloc_root;
         INODE_ITEM* ii;
-        UINT16 irlen;
+        uint16_t irlen;
         INODE_REF* ir;
         LARGE_INTEGER time;
         BTRFS_TIME now;
 
         WARN("data reloc root doesn't exist, creating it\n");
 
-        Status = create_root(Vcb, BTRFS_ROOT_DATA_RELOC, &reloc_root, FALSE, 0, Irp);
+        Status = create_root(Vcb, BTRFS_ROOT_DATA_RELOC, &reloc_root, false, 0, Irp);
 
         if (!NT_SUCCESS(Status)) {
             ERR("create_root returned %08x\n", Status);
@@ -2874,7 +3063,7 @@ static NTSTATUS look_for_roots(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
             return Status;
         }
 
-        irlen = (UINT16)offsetof(INODE_REF, name[0]) + 2;
+        irlen = (uint16_t)offsetof(INODE_REF, name[0]) + 2;
         ir = ExAllocatePoolWithTag(PagedPool, irlen, ALLOC_TAG);
         if (!ir) {
             ERR("out of memory\n");
@@ -2894,7 +3083,7 @@ static NTSTATUS look_for_roots(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
         }
 
         Vcb->data_reloc_root = reloc_root;
-        Vcb->need_write = TRUE;
+        Vcb->need_write = true;
     }
 
     return STATUS_SUCCESS;
@@ -2903,8 +3092,8 @@ static NTSTATUS look_for_roots(_Requires_exclusive_lock_held_(_Curr_->tree_lock)
 static NTSTATUS find_disk_holes(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ device* dev, _In_opt_ PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp, next_tp;
-    BOOL b;
-    UINT64 lastaddr;
+    bool b;
+    uint64_t lastaddr;
     NTSTATUS Status;
 
     InitializeListHead(&dev->space);
@@ -2913,15 +3102,15 @@ static NTSTATUS find_disk_holes(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
     searchkey.obj_type = TYPE_DEV_STATS;
     searchkey.offset = dev->devitem.dev_id;
 
-    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, false, Irp);
     if (NT_SUCCESS(Status) && !keycmp(tp.item->key, searchkey))
-        RtlCopyMemory(dev->stats, tp.item->data, min(sizeof(UINT64) * 5, tp.item->size));
+        RtlCopyMemory(dev->stats, tp.item->data, min(sizeof(uint64_t) * 5, tp.item->size));
 
     searchkey.obj_id = dev->devitem.dev_id;
     searchkey.obj_type = TYPE_DEV_EXTENT;
     searchkey.offset = 0;
 
-    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
@@ -2944,11 +3133,11 @@ static NTSTATUS find_disk_holes(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
 
                 lastaddr = tp.item->key.offset + de->length;
             } else {
-                ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DEV_EXTENT));
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DEV_EXTENT));
             }
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, Irp);
+        b = find_next_item(Vcb, &tp, &next_tp, false, Irp);
 
         if (b) {
             tp = next_tp;
@@ -3001,12 +3190,12 @@ device* find_device_from_uuid(_In_ device_extension* Vcb, _In_ BTRFS_UUID* uuid)
     while (le != &Vcb->devices) {
         device* dev = CONTAINING_RECORD(le, device, list_entry);
 
-        TRACE("device %llx, uuid %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", dev->devitem.dev_id,
+        TRACE("device %I64x, uuid %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", dev->devitem.dev_id,
             dev->devitem.device_uuid.uuid[0], dev->devitem.device_uuid.uuid[1], dev->devitem.device_uuid.uuid[2], dev->devitem.device_uuid.uuid[3], dev->devitem.device_uuid.uuid[4], dev->devitem.device_uuid.uuid[5], dev->devitem.device_uuid.uuid[6], dev->devitem.device_uuid.uuid[7],
             dev->devitem.device_uuid.uuid[8], dev->devitem.device_uuid.uuid[9], dev->devitem.device_uuid.uuid[10], dev->devitem.device_uuid.uuid[11], dev->devitem.device_uuid.uuid[12], dev->devitem.device_uuid.uuid[13], dev->devitem.device_uuid.uuid[14], dev->devitem.device_uuid.uuid[15]);
 
         if (RtlCompareMemory(&dev->devitem.device_uuid, uuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
-            TRACE("returning device %llx\n", dev->devitem.dev_id);
+            TRACE("returning device %I64x\n", dev->devitem.dev_id);
             return dev;
         }
 
@@ -3020,7 +3209,7 @@ device* find_device_from_uuid(_In_ device_extension* Vcb, _In_ BTRFS_UUID* uuid)
 
     pdode = vde->pdode;
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     if (Vcb->devices_loaded < Vcb->superblock.num_devices) {
         le = pdode->children.Flink;
@@ -3040,13 +3229,14 @@ device* find_device_from_uuid(_In_ device_extension* Vcb, _In_ BTRFS_UUID* uuid)
 
                 RtlZeroMemory(dev, sizeof(device));
                 dev->devobj = vc->devobj;
+                dev->fileobj = vc->fileobj;
                 dev->devitem.device_uuid = *uuid;
                 dev->devitem.dev_id = vc->devid;
                 dev->devitem.num_bytes = vc->size;
                 dev->seeding = vc->seeding;
                 dev->readonly = dev->seeding;
-                dev->reloc = FALSE;
-                dev->removable = FALSE;
+                dev->reloc = false;
+                dev->removable = false;
                 dev->disk_num = vc->disk_num;
                 dev->part_num = vc->part_num;
                 dev->num_trim_entries = 0;
@@ -3074,18 +3264,18 @@ end:
     return NULL;
 }
 
-static BOOL is_device_removable(_In_ PDEVICE_OBJECT devobj) {
+static bool is_device_removable(_In_ PDEVICE_OBJECT devobj) {
     NTSTATUS Status;
     STORAGE_HOTPLUG_INFO shi;
 
-    Status = dev_ioctl(devobj, IOCTL_STORAGE_GET_HOTPLUG_INFO, NULL, 0, &shi, sizeof(STORAGE_HOTPLUG_INFO), TRUE, NULL);
+    Status = dev_ioctl(devobj, IOCTL_STORAGE_GET_HOTPLUG_INFO, NULL, 0, &shi, sizeof(STORAGE_HOTPLUG_INFO), true, NULL);
 
     if (!NT_SUCCESS(Status)) {
         ERR("dev_ioctl returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
-    return shi.MediaRemovable != 0 ? TRUE : FALSE;
+    return shi.MediaRemovable != 0 ? true : false;
 }
 
 static ULONG get_device_change_count(_In_ PDEVICE_OBJECT devobj) {
@@ -3093,7 +3283,7 @@ static ULONG get_device_change_count(_In_ PDEVICE_OBJECT devobj) {
     ULONG cc;
     IO_STATUS_BLOCK iosb;
 
-    Status = dev_ioctl(devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, &cc, sizeof(ULONG), TRUE, &iosb);
+    Status = dev_ioctl(devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, &cc, sizeof(ULONG), true, &iosb);
 
     if (!NT_SUCCESS(Status)) {
         ERR("dev_ioctl returned %08x\n", Status);
@@ -3108,7 +3298,7 @@ static ULONG get_device_change_count(_In_ PDEVICE_OBJECT devobj) {
     return cc;
 }
 
-void init_device(_In_ device_extension* Vcb, _Inout_ device* dev, _In_ BOOL get_nums) {
+void init_device(_In_ device_extension* Vcb, _Inout_ device* dev, _In_ bool get_nums) {
     NTSTATUS Status;
     ULONG aptelen;
     ATA_PASS_THROUGH_EX* apte;
@@ -3122,7 +3312,7 @@ void init_device(_In_ device_extension* Vcb, _Inout_ device* dev, _In_ BOOL get_
         STORAGE_DEVICE_NUMBER sdn;
 
         Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0,
-                           &sdn, sizeof(STORAGE_DEVICE_NUMBER), TRUE, NULL);
+                           &sdn, sizeof(STORAGE_DEVICE_NUMBER), true, NULL);
 
         if (!NT_SUCCESS(Status)) {
             WARN("IOCTL_STORAGE_GET_DEVICE_NUMBER returned %08x\n", Status);
@@ -3134,18 +3324,18 @@ void init_device(_In_ device_extension* Vcb, _Inout_ device* dev, _In_ BOOL get_
         }
     }
 
-    dev->trim = FALSE;
+    dev->trim = false;
     dev->readonly = dev->seeding;
-    dev->reloc = FALSE;
+    dev->reloc = false;
     dev->num_trim_entries = 0;
-    dev->stats_changed = FALSE;
+    dev->stats_changed = false;
     InitializeListHead(&dev->trim_list);
 
     if (!dev->readonly) {
         Status = dev_ioctl(dev->devobj, IOCTL_DISK_IS_WRITABLE, NULL, 0,
-                        NULL, 0, TRUE, NULL);
+                        NULL, 0, true, NULL);
         if (Status == STATUS_MEDIA_WRITE_PROTECTED)
-            dev->readonly = TRUE;
+            dev->readonly = true;
     }
 
     aptelen = sizeof(ATA_PASS_THROUGH_EX) + 512;
@@ -3165,15 +3355,15 @@ void init_device(_In_ device_extension* Vcb, _Inout_ device* dev, _In_ BOOL get_
     apte->CurrentTaskFile[6] = IDE_COMMAND_IDENTIFY;
 
     Status = dev_ioctl(dev->devobj, IOCTL_ATA_PASS_THROUGH, apte, aptelen,
-                       apte, aptelen, TRUE, NULL);
+                       apte, aptelen, true, NULL);
 
     if (!NT_SUCCESS(Status))
         TRACE("IOCTL_ATA_PASS_THROUGH returned %08x for IDENTIFY DEVICE\n", Status);
     else {
-        IDENTIFY_DEVICE_DATA* idd = (IDENTIFY_DEVICE_DATA*)((UINT8*)apte + sizeof(ATA_PASS_THROUGH_EX));
+        IDENTIFY_DEVICE_DATA* idd = (IDENTIFY_DEVICE_DATA*)((uint8_t*)apte + sizeof(ATA_PASS_THROUGH_EX));
 
         if (idd->CommandSetSupport.FlushCache) {
-            dev->can_flush = TRUE;
+            dev->can_flush = true;
             TRACE("FLUSH CACHE supported\n");
         } else
             TRACE("FLUSH CACHE not supported\n");
@@ -3181,29 +3371,34 @@ void init_device(_In_ device_extension* Vcb, _Inout_ device* dev, _In_ BOOL get_
 
     ExFreePool(apte);
 
+#ifdef DEBUG_TRIM_EMULATION
+    dev->trim = true;
+    Vcb->trim = true;
+#else
     spq.PropertyId = StorageDeviceTrimProperty;
     spq.QueryType = PropertyStandardQuery;
     spq.AdditionalParameters[0] = 0;
 
     Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_QUERY_PROPERTY, &spq, sizeof(STORAGE_PROPERTY_QUERY),
-                       &dtd, sizeof(DEVICE_TRIM_DESCRIPTOR), TRUE, NULL);
+                       &dtd, sizeof(DEVICE_TRIM_DESCRIPTOR), true, NULL);
 
     if (NT_SUCCESS(Status)) {
         if (dtd.TrimEnabled) {
-            dev->trim = TRUE;
-            Vcb->trim = TRUE;
+            dev->trim = true;
+            Vcb->trim = true;
             TRACE("TRIM supported\n");
         } else
             TRACE("TRIM not supported\n");
     }
+#endif
 
-    RtlZeroMemory(dev->stats, sizeof(UINT64) * 5);
+    RtlZeroMemory(dev->stats, sizeof(uint64_t) * 5);
 }
 
 static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_opt_ PIRP Irp) {
     traverse_ptr tp, next_tp;
     KEY searchkey;
-    BOOL b;
+    bool b;
     chunk* c;
     NTSTATUS Status;
 
@@ -3215,22 +3410,22 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
     Vcb->metadata_flags = 0;
     Vcb->system_flags = 0;
 
-    Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
     }
 
     do {
-        TRACE("(%llx,%x,%llx)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+        TRACE("(%I64x,%x,%I64x)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
 
         if (tp.item->key.obj_id == 1 && tp.item->key.obj_type == TYPE_DEV_ITEM) {
             if (tp.item->size < sizeof(DEV_ITEM)) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DEV_ITEM));
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DEV_ITEM));
             } else {
                 DEV_ITEM* di = (DEV_ITEM*)tp.item->data;
                 LIST_ENTRY* le;
-                BOOL done = FALSE;
+                bool done = false;
 
                 le = Vcb->devices.Flink;
                 while (le != &Vcb->devices) {
@@ -3240,9 +3435,9 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
                         RtlCopyMemory(&dev->devitem, tp.item->data, min(tp.item->size, sizeof(DEV_ITEM)));
 
                         if (le != Vcb->devices.Flink)
-                            init_device(Vcb, dev, TRUE);
+                            init_device(Vcb, dev, true);
 
-                        done = TRUE;
+                        done = true;
                         break;
                     }
 
@@ -3253,7 +3448,7 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
                     volume_device_extension* vde = Vcb->vde;
                     pdo_device_extension* pdode = vde->pdode;
 
-                    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+                    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
                     if (Vcb->devices_loaded < Vcb->superblock.num_devices) {
                         le = pdode->children.Flink;
@@ -3274,12 +3469,13 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
                                 RtlZeroMemory(dev, sizeof(device));
 
                                 dev->devobj = vc->devobj;
+                                dev->fileobj = vc->fileobj;
                                 RtlCopyMemory(&dev->devitem, di, min(tp.item->size, sizeof(DEV_ITEM)));
                                 dev->seeding = vc->seeding;
-                                init_device(Vcb, dev, FALSE);
+                                init_device(Vcb, dev, false);
 
                                 if (dev->devitem.num_bytes > vc->size) {
-                                    WARN("device %llx: DEV_ITEM says %llx bytes, but Windows only reports %llx\n", tp.item->key.offset,
+                                    WARN("device %I64x: DEV_ITEM says %I64x bytes, but Windows only reports %I64x\n", tp.item->key.offset,
                                          dev->devitem.num_bytes, vc->size);
 
                                     dev->devitem.num_bytes = vc->size;
@@ -3290,7 +3486,7 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
                                 add_device_to_list(Vcb, dev);
                                 Vcb->devices_loaded++;
 
-                                done = TRUE;
+                                done = true;
                                 break;
                             }
 
@@ -3299,7 +3495,7 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
 
                         if (!done) {
                             if (!Vcb->options.allow_degraded) {
-                                ERR("volume not found: device %llx, uuid %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", tp.item->key.offset,
+                                ERR("volume not found: device %I64x, uuid %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", tp.item->key.offset,
                                     di->device_uuid.uuid[0], di->device_uuid.uuid[1], di->device_uuid.uuid[2], di->device_uuid.uuid[3], di->device_uuid.uuid[4], di->device_uuid.uuid[5], di->device_uuid.uuid[6], di->device_uuid.uuid[7],
                                     di->device_uuid.uuid[8], di->device_uuid.uuid[9], di->device_uuid.uuid[10], di->device_uuid.uuid[11], di->device_uuid.uuid[12], di->device_uuid.uuid[13], di->device_uuid.uuid[14], di->device_uuid.uuid[15]);
                             } else {
@@ -3323,14 +3519,14 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
                             }
                         }
                     } else
-                        ERR("unexpected device %llx found\n", tp.item->key.offset);
+                        ERR("unexpected device %I64x found\n", tp.item->key.offset);
 
                     ExReleaseResourceLite(&pdode->child_lock);
                 }
             }
         } else if (tp.item->key.obj_type == TYPE_CHUNK_ITEM) {
             if (tp.item->size < sizeof(CHUNK_ITEM)) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(CHUNK_ITEM));
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(CHUNK_ITEM));
             } else {
                 c = ExAllocatePoolWithTag(NonPagedPool, sizeof(chunk), ALLOC_TAG);
 
@@ -3343,12 +3539,12 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
                 c->offset = tp.item->key.offset;
                 c->used = c->oldused = 0;
                 c->cache = c->old_cache = NULL;
-                c->created = FALSE;
-                c->readonly = FALSE;
-                c->reloc = FALSE;
-                c->cache_loaded = FALSE;
-                c->changed = FALSE;
-                c->space_changed = FALSE;
+                c->created = false;
+                c->readonly = false;
+                c->reloc = false;
+                c->cache_loaded = false;
+                c->changed = false;
+                c->space_changed = false;
                 c->balance_num = 0;
 
                 c->chunk_item = ExAllocatePoolWithTag(NonPagedPool, tp.item->size, ALLOC_TAG);
@@ -3372,7 +3568,7 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
 
                 if (c->chunk_item->type & BLOCK_FLAG_RAID10) {
                     if (c->chunk_item->sub_stripes == 0 || c->chunk_item->sub_stripes > c->chunk_item->num_stripes) {
-                        ERR("chunk %llx: invalid stripes (num_stripes %u, sub_stripes %u)\n", c->offset, c->chunk_item->num_stripes, c->chunk_item->sub_stripes);
+                        ERR("chunk %I64x: invalid stripes (num_stripes %u, sub_stripes %u)\n", c->offset, c->chunk_item->num_stripes, c->chunk_item->sub_stripes);
                         ExFreePool(c->chunk_item);
                         ExFreePool(c);
                         return STATUS_INTERNAL_ERROR;
@@ -3381,7 +3577,7 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
 
                 if (c->chunk_item->num_stripes > 0) {
                     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
-                    UINT16 i;
+                    uint16_t i;
 
                     c->devices = ExAllocatePoolWithTag(NonPagedPool, sizeof(device*) * c->chunk_item->num_stripes, ALLOC_TAG);
 
@@ -3394,7 +3590,7 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
 
                     for (i = 0; i < c->chunk_item->num_stripes; i++) {
                         c->devices[i] = find_device_from_uuid(Vcb, &cis[i].dev_uuid);
-                        TRACE("device %llu = %p\n", i, c->devices[i]);
+                        TRACE("device %I64u = %p\n", i, c->devices[i]);
 
                         if (!c->devices[i]) {
                             ERR("missing device\n");
@@ -3404,10 +3600,10 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
                         }
 
                         if (c->devices[i]->readonly)
-                            c->readonly = TRUE;
+                            c->readonly = true;
                     }
                 } else {
-                    ERR("chunk %llx: number of stripes is 0\n", c->offset);
+                    ERR("chunk %I64x: number of stripes is 0\n", c->offset);
                     ExFreePool(c->chunk_item);
                     ExFreePool(c);
                     return STATUS_INTERNAL_ERROR;
@@ -3423,12 +3619,12 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
 
                 InitializeListHead(&c->range_locks);
                 ExInitializeResourceLite(&c->range_locks_lock);
-                KeInitializeEvent(&c->range_locks_event, NotificationEvent, FALSE);
+                KeInitializeEvent(&c->range_locks_event, NotificationEvent, false);
 
                 InitializeListHead(&c->partial_stripes);
                 ExInitializeResourceLite(&c->partial_stripes_lock);
 
-                c->last_alloc_set = FALSE;
+                c->last_alloc_set = false;
 
                 c->last_stripe = 0;
 
@@ -3438,13 +3634,13 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
             }
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, Irp);
+        b = find_next_item(Vcb, &tp, &next_tp, false, Irp);
 
         if (b)
             tp = next_tp;
     } while (b);
 
-    Vcb->log_to_phys_loaded = TRUE;
+    Vcb->log_to_phys_loaded = true;
 
     if (Vcb->data_flags == 0)
         Vcb->data_flags = BLOCK_FLAG_DATA | (Vcb->superblock.num_devices > 1 ? BLOCK_FLAG_RAID0 : 0);
@@ -3464,14 +3660,14 @@ static NTSTATUS load_chunk_root(_In_ _Requires_lock_held_(_Curr_->tree_lock) dev
 }
 
 void protect_superblocks(_Inout_ chunk* c) {
-    UINT16 i = 0, j;
-    UINT64 off_start, off_end;
+    uint16_t i = 0, j;
+    uint64_t off_start, off_end;
 
     // The Linux driver also protects all the space before the first superblock.
     // I realize this confuses physical and logical addresses, but this is what btrfs-progs does -
     // evidently Linux assumes the chunk at 0 is always SINGLE.
     if (c->offset < superblock_addrs[0])
-        space_list_subtract(c, FALSE, c->offset, superblock_addrs[0] - c->offset, NULL);
+        space_list_subtract(c, false, c->offset, superblock_addrs[0] - c->offset, NULL);
 
     while (superblock_addrs[i] != 0) {
         CHUNK_ITEM* ci = c->chunk_item;
@@ -3479,15 +3675,15 @@ void protect_superblocks(_Inout_ chunk* c) {
 
         if (ci->type & BLOCK_FLAG_RAID0 || ci->type & BLOCK_FLAG_RAID10) {
             for (j = 0; j < ci->num_stripes; j++) {
-                UINT16 sub_stripes = max(ci->sub_stripes, 1);
+                uint16_t sub_stripes = max(ci->sub_stripes, 1);
 
                 if (cis[j].offset + (ci->size * ci->num_stripes / sub_stripes) > superblock_addrs[i] && cis[j].offset <= superblock_addrs[i] + sizeof(superblock)) {
 #ifdef _DEBUG
-                    UINT64 startoff;
-                    UINT16 startoffstripe;
+                    uint64_t startoff;
+                    uint16_t startoffstripe;
 #endif
 
-                    TRACE("cut out superblock in chunk %llx\n", c->offset);
+                    TRACE("cut out superblock in chunk %I64x\n", c->offset);
 
                     off_start = superblock_addrs[i] - cis[j].offset;
                     off_start -= off_start % ci->stripe_length;
@@ -3499,18 +3695,18 @@ void protect_superblocks(_Inout_ chunk* c) {
 #ifdef _DEBUG
                     get_raid0_offset(off_start, ci->stripe_length, ci->num_stripes / sub_stripes, &startoff, &startoffstripe);
                     TRACE("j = %u, startoffstripe = %u\n", j, startoffstripe);
-                    TRACE("startoff = %llx, superblock = %llx\n", startoff + cis[j].offset, superblock_addrs[i]);
+                    TRACE("startoff = %I64x, superblock = %I64x\n", startoff + cis[j].offset, superblock_addrs[i]);
 #endif
 
-                    space_list_subtract(c, FALSE, c->offset + off_start, off_end - off_start, NULL);
+                    space_list_subtract(c, false, c->offset + off_start, off_end - off_start, NULL);
                 }
             }
         } else if (ci->type & BLOCK_FLAG_RAID5) {
-            UINT64 stripe_size = ci->size / (ci->num_stripes - 1);
+            uint64_t stripe_size = ci->size / (ci->num_stripes - 1);
 
             for (j = 0; j < ci->num_stripes; j++) {
                 if (cis[j].offset + stripe_size > superblock_addrs[i] && cis[j].offset <= superblock_addrs[i] + sizeof(superblock)) {
-                    TRACE("cut out superblock in chunk %llx\n", c->offset);
+                    TRACE("cut out superblock in chunk %I64x\n", c->offset);
 
                     off_start = superblock_addrs[i] - cis[j].offset;
                     off_start -= off_start % ci->stripe_length;
@@ -3519,17 +3715,17 @@ void protect_superblocks(_Inout_ chunk* c) {
                     off_end = sector_align(superblock_addrs[i] - cis[j].offset + sizeof(superblock), ci->stripe_length);
                     off_end *= ci->num_stripes - 1;
 
-                    TRACE("cutting out %llx, size %llx\n", c->offset + off_start, off_end - off_start);
+                    TRACE("cutting out %I64x, size %I64x\n", c->offset + off_start, off_end - off_start);
 
-                    space_list_subtract(c, FALSE, c->offset + off_start, off_end - off_start, NULL);
+                    space_list_subtract(c, false, c->offset + off_start, off_end - off_start, NULL);
                 }
             }
         } else if (ci->type & BLOCK_FLAG_RAID6) {
-            UINT64 stripe_size = ci->size / (ci->num_stripes - 2);
+            uint64_t stripe_size = ci->size / (ci->num_stripes - 2);
 
             for (j = 0; j < ci->num_stripes; j++) {
                 if (cis[j].offset + stripe_size > superblock_addrs[i] && cis[j].offset <= superblock_addrs[i] + sizeof(superblock)) {
-                    TRACE("cut out superblock in chunk %llx\n", c->offset);
+                    TRACE("cut out superblock in chunk %I64x\n", c->offset);
 
                     off_start = superblock_addrs[i] - cis[j].offset;
                     off_start -= off_start % ci->stripe_length;
@@ -3538,22 +3734,22 @@ void protect_superblocks(_Inout_ chunk* c) {
                     off_end = sector_align(superblock_addrs[i] - cis[j].offset + sizeof(superblock), ci->stripe_length);
                     off_end *= ci->num_stripes - 2;
 
-                    TRACE("cutting out %llx, size %llx\n", c->offset + off_start, off_end - off_start);
+                    TRACE("cutting out %I64x, size %I64x\n", c->offset + off_start, off_end - off_start);
 
-                    space_list_subtract(c, FALSE, c->offset + off_start, off_end - off_start, NULL);
+                    space_list_subtract(c, false, c->offset + off_start, off_end - off_start, NULL);
                 }
             }
         } else { // SINGLE, DUPLICATE, RAID1
             for (j = 0; j < ci->num_stripes; j++) {
                 if (cis[j].offset + ci->size > superblock_addrs[i] && cis[j].offset <= superblock_addrs[i] + sizeof(superblock)) {
-                    TRACE("cut out superblock in chunk %llx\n", c->offset);
+                    TRACE("cut out superblock in chunk %I64x\n", c->offset);
 
                     // The Linux driver protects the whole stripe in which the superblock lives
 
                     off_start = ((superblock_addrs[i] - cis[j].offset) / c->chunk_item->stripe_length) * c->chunk_item->stripe_length;
                     off_end = sector_align(superblock_addrs[i] - cis[j].offset + sizeof(superblock), c->chunk_item->stripe_length);
 
-                    space_list_subtract(c, FALSE, c->offset + off_start, off_end - off_start, NULL);
+                    space_list_subtract(c, false, c->offset + off_start, off_end - off_start, NULL);
                 }
             }
         }
@@ -3562,8 +3758,8 @@ void protect_superblocks(_Inout_ chunk* c) {
     }
 }
 
-UINT64 chunk_estimate_phys_size(device_extension* Vcb, chunk* c, UINT64 u) {
-    UINT64 nfactor, dfactor;
+uint64_t chunk_estimate_phys_size(device_extension* Vcb, chunk* c, uint64_t u) {
+    uint64_t nfactor, dfactor;
 
     if (c->chunk_item->type & BLOCK_FLAG_DUPLICATE || c->chunk_item->type & BLOCK_FLAG_RAID1 || c->chunk_item->type & BLOCK_FLAG_RAID10) {
         nfactor = 1;
@@ -3600,7 +3796,7 @@ NTSTATUS find_chunk_usage(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_ex
         searchkey.obj_id = c->offset;
         searchkey.offset = c->chunk_item->size;
 
-        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
@@ -3612,11 +3808,11 @@ NTSTATUS find_chunk_usage(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_ex
 
                 c->used = c->oldused = bgi->used;
 
-                TRACE("chunk %llx has %llx bytes used\n", c->offset, c->used);
+                TRACE("chunk %I64x has %I64x bytes used\n", c->offset, c->used);
 
                 Vcb->superblock.bytes_used += chunk_estimate_phys_size(Vcb, c, bgi->used);
             } else {
-                ERR("(%llx;%llx,%x,%llx) is %u bytes, expected %u\n",
+                ERR("(%I64x;%I64x,%x,%I64x) is %u bytes, expected %u\n",
                     Vcb->extent_root->id, tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(BLOCK_GROUP_ITEM));
             }
         }
@@ -3624,7 +3820,7 @@ NTSTATUS find_chunk_usage(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_ex
         le = le->Flink;
     }
 
-    Vcb->chunk_usage_found = TRUE;
+    Vcb->chunk_usage_found = true;
 
     return STATUS_SUCCESS;
 }
@@ -3640,7 +3836,7 @@ static NTSTATUS load_sys_chunks(_In_ device_extension* Vcb) {
         } else
             return STATUS_SUCCESS;
 
-        TRACE("bootstrap: %llx,%x,%llx\n", key.obj_id, key.obj_type, key.offset);
+        TRACE("bootstrap: %I64x,%x,%I64x\n", key.obj_id, key.obj_type, key.offset);
 
         if (key.obj_type == TYPE_CHUNK_ITEM) {
             CHUNK_ITEM* ci;
@@ -3678,7 +3874,7 @@ static NTSTATUS load_sys_chunks(_In_ device_extension* Vcb) {
 
             n -= cisize;
         } else {
-            ERR("unexpected item %llx,%x,%llx in bootstrap\n", key.obj_id, key.obj_type, key.offset);
+            ERR("unexpected item %I64x,%x,%I64x in bootstrap\n", key.obj_id, key.obj_type, key.offset);
             return STATUS_INTERNAL_ERROR;
         }
     }
@@ -3691,7 +3887,7 @@ static root* find_default_subvol(_In_ _Requires_lock_held_(_Curr_->tree_lock) de
     LIST_ENTRY* le;
 
     static const char fn[] = "default";
-    static UINT32 crc32 = 0x8dbfc2d2;
+    static uint32_t crc32 = 0x8dbfc2d2;
 
     if (Vcb->options.subvol_id != 0) {
         le = Vcb->roots.Flink;
@@ -3715,26 +3911,26 @@ static root* find_default_subvol(_In_ _Requires_lock_held_(_Curr_->tree_lock) de
         searchkey.obj_type = TYPE_DIR_ITEM;
         searchkey.offset = crc32;
 
-        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             goto end;
         }
 
         if (keycmp(tp.item->key, searchkey)) {
-            ERR("could not find (%llx,%x,%llx) in root tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+            ERR("could not find (%I64x,%x,%I64x) in root tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
             goto end;
         }
 
         if (tp.item->size < sizeof(DIR_ITEM)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DIR_ITEM));
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DIR_ITEM));
             goto end;
         }
 
         di = (DIR_ITEM*)tp.item->data;
 
         if (tp.item->size < sizeof(DIR_ITEM) - 1 + di->n) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DIR_ITEM) - 1 + di->n);
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DIR_ITEM) - 1 + di->n);
             goto end;
         }
 
@@ -3744,7 +3940,7 @@ static root* find_default_subvol(_In_ _Requires_lock_held_(_Curr_->tree_lock) de
         }
 
         if (di->key.obj_type != TYPE_ROOT_ITEM) {
-            ERR("default root has key (%llx,%x,%llx), expected subvolume\n", di->key.obj_id, di->key.obj_type, di->key.offset);
+            ERR("default root has key (%I64x,%x,%I64x), expected subvolume\n", di->key.obj_id, di->key.obj_type, di->key.offset);
             goto end;
         }
 
@@ -3758,7 +3954,7 @@ static root* find_default_subvol(_In_ _Requires_lock_held_(_Curr_->tree_lock) de
             le = le->Flink;
         }
 
-        ERR("could not find root %llx, using default instead\n", di->key.obj_id);
+        ERR("could not find root %I64x, using default instead\n", di->key.obj_id);
     }
 
 end:
@@ -3778,7 +3974,7 @@ end:
 void init_file_cache(_In_ PFILE_OBJECT FileObject, _In_ CC_FILE_SIZES* ccfs) {
     TRACE("(%p, %p)\n", FileObject, ccfs);
 
-    CcInitializeCacheMap(FileObject, ccfs, FALSE, cache_callbacks, FileObject);
+    CcInitializeCacheMap(FileObject, ccfs, false, cache_callbacks, FileObject);
 
     if (diskacc)
         fCcSetAdditionalCacheAttributesEx(FileObject, CC_ENABLE_DISK_IO_ACCOUNTING);
@@ -3786,11 +3982,25 @@ void init_file_cache(_In_ PFILE_OBJECT FileObject, _In_ CC_FILE_SIZES* ccfs) {
     CcSetReadAheadGranularity(FileObject, READ_AHEAD_GRANULARITY);
 }
 
+uint32_t get_num_of_processors() {
+    KAFFINITY p = KeQueryActiveProcessors();
+    uint32_t r = 0;
+
+    while (p != 0) {
+        if (p & 1)
+            r++;
+
+        p >>= 1;
+    }
+
+    return r;
+}
+
 static NTSTATUS create_calc_threads(_In_ PDEVICE_OBJECT DeviceObject) {
     device_extension* Vcb = DeviceObject->DeviceExtension;
     ULONG i;
 
-    Vcb->calcthreads.num_threads = KeQueryActiveProcessorCount(NULL);
+    Vcb->calcthreads.num_threads = get_num_of_processors();
 
     Vcb->calcthreads.threads = ExAllocatePoolWithTag(NonPagedPool, sizeof(drv_calc_thread) * Vcb->calcthreads.num_threads, ALLOC_TAG);
     if (!Vcb->calcthreads.threads) {
@@ -3800,7 +4010,7 @@ static NTSTATUS create_calc_threads(_In_ PDEVICE_OBJECT DeviceObject) {
 
     InitializeListHead(&Vcb->calcthreads.job_list);
     ExInitializeResourceLite(&Vcb->calcthreads.lock);
-    KeInitializeEvent(&Vcb->calcthreads.event, NotificationEvent, FALSE);
+    KeInitializeEvent(&Vcb->calcthreads.event, NotificationEvent, false);
 
     RtlZeroMemory(Vcb->calcthreads.threads, sizeof(drv_calc_thread) * Vcb->calcthreads.num_threads);
 
@@ -3808,7 +4018,7 @@ static NTSTATUS create_calc_threads(_In_ PDEVICE_OBJECT DeviceObject) {
         NTSTATUS Status;
 
         Vcb->calcthreads.threads[i].DeviceObject = DeviceObject;
-        KeInitializeEvent(&Vcb->calcthreads.threads[i].finished, NotificationEvent, FALSE);
+        KeInitializeEvent(&Vcb->calcthreads.threads[i].finished, NotificationEvent, false);
 
         Status = PsCreateSystemThread(&Vcb->calcthreads.threads[i].handle, 0, NULL, NULL, NULL, calc_thread, &Vcb->calcthreads.threads[i]);
         if (!NT_SUCCESS(Status)) {
@@ -3817,10 +4027,10 @@ static NTSTATUS create_calc_threads(_In_ PDEVICE_OBJECT DeviceObject) {
             ERR("PsCreateSystemThread returned %08x\n", Status);
 
             for (j = 0; j < i; j++) {
-                Vcb->calcthreads.threads[i].quit = TRUE;
+                Vcb->calcthreads.threads[i].quit = true;
             }
 
-            KeSetEvent(&Vcb->calcthreads.event, 0, FALSE);
+            KeSetEvent(&Vcb->calcthreads.event, 0, false);
 
             return Status;
         }
@@ -3829,15 +4039,15 @@ static NTSTATUS create_calc_threads(_In_ PDEVICE_OBJECT DeviceObject) {
     return STATUS_SUCCESS;
 }
 
-static BOOL is_btrfs_volume(_In_ PDEVICE_OBJECT DeviceObject) {
+static bool is_btrfs_volume(_In_ PDEVICE_OBJECT DeviceObject) {
     NTSTATUS Status;
     MOUNTDEV_NAME mdn, *mdn2;
     ULONG mdnsize;
 
-    Status = dev_ioctl(DeviceObject, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), TRUE, NULL);
+    Status = dev_ioctl(DeviceObject, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), true, NULL);
     if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
         ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
     mdnsize = (ULONG)offsetof(MOUNTDEV_NAME, Name[0]) + mdn.NameLength;
@@ -3845,25 +4055,25 @@ static BOOL is_btrfs_volume(_In_ PDEVICE_OBJECT DeviceObject) {
     mdn2 = ExAllocatePoolWithTag(PagedPool, mdnsize, ALLOC_TAG);
     if (!mdn2) {
         ERR("out of memory\n");
-        return FALSE;
+        return false;
     }
 
-    Status = dev_ioctl(DeviceObject, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, TRUE, NULL);
+    Status = dev_ioctl(DeviceObject, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, true, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
         ExFreePool(mdn2);
-        return FALSE;
+        return false;
     }
 
     if (mdn2->NameLength > (sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR)) &&
         RtlCompareMemory(mdn2->Name, BTRFS_VOLUME_PREFIX, sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR)) == sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR)) {
         ExFreePool(mdn2);
-        return TRUE;
+        return true;
     }
 
     ExFreePool(mdn2);
 
-    return FALSE;
+    return false;
 }
 
 static NTSTATUS get_device_pnp_name_guid(_In_ PDEVICE_OBJECT DeviceObject, _Out_ PUNICODE_STRING pnp_name, _In_ const GUID* guid) {
@@ -3946,11 +4156,11 @@ NTSTATUS get_device_pnp_name(_In_ PDEVICE_OBJECT DeviceObject, _Out_ PUNICODE_ST
 }
 
 _Success_(return>=0)
-static NTSTATUS check_mount_device(_In_ PDEVICE_OBJECT DeviceObject, _Out_ BOOL* no_pnp) {
+static NTSTATUS check_mount_device(_In_ PDEVICE_OBJECT DeviceObject, _Out_ bool* pno_pnp) {
     NTSTATUS Status;
     ULONG to_read;
     superblock* sb;
-    UINT32 crc32;
+    uint32_t crc32;
     UNICODE_STRING pnp_name;
     const GUID* guid;
 
@@ -3962,7 +4172,7 @@ static NTSTATUS check_mount_device(_In_ PDEVICE_OBJECT DeviceObject, _Out_ BOOL*
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    Status = sync_read_phys(DeviceObject, superblock_addrs[0], to_read, (PUCHAR)sb, TRUE);
+    Status = sync_read_phys(DeviceObject, NULL, superblock_addrs[0], to_read, (PUCHAR)sb, true);
     if (!NT_SUCCESS(Status)) {
         ERR("sync_read_phys returned %08x\n", Status);
         goto end;
@@ -3973,10 +4183,10 @@ static NTSTATUS check_mount_device(_In_ PDEVICE_OBJECT DeviceObject, _Out_ BOOL*
         goto end;
     }
 
-    crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
+    crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
 
-    if (crc32 != *((UINT32*)sb->checksum)) {
-        WARN("crc32 was %08x, expected %08x\n", crc32, *((UINT32*)sb->checksum));
+    if (crc32 != *((uint32_t*)sb->checksum)) {
+        WARN("crc32 was %08x, expected %08x\n", crc32, *((uint32_t*)sb->checksum));
         Status = STATUS_SUCCESS;
         goto end;
     }
@@ -3992,9 +4202,9 @@ static NTSTATUS check_mount_device(_In_ PDEVICE_OBJECT DeviceObject, _Out_ BOOL*
     }
 
     if (pnp_name.Length == 0)
-        *no_pnp = TRUE;
+        *pno_pnp = true;
     else {
-        *no_pnp = FALSE;
+        *pno_pnp = false;
         volume_arrival(drvobj, &pnp_name);
     }
 
@@ -4009,41 +4219,41 @@ end:
     return Status;
 }
 
-static BOOL still_has_superblock(_In_ PDEVICE_OBJECT device) {
+static bool still_has_superblock(_In_ PDEVICE_OBJECT device, _In_ PFILE_OBJECT fileobj) {
     NTSTATUS Status;
     ULONG to_read;
     superblock* sb;
     PDEVICE_OBJECT device2;
 
     if (!device)
-        return FALSE;
+        return false;
 
     to_read = device->SectorSize == 0 ? sizeof(superblock) : (ULONG)sector_align(sizeof(superblock), device->SectorSize);
 
     sb = ExAllocatePoolWithTag(NonPagedPool, to_read, ALLOC_TAG);
     if (!sb) {
         ERR("out of memory\n");
-        return FALSE;
+        return false;
     }
 
-    Status = sync_read_phys(device, superblock_addrs[0], to_read, (PUCHAR)sb, TRUE);
+    Status = sync_read_phys(device, fileobj, superblock_addrs[0], to_read, (PUCHAR)sb, true);
     if (!NT_SUCCESS(Status)) {
         ERR("Failed to read superblock: %08x\n", Status);
         ExFreePool(sb);
-        return FALSE;
+        return false;
     }
 
     if (sb->magic != BTRFS_MAGIC) {
         TRACE("not a BTRFS volume\n");
         ExFreePool(sb);
-        return FALSE;
+        return false;
     } else {
-        UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
+        uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
 
-        if (crc32 != *((UINT32*)sb->checksum)) {
-            WARN("crc32 was %08x, expected %08x\n", crc32, *((UINT32*)sb->checksum));
+        if (crc32 != *((uint32_t*)sb->checksum)) {
+            WARN("crc32 was %08x, expected %08x\n", crc32, *((uint32_t*)sb->checksum));
             ExFreePool(sb);
-            return FALSE;
+            return false;
         }
     }
 
@@ -4055,13 +4265,14 @@ static BOOL still_has_superblock(_In_ PDEVICE_OBJECT device) {
     } while (device2);
 
     ExFreePool(sb);
-    return TRUE;
+    return true;
 }
 
 static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     PIO_STACK_LOCATION IrpSp;
     PDEVICE_OBJECT NewDeviceObject = NULL;
     PDEVICE_OBJECT DeviceToMount, readobj;
+    PFILE_OBJECT fileobj;
     NTSTATUS Status;
     device_extension* Vcb = NULL;
     LIST_ENTRY *le, batchlist;
@@ -4069,13 +4280,12 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     traverse_ptr tp;
     fcb* root_fcb = NULL;
     ccb* root_ccb = NULL;
-    BOOL init_lookaside = FALSE;
+    bool init_lookaside = false;
     device* dev;
     volume_device_extension* vde = NULL;
     pdo_device_extension* pdode = NULL;
     volume_child* vc;
-    BOOL no_pnp = FALSE;
-    UINT64 readobjsize;
+    uint64_t readobjsize;
 
     TRACE("(%p, %p)\n", DeviceObject, Irp);
 
@@ -4088,11 +4298,13 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     DeviceToMount = IrpSp->Parameters.MountVolume.DeviceObject;
 
     if (!is_btrfs_volume(DeviceToMount)) {
-        Status = check_mount_device(DeviceToMount, &no_pnp);
+        bool not_pnp = false;
+
+        Status = check_mount_device(DeviceToMount, &not_pnp);
         if (!NT_SUCCESS(Status))
             WARN("check_mount_device returned %08x\n", Status);
 
-        if (!no_pnp) {
+        if (!not_pnp) {
             Status = STATUS_UNRECOGNIZED_VOLUME;
             goto exit2;
         }
@@ -4105,14 +4317,14 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
             pdo = IoGetLowerDeviceObject(pdo);
         }
 
-        ExAcquireResourceSharedLite(&pdo_list_lock, TRUE);
+        ExAcquireResourceSharedLite(&pdo_list_lock, true);
 
         le = pdo_list.Flink;
         while (le != &pdo_list) {
-            pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
+            pdo_device_extension* pdode2 = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
 
-            if (pdode->pdo == pdo) {
-                vde = pdode->vde;
+            if (pdode2->pdo == pdo) {
+                vde = pdode2->vde;
                 break;
             }
 
@@ -4131,7 +4343,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     if (vde) {
         pdode = vde->pdode;
 
-        ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
 
         le = pdode->children.Flink;
         while (le != &pdode->children) {
@@ -4139,8 +4351,8 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
 
             vc = CONTAINING_RECORD(pdode->children.Flink, volume_child, list_entry);
 
-            if (!still_has_superblock(vc->devobj)) {
-                remove_volume_child(vde, vc, FALSE);
+            if (!still_has_superblock(vc->devobj, vc->fileobj)) {
+                remove_volume_child(vde, vc, false);
 
                 if (pdode->num_children == 0) {
                     ERR("error - number of devices is zero\n");
@@ -4166,6 +4378,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
         vc = CONTAINING_RECORD(pdode->children.Flink, volume_child, list_entry);
 
         readobj = vc->devobj;
+        fileobj = vc->fileobj;
         readobjsize = vc->size;
 
         vde->device->Characteristics &= ~FILE_DEVICE_SECURE_OPEN;
@@ -4174,9 +4387,10 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
 
         vc = NULL;
         readobj = DeviceToMount;
+        fileobj = NULL;
 
         Status = dev_ioctl(readobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
-                           &gli, sizeof(gli), TRUE, NULL);
+                           &gli, sizeof(gli), true, NULL);
 
         if (!NT_SUCCESS(Status)) {
             ERR("error reading length information: %08x\n", Status);
@@ -4186,7 +4400,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
         readobjsize = gli.Length.QuadPart;
     }
 
-    Status = IoCreateDevice(drvobj, sizeof(device_extension), NULL, FILE_DEVICE_DISK_FILE_SYSTEM, 0, FALSE, &NewDeviceObject);
+    Status = IoCreateDevice(drvobj, sizeof(device_extension), NULL, FILE_DEVICE_DISK_FILE_SYSTEM, 0, false, &NewDeviceObject);
     if (!NT_SUCCESS(Status)) {
         ERR("IoCreateDevice returned %08x\n", Status);
         Status = STATUS_UNRECOGNIZED_VOLUME;
@@ -4205,7 +4419,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     Vcb->vde = vde;
 
     ExInitializeResourceLite(&Vcb->tree_lock);
-    Vcb->need_write = FALSE;
+    Vcb->need_write = false;
 
     ExInitializeResourceLite(&Vcb->fcb_lock);
     ExInitializeResourceLite(&Vcb->fileref_lock);
@@ -4216,13 +4430,13 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     ExInitializeResourceLite(&Vcb->scrub.stats_lock);
 
     ExInitializeResourceLite(&Vcb->load_lock);
-    ExAcquireResourceExclusiveLite(&Vcb->load_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->load_lock, true);
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     DeviceToMount->Flags |= DO_DIRECT_IO;
 
-    Status = read_superblock(Vcb, readobj, readobjsize);
+    Status = read_superblock(Vcb, readobj, fileobj, readobjsize);
     if (!NT_SUCCESS(Status)) {
         if (!IoIsErrorUserInduced(Status))
             Status = STATUS_UNRECOGNIZED_VOLUME;
@@ -4257,19 +4471,19 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     }
 
     if (Vcb->superblock.incompat_flags & ~INCOMPAT_SUPPORTED) {
-        WARN("cannot mount because of unsupported incompat flags (%llx)\n", Vcb->superblock.incompat_flags & ~INCOMPAT_SUPPORTED);
+        WARN("cannot mount because of unsupported incompat flags (%I64x)\n", Vcb->superblock.incompat_flags & ~INCOMPAT_SUPPORTED);
         Status = STATUS_UNRECOGNIZED_VOLUME;
         goto exit;
     }
 
-    Vcb->readonly = FALSE;
+    Vcb->readonly = false;
     if (Vcb->superblock.compat_ro_flags & ~COMPAT_RO_SUPPORTED) {
-        WARN("mounting read-only because of unsupported flags (%llx)\n", Vcb->superblock.compat_ro_flags & ~COMPAT_RO_SUPPORTED);
-        Vcb->readonly = TRUE;
+        WARN("mounting read-only because of unsupported flags (%I64x)\n", Vcb->superblock.compat_ro_flags & ~COMPAT_RO_SUPPORTED);
+        Vcb->readonly = true;
     }
 
     if (Vcb->options.readonly)
-        Vcb->readonly = TRUE;
+        Vcb->readonly = true;
 
     Vcb->superblock.generation++;
     Vcb->superblock.incompat_flags |= BTRFS_INCOMPAT_FLAGS_MIXED_BACKREF;
@@ -4283,24 +4497,25 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     }
 
     dev->devobj = readobj;
+    dev->fileobj = fileobj;
     RtlCopyMemory(&dev->devitem, &Vcb->superblock.dev_item, sizeof(DEV_ITEM));
 
     if (dev->devitem.num_bytes > readobjsize) {
-        WARN("device %llx: DEV_ITEM says %llx bytes, but Windows only reports %llx\n", dev->devitem.dev_id,
+        WARN("device %I64x: DEV_ITEM says %I64x bytes, but Windows only reports %I64x\n", dev->devitem.dev_id,
                 dev->devitem.num_bytes, readobjsize);
 
         dev->devitem.num_bytes = readobjsize;
     }
 
-    dev->seeding = Vcb->superblock.flags & BTRFS_SUPERBLOCK_FLAGS_SEEDING ? TRUE : FALSE;
+    dev->seeding = Vcb->superblock.flags & BTRFS_SUPERBLOCK_FLAGS_SEEDING ? true : false;
 
-    init_device(Vcb, dev, TRUE);
+    init_device(Vcb, dev, true);
 
     InsertTailList(&Vcb->devices, &dev->list_entry);
     Vcb->devices_loaded = 1;
 
     if (DeviceToMount->Flags & DO_SYSTEM_BOOT_PARTITION)
-        Vcb->disallow_dismount = TRUE;
+        Vcb->disallow_dismount = true;
 
     TRACE("DeviceToMount = %p\n", DeviceToMount);
     TRACE("IrpSp->Parameters.MountVolume.Vpb = %p\n", IrpSp->Parameters.MountVolume.Vpb);
@@ -4311,7 +4526,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     InitializeListHead(&Vcb->roots);
     InitializeListHead(&Vcb->drop_roots);
 
-    Vcb->log_to_phys_loaded = FALSE;
+    Vcb->log_to_phys_loaded = false;
 
     add_root(Vcb, BTRFS_ROOT_CHUNK, Vcb->superblock.chunk_tree_addr, Vcb->superblock.chunk_root_generation, NULL);
 
@@ -4353,7 +4568,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     ExInitializeNPagedLookasideList(&Vcb->range_lock_lookaside, NULL, NULL, 0, sizeof(range_lock), ALLOC_TAG, 0);
     ExInitializeNPagedLookasideList(&Vcb->fileref_np_lookaside, NULL, NULL, 0, sizeof(file_ref_nonpaged), ALLOC_TAG, 0);
     ExInitializeNPagedLookasideList(&Vcb->fcb_np_lookaside, NULL, NULL, 0, sizeof(fcb_nonpaged), ALLOC_TAG, 0);
-    init_lookaside = TRUE;
+    init_lookaside = true;
 
     Vcb->Vpb = IrpSp->Parameters.MountVolume.Vpb;
 
@@ -4374,7 +4589,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
         }
 
         if (dev->readonly && !Vcb->readonly) {
-            Vcb->readonly = TRUE;
+            Vcb->readonly = true;
 
             le = Vcb->devices.Flink;
             while (le != &Vcb->devices) {
@@ -4384,7 +4599,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
                     break;
 
                 if (!dev2->readonly) {
-                    Vcb->readonly = FALSE;
+                    Vcb->readonly = false;
                     break;
                 }
 
@@ -4397,7 +4612,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     } else {
         if (dev->readonly) {
             WARN("setting volume to readonly as device is readonly\n");
-            Vcb->readonly = TRUE;
+            Vcb->readonly = true;
         }
     }
 
@@ -4435,7 +4650,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
         else if (Vcb->superblock.compat_ro_flags & BTRFS_COMPAT_RO_FLAGS_FREE_SPACE_CACHE && !(Vcb->superblock.compat_ro_flags & BTRFS_COMPAT_RO_FLAGS_FREE_SPACE_CACHE_VALID))
             WARN("clearing free-space tree created by buggy Linux driver\n");
         else
-            WARN("generation was %llx, free-space cache generation was %llx; clearing cache...\n", Vcb->superblock.generation - 1, Vcb->superblock.cache_generation);
+            WARN("generation was %I64x, free-space cache generation was %I64x; clearing cache...\n", Vcb->superblock.generation - 1, Vcb->superblock.cache_generation);
 
         Status = clear_free_space_cache(Vcb, &batchlist, Irp);
         if (!NT_SUCCESS(Status)) {
@@ -4503,7 +4718,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
 
     root_fcb->Vcb = Vcb;
     root_fcb->inode = SUBVOL_ROOT_INODE;
-    root_fcb->hash = calc_crc32c(0xffffffff, (UINT8*)&root_fcb->inode, sizeof(UINT64));
+    root_fcb->hash = calc_crc32c(0xffffffff, (uint8_t*)&root_fcb->inode, sizeof(uint64_t));
     root_fcb->type = BTRFS_TYPE_DIRECTORY;
 
 #ifdef DEBUG_FCB_REFCOUNTS
@@ -4519,7 +4734,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
         goto exit;
     }
 
-    Status = load_dir_children(Vcb, root_fcb, TRUE, Irp);
+    Status = load_dir_children(Vcb, root_fcb, true, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("load_dir_children returned %08x\n", Status);
         goto exit;
@@ -4529,7 +4744,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     searchkey.obj_type = TYPE_INODE_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, root_fcb->subvol, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, root_fcb->subvol, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         goto exit;
@@ -4544,9 +4759,9 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     if (tp.item->size > 0)
         RtlCopyMemory(&root_fcb->inode_item, tp.item->data, min(sizeof(INODE_ITEM), tp.item->size));
 
-    fcb_get_sd(root_fcb, NULL, TRUE, Irp);
+    fcb_get_sd(root_fcb, NULL, true, Irp);
 
-    root_fcb->atts = get_file_attributes(Vcb, root_fcb->subvol, root_fcb->inode, root_fcb->type, FALSE, FALSE, Irp);
+    root_fcb->atts = get_file_attributes(Vcb, root_fcb->subvol, root_fcb->inode, root_fcb->type, false, false, Irp);
 
     Vcb->root_fileref = create_fileref(Vcb);
     if (!Vcb->root_fileref) {
@@ -4596,7 +4811,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     Vcb->root_file->FsContext2 = root_ccb;
 
     _SEH2_TRY {
-        CcInitializeCacheMap(Vcb->root_file, (PCC_FILE_SIZES)(&root_fcb->Header.AllocationSize), FALSE, cache_callbacks, Vcb->root_file);
+        CcInitializeCacheMap(Vcb->root_file, (PCC_FILE_SIZES)(&root_fcb->Header.AllocationSize), false, cache_callbacks, Vcb->root_file);
     } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
         Status = _SEH2_GetExceptionCode();
         goto exit;
@@ -4623,7 +4838,7 @@ static NTSTATUS mount_vol(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     NewDeviceObject->Vpb->VolumeLabel[1] = 0;
     NewDeviceObject->Vpb->ReferenceCount++; // FIXME - should we deref this at any point?
 
-    KeInitializeEvent(&Vcb->flush_thread_finished, NotificationEvent, FALSE);
+    KeInitializeEvent(&Vcb->flush_thread_finished, NotificationEvent, false);
 
     Status = PsCreateSystemThread(&Vcb->flush_thread_handle, 0, NULL, NULL, NULL, flush_thread, NewDeviceObject);
     if (!NT_SUCCESS(Status)) {
@@ -4711,7 +4926,7 @@ exit2:
         if (NewDeviceObject)
             IoDeleteDevice(NewDeviceObject);
     } else {
-        ExAcquireResourceExclusiveLite(&global_loading_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&global_loading_lock, true);
         InsertTailList(&VcbList, &Vcb->list_entry);
         ExReleaseResourceLite(&global_loading_lock);
 
@@ -4726,7 +4941,7 @@ exit2:
 static NTSTATUS verify_device(_In_ device_extension* Vcb, _Inout_ device* dev) {
     NTSTATUS Status;
     superblock* sb;
-    UINT32 crc32;
+    uint32_t crc32;
     ULONG to_read, cc;
 
     if (!dev->devobj)
@@ -4735,7 +4950,7 @@ static NTSTATUS verify_device(_In_ device_extension* Vcb, _Inout_ device* dev) {
     if (dev->removable) {
         IO_STATUS_BLOCK iosb;
 
-        Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, &cc, sizeof(ULONG), TRUE, &iosb);
+        Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, &cc, sizeof(ULONG), true, &iosb);
 
         if (IoIsErrorUserInduced(Status)) {
             ERR("IOCTL_STORAGE_CHECK_VERIFY returned %08x (user-induced)\n", Status);
@@ -4743,9 +4958,9 @@ static NTSTATUS verify_device(_In_ device_extension* Vcb, _Inout_ device* dev) {
             if (Vcb->vde) {
                 pdo_device_extension* pdode = Vcb->vde->pdode;
                 LIST_ENTRY* le2;
-                BOOL changed = FALSE;
+                bool changed = false;
 
-                ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
 
                 le2 = pdode->children.Flink;
                 while (le2 != &pdode->children) {
@@ -4754,8 +4969,8 @@ static NTSTATUS verify_device(_In_ device_extension* Vcb, _Inout_ device* dev) {
                     if (vc->devobj == dev->devobj) {
                         TRACE("removing device\n");
 
-                        remove_volume_child(Vcb->vde, vc, TRUE);
-                        changed = TRUE;
+                        remove_volume_child(Vcb->vde, vc, true);
+                        changed = true;
 
                         break;
                     }
@@ -4785,7 +5000,7 @@ static NTSTATUS verify_device(_In_ device_extension* Vcb, _Inout_ device* dev) {
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    Status = sync_read_phys(dev->devobj, superblock_addrs[0], to_read, (PUCHAR)sb, TRUE);
+    Status = sync_read_phys(dev->devobj, dev->fileobj, superblock_addrs[0], to_read, (PUCHAR)sb, true);
     if (!NT_SUCCESS(Status)) {
         ERR("Failed to read superblock: %08x\n", Status);
         ExFreePool(sb);
@@ -4798,10 +5013,10 @@ static NTSTATUS verify_device(_In_ device_extension* Vcb, _Inout_ device* dev) {
         return STATUS_WRONG_VOLUME;
     }
 
-    crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
-    TRACE("crc32 was %08x, expected %08x\n", crc32, *((UINT32*)sb->checksum));
+    crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
+    TRACE("crc32 was %08x, expected %08x\n", crc32, *((uint32_t*)sb->checksum));
 
-    if (crc32 != *((UINT32*)sb->checksum)) {
+    if (crc32 != *((uint32_t*)sb->checksum)) {
         ERR("checksum error\n");
         ExFreePool(sb);
         return STATUS_WRONG_VOLUME;
@@ -4824,15 +5039,15 @@ static NTSTATUS verify_volume(_In_ PDEVICE_OBJECT devobj) {
     device_extension* Vcb = devobj->DeviceExtension;
     NTSTATUS Status;
     LIST_ENTRY* le;
-    UINT64 failed_devices = 0;
-    BOOL locked = FALSE, remove = FALSE;
+    uint64_t failed_devices = 0;
+    bool locked = false, remove = false;
 
     if (!(Vcb->Vpb->Flags & VPB_MOUNTED))
         return STATUS_WRONG_VOLUME;
 
     if (!ExIsResourceAcquiredExclusive(&Vcb->tree_lock)) {
-        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
-        locked = TRUE;
+        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
+        locked = true;
     }
 
     if (Vcb->removing) {
@@ -4860,7 +5075,7 @@ static NTSTATUS verify_volume(_In_ PDEVICE_OBJECT devobj) {
     InterlockedDecrement(&Vcb->open_files);
 
     if (Vcb->removing && Vcb->open_files == 0)
-        remove = TRUE;
+        remove = true;
 
     if (locked)
         ExReleaseResourceLite(&Vcb->tree_lock);
@@ -4881,15 +5096,11 @@ static NTSTATUS verify_volume(_In_ PDEVICE_OBJECT devobj) {
 
 _Dispatch_type_(IRP_MJ_FILE_SYSTEM_CONTROL)
 _Function_class_(DRIVER_DISPATCH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI drv_file_system_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#else
-static NTSTATUS drv_file_system_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#endif
+static NTSTATUS __stdcall drv_file_system_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     PIO_STACK_LOCATION IrpSp;
     NTSTATUS Status;
     device_extension* Vcb = DeviceObject->DeviceExtension;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -4936,8 +5147,8 @@ static NTSTATUS drv_file_system_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ P
             Status = verify_volume(DeviceObject);
 
             if (!NT_SUCCESS(Status) && Vcb->Vpb->Flags & VPB_MOUNTED) {
-                ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
-                Vcb->removing = TRUE;
+                ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
+                Vcb->removing = true;
                 ExReleaseResourceLite(&Vcb->tree_lock);
             }
 
@@ -4966,16 +5177,12 @@ end:
 
 _Dispatch_type_(IRP_MJ_LOCK_CONTROL)
 _Function_class_(DRIVER_DISPATCH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI drv_lock_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#else
-static NTSTATUS drv_lock_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#endif
+static NTSTATUS __stdcall drv_lock_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     fcb* fcb = IrpSp->FileObject->FsContext;
     device_extension* Vcb = DeviceObject->DeviceExtension;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -5009,13 +5216,9 @@ exit:
 
 _Dispatch_type_(IRP_MJ_SHUTDOWN)
 _Function_class_(DRIVER_DISPATCH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI drv_shutdown(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#else
-static NTSTATUS drv_shutdown(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#endif
+static NTSTATUS __stdcall drv_shutdown(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     NTSTATUS Status;
-    BOOL top_level;
+    bool top_level;
     device_extension* Vcb = DeviceObject->DeviceExtension;
     LIST_ENTRY* le;
 
@@ -5032,20 +5235,20 @@ static NTSTATUS drv_shutdown(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
 
     Status = STATUS_SUCCESS;
 
-    shutting_down = TRUE;
-    KeSetEvent(&mountmgr_thread_event, 0, FALSE);
+    shutting_down = true;
+    KeSetEvent(&mountmgr_thread_event, 0, false);
 
     le = VcbList.Flink;
     while (le != &VcbList) {
-        BOOL open_files;
+        bool open_files;
         LIST_ENTRY* le2 = le->Flink;
 
         Vcb = CONTAINING_RECORD(le, device_extension, list_entry);
 
         TRACE("shutting down Vcb %p\n", Vcb);
 
-        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
-        Vcb->removing = TRUE;
+        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
+        Vcb->removing = true;
         open_files = Vcb->open_files > 0;
 
         if (Vcb->need_write && !Vcb->readonly) {
@@ -5088,14 +5291,11 @@ end:
 
 _Dispatch_type_(IRP_MJ_POWER)
 _Function_class_(DRIVER_DISPATCH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI drv_power(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#else
-static NTSTATUS drv_power(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#endif
+static NTSTATUS __stdcall drv_power(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     NTSTATUS Status;
+    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     device_extension* Vcb = DeviceObject->DeviceExtension;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -5104,10 +5304,11 @@ static NTSTATUS drv_power(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     Irp->IoStatus.Information = 0;
 
     if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
-        Status = vol_power(DeviceObject, Irp);
+        volume_device_extension* vde = DeviceObject->DeviceExtension;
 
-        Irp->IoStatus.Status = Status;
-        IoCompleteRequest(Irp, IO_NO_INCREMENT);
+        PoStartNextPowerIrp(Irp);
+        IoSkipCurrentIrpStackLocation(Irp);
+        Status = PoCallDriver(vde->attached_device, Irp);
 
         goto exit;
     } else if (Vcb && Vcb->type == VCB_TYPE_FS) {
@@ -5115,11 +5316,24 @@ static NTSTATUS drv_power(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
 
         Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
 
+        goto exit;
+    } else if (Vcb && Vcb->type == VCB_TYPE_BUS) {
+        bus_device_extension* bde = DeviceObject->DeviceExtension;
+
+        PoStartNextPowerIrp(Irp);
+        IoSkipCurrentIrpStackLocation(Irp);
+        Status = PoCallDriver(bde->attached_device, Irp);
+
         goto exit;
     }
 
-    Status = STATUS_INVALID_DEVICE_REQUEST;
-    Irp->IoStatus.Status = Status;
+    if (IrpSp->MinorFunction == IRP_MN_SET_POWER || IrpSp->MinorFunction == IRP_MN_QUERY_POWER)
+        Irp->IoStatus.Status = STATUS_SUCCESS;
+
+    Status = Irp->IoStatus.Status;
+
+    PoStartNextPowerIrp(Irp);
+
     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
 exit:
@@ -5133,14 +5347,10 @@ exit:
 
 _Dispatch_type_(IRP_MJ_SYSTEM_CONTROL)
 _Function_class_(DRIVER_DISPATCH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI drv_system_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#else
-static NTSTATUS drv_system_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
-#endif
+static NTSTATUS __stdcall drv_system_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) {
     NTSTATUS Status;
     device_extension* Vcb = DeviceObject->DeviceExtension;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -5153,7 +5363,7 @@ static NTSTATUS drv_system_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP I
 
         IoSkipCurrentIrpStackLocation(Irp);
 
-        Status = IoCallDriver(vde->pdo, Irp);
+        Status = IoCallDriver(vde->attached_device, Irp);
 
         goto exit;
     } else if (Vcb && Vcb->type == VCB_TYPE_FS) {
@@ -5161,6 +5371,14 @@ static NTSTATUS drv_system_control(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP I
 
         Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
 
+        goto exit;
+    } else if (Vcb && Vcb->type == VCB_TYPE_BUS) {
+        bus_device_extension* bde = DeviceObject->DeviceExtension;
+
+        IoSkipCurrentIrpStackLocation(Irp);
+
+        Status = IoCallDriver(bde->attached_device, Irp);
+
         goto exit;
     }
 
@@ -5176,31 +5394,31 @@ exit:
     return Status;
 }
 
-BOOL is_file_name_valid(_In_ PUNICODE_STRING us, _In_ BOOL posix) {
+bool is_file_name_valid(_In_ PUNICODE_STRING us, _In_ bool posix) {
     ULONG i;
 
     if (us->Length < sizeof(WCHAR))
-        return FALSE;
+        return false;
 
     if (us->Length > 255 * sizeof(WCHAR))
-        return FALSE;
+        return false;
 
     for (i = 0; i < us->Length / sizeof(WCHAR); i++) {
         if (us->Buffer[i] == '/' || us->Buffer[i] == 0 ||
             (!posix && (us->Buffer[i] == '<' || us->Buffer[i] == '>' || us->Buffer[i] == ':' || us->Buffer[i] == '"' ||
             us->Buffer[i] == '|' || us->Buffer[i] == '?' || us->Buffer[i] == '*' || (us->Buffer[i] >= 1 && us->Buffer[i] <= 31))))
-            return FALSE;
+            return false;
     }
 
     if (us->Buffer[0] == '.' && (us->Length == sizeof(WCHAR) || (us->Length == 2 * sizeof(WCHAR) && us->Buffer[1] == '.')))
-        return FALSE;
+        return false;
 
-    return TRUE;
+    return true;
 }
 
-void chunk_lock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ UINT64 start, _In_ UINT64 length) {
+void chunk_lock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ uint64_t start, _In_ uint64_t length) {
     LIST_ENTRY* le;
-    BOOL locked;
+    bool locked;
     range_lock* rl;
 
     rl = ExAllocateFromNPagedLookasideList(&Vcb->range_lock_lookaside);
@@ -5213,17 +5431,17 @@ void chunk_lock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ UINT64 sta
     rl->length = length;
     rl->thread = PsGetCurrentThread();
 
-    while (TRUE) {
-        locked = FALSE;
+    while (true) {
+        locked = false;
 
-        ExAcquireResourceExclusiveLite(&c->range_locks_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&c->range_locks_lock, true);
 
         le = c->range_locks.Flink;
         while (le != &c->range_locks) {
             range_lock* rl2 = CONTAINING_RECORD(le, range_lock, list_entry);
 
             if (rl2->start < start + length && rl2->start + rl2->length > start && rl2->thread != PsGetCurrentThread()) {
-                locked = TRUE;
+                locked = true;
                 break;
             }
 
@@ -5241,14 +5459,14 @@ void chunk_lock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ UINT64 sta
 
         ExReleaseResourceLite(&c->range_locks_lock);
 
-        KeWaitForSingleObject(&c->range_locks_event, UserRequest, KernelMode, FALSE, NULL);
+        KeWaitForSingleObject(&c->range_locks_event, UserRequest, KernelMode, false, NULL);
     }
 }
 
-void chunk_unlock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ UINT64 start, _In_ UINT64 length) {
+void chunk_unlock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ uint64_t start, _In_ uint64_t length) {
     LIST_ENTRY* le;
 
-    ExAcquireResourceExclusiveLite(&c->range_locks_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&c->range_locks_lock, true);
 
     le = c->range_locks.Flink;
     while (le != &c->range_locks) {
@@ -5263,20 +5481,20 @@ void chunk_unlock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ UINT64 s
         le = le->Flink;
     }
 
-    KeSetEvent(&c->range_locks_event, 0, FALSE);
+    KeSetEvent(&c->range_locks_event, 0, false);
 
     ExReleaseResourceLite(&c->range_locks_lock);
 }
 
 void log_device_error(_In_ device_extension* Vcb, _Inout_ device* dev, _In_ int error) {
     dev->stats[error]++;
-    dev->stats_changed = TRUE;
-    Vcb->stats_changed = TRUE;
+    dev->stats_changed = true;
+    Vcb->stats_changed = true;
 }
 
 #ifdef _DEBUG
 _Function_class_(KSTART_ROUTINE)
-static void serial_thread(void* context) {
+static void __stdcall serial_thread(void* context) {
     LARGE_INTEGER due_time;
     KTIMER timer;
 
@@ -5284,14 +5502,14 @@ static void serial_thread(void* context) {
 
     KeInitializeTimer(&timer);
 
-    due_time.QuadPart = (UINT64)-10000000;
+    due_time.QuadPart = (uint64_t)-10000000;
 
     KeSetTimer(&timer, due_time, NULL);
 
-    while (TRUE) {
-        KeWaitForSingleObject(&timer, Executive, KernelMode, FALSE, NULL);
+    while (true) {
+        KeWaitForSingleObject(&timer, Executive, KernelMode, false, NULL);
 
-        init_serial(FALSE);
+        init_serial(false);
 
         if (comdo)
             break;
@@ -5306,7 +5524,7 @@ static void serial_thread(void* context) {
     serial_thread_handle = NULL;
 }
 
-static void init_serial(BOOL first_time) {
+static void init_serial(bool first_time) {
     NTSTATUS Status;
 
     Status = IoGetDeviceObjectPointer(&log_device, FILE_WRITE_DATA, &comfo, &comdo);
@@ -5314,8 +5532,6 @@ static void init_serial(BOOL first_time) {
         ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
 
         if (first_time) {
-            NTSTATUS Status;
-
             Status = PsCreateSystemThread(&serial_thread_handle, 0, NULL, NULL, NULL, serial_thread, NULL);
             if (!NT_SUCCESS(Status)) {
                 ERR("PsCreateSystemThread returned %08x\n", Status);
@@ -5353,10 +5569,10 @@ static void check_cpu() {
 
 #ifdef _DEBUG
 static void init_logging() {
-    ExAcquireResourceExclusiveLite(&log_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&log_lock, true);
 
     if (log_device.Length > 0)
-        init_serial(TRUE);
+        init_serial(true);
     else if (log_file.Length > 0) {
         NTSTATUS Status;
         OBJECT_ATTRIBUTES oa;
@@ -5436,11 +5652,7 @@ end:
 #endif
 
 _Function_class_(KSTART_ROUTINE)
-#ifdef __REACTOS__
-static void NTAPI degraded_wait_thread(_In_ void* context) {
-#else
-static void degraded_wait_thread(_In_ void* context) {
-#endif
+static void __stdcall degraded_wait_thread(_In_ void* context) {
     KTIMER timer;
     LARGE_INTEGER delay;
 
@@ -5450,11 +5662,11 @@ static void degraded_wait_thread(_In_ void* context) {
 
     delay.QuadPart = -30000000; // wait three seconds
     KeSetTimer(&timer, delay, NULL);
-    KeWaitForSingleObject(&timer, Executive, KernelMode, FALSE, NULL);
+    KeWaitForSingleObject(&timer, Executive, KernelMode, false, NULL);
 
     TRACE("timer expired\n");
 
-    degraded_wait = FALSE;
+    degraded_wait = false;
 
     ZwClose(degraded_wait_handle);
     degraded_wait_handle = NULL;
@@ -5462,11 +5674,8 @@ static void degraded_wait_thread(_In_ void* context) {
     PsTerminateSystemThread(STATUS_SUCCESS);
 }
 
-#ifdef __REACTOS__
-NTSTATUS NTAPI AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject) {
-#else
-NTSTATUS AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject) {
-#endif
+_Function_class_(DRIVER_ADD_DEVICE)
+NTSTATUS __stdcall AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject) {
     LIST_ENTRY* le;
     NTSTATUS Status;
     UNICODE_STRING volname;
@@ -5477,7 +5686,7 @@ NTSTATUS AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObj
 
     TRACE("(%p, %p)\n", DriverObject, PhysicalDeviceObject);
 
-    ExAcquireResourceSharedLite(&pdo_list_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdo_list_lock, true);
 
     le = pdo_list.Flink;
     while (le != &pdo_list) {
@@ -5497,7 +5706,7 @@ NTSTATUS AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObj
         goto end;
     }
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     volname.Length = volname.MaximumLength = (sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR)) + ((36 + 1) * sizeof(WCHAR));
     volname.Buffer = ExAllocatePoolWithTag(PagedPool, volname.MaximumLength, ALLOC_TAG); // FIXME - when do we free this?
@@ -5524,7 +5733,7 @@ NTSTATUS AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObj
     volname.Buffer[j] = '}';
 
     Status = IoCreateDevice(drvobj, sizeof(volume_device_extension), &volname, FILE_DEVICE_DISK,
-                            RtlIsNtDdiVersionAvailable(NTDDI_WIN8) ? FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL : 0, FALSE, &voldev);
+                            WdmlibRtlIsNtDdiVersionAvailable(NTDDI_WIN8) ? FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL : 0, false, &voldev);
     if (!NT_SUCCESS(Status)) {
         ERR("IoCreateDevice returned %08x\n", Status);
         goto end2;
@@ -5540,7 +5749,7 @@ NTSTATUS AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObj
     vde->mounted_device = NULL;
     vde->pdo = PhysicalDeviceObject;
     vde->pdode = pdode;
-    vde->removing = FALSE;
+    vde->removing = false;
     vde->open_count = 0;
 
     Status = IoRegisterDeviceInterface(PhysicalDeviceObject, &GUID_DEVINTERFACE_VOLUME, NULL, &vde->bus_name);
@@ -5556,7 +5765,7 @@ NTSTATUS AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObj
 
     voldev->Flags &= ~DO_DEVICE_INITIALIZING;
 
-    Status = IoSetDeviceInterfaceState(&vde->bus_name, TRUE);
+    Status = IoSetDeviceInterfaceState(&vde->bus_name, true);
     if (!NT_SUCCESS(Status))
         WARN("IoSetDeviceInterfaceState returned %08x\n", Status);
 
@@ -5572,16 +5781,13 @@ end:
 }
 
 _Function_class_(DRIVER_INITIALIZE)
-#ifdef __REACTOS__
-NTSTATUS NTAPI DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath) {
-#else
-NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath) {
-#endif
+NTSTATUS __stdcall DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath) {
     NTSTATUS Status;
     PDEVICE_OBJECT DeviceObject;
     UNICODE_STRING device_nameW;
     UNICODE_STRING dosdevice_nameW;
     control_device_extension* cde;
+    bus_device_extension* bde;
     HANDLE regh;
     OBJECT_ATTRIBUTES oa;
     ULONG dispos;
@@ -5609,13 +5815,13 @@ NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING Regi
 
     RtlCopyMemory(registry_path.Buffer, RegistryPath->Buffer, registry_path.Length);
 
-    read_registry(&registry_path, FALSE);
+    read_registry(&registry_path, false);
 
 #ifdef _DEBUG
     if (debug_log_level > 0)
         init_logging();
 
-    log_started = TRUE;
+    log_started = true;
 #endif
 
     TRACE("DriverEntry\n");
@@ -5624,7 +5830,7 @@ NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING Regi
     check_cpu();
 #endif
 
-    if (RtlIsNtDdiVersionAvailable(NTDDI_WIN8)) {
+    if (WdmlibRtlIsNtDdiVersionAvailable(NTDDI_WIN8)) {
         UNICODE_STRING name;
         tPsIsDiskCountersEnabled fPsIsDiskCountersEnabled;
 
@@ -5638,7 +5844,7 @@ NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING Regi
             fPsUpdateDiskCounters = (tPsUpdateDiskCounters)MmGetSystemRoutineAddress(&name);
 
             if (!fPsUpdateDiskCounters)
-                diskacc = FALSE;
+                diskacc = false;
 
             RtlInitUnicodeString(&name, L"FsRtlUpdateDiskCounters");
             fFsRtlUpdateDiskCounters = (tFsRtlUpdateDiskCounters)MmGetSystemRoutineAddress(&name);
@@ -5660,13 +5866,37 @@ NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING Regi
         fFsRtlUpdateDiskCounters = NULL;
     }
 
+    if (WdmlibRtlIsNtDdiVersionAvailable(NTDDI_WIN7)) {
+        UNICODE_STRING name;
+
+        RtlInitUnicodeString(&name, L"IoUnregisterPlugPlayNotificationEx");
+        fIoUnregisterPlugPlayNotificationEx = (tIoUnregisterPlugPlayNotificationEx)MmGetSystemRoutineAddress(&name);
+    } else
+        fIoUnregisterPlugPlayNotificationEx = NULL;
+
+    if (WdmlibRtlIsNtDdiVersionAvailable(NTDDI_VISTA)) {
+        UNICODE_STRING name;
+
+        RtlInitUnicodeString(&name, L"FsRtlGetEcpListFromIrp");
+        fFsRtlGetEcpListFromIrp = (tFsRtlGetEcpListFromIrp)MmGetSystemRoutineAddress(&name);
+
+        RtlInitUnicodeString(&name, L"FsRtlGetNextExtraCreateParameter");
+        fFsRtlGetNextExtraCreateParameter = (tFsRtlGetNextExtraCreateParameter)MmGetSystemRoutineAddress(&name);
+
+        RtlInitUnicodeString(&name, L"FsRtlValidateReparsePointBuffer");
+        fFsRtlValidateReparsePointBuffer = (tFsRtlValidateReparsePointBuffer)MmGetSystemRoutineAddress(&name);
+    } else {
+        fFsRtlGetEcpListFromIrp = NULL;
+        fFsRtlGetNextExtraCreateParameter = NULL;
+        fFsRtlValidateReparsePointBuffer = compat_FsRtlValidateReparsePointBuffer;
+    }
+
     drvobj = DriverObject;
 
     DriverObject->DriverUnload = DriverUnload;
 
     DriverObject->DriverExtension->AddDevice = AddDevice;
 
-#ifdef __REACTOS__
     DriverObject->MajorFunction[IRP_MJ_CREATE]                   = drv_create;
     DriverObject->MajorFunction[IRP_MJ_CLOSE]                    = drv_close;
     DriverObject->MajorFunction[IRP_MJ_READ]                     = drv_read;
@@ -5689,30 +5919,6 @@ NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING Regi
     DriverObject->MajorFunction[IRP_MJ_POWER]                    = drv_power;
     DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL]           = drv_system_control;
     DriverObject->MajorFunction[IRP_MJ_PNP]                      = drv_pnp;
-#else
-    DriverObject->MajorFunction[IRP_MJ_CREATE]                   = (PDRIVER_DISPATCH)drv_create;
-    DriverObject->MajorFunction[IRP_MJ_CLOSE]                    = (PDRIVER_DISPATCH)drv_close;
-    DriverObject->MajorFunction[IRP_MJ_READ]                     = (PDRIVER_DISPATCH)drv_read;
-    DriverObject->MajorFunction[IRP_MJ_WRITE]                    = (PDRIVER_DISPATCH)drv_write;
-    DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION]        = (PDRIVER_DISPATCH)drv_query_information;
-    DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION]          = (PDRIVER_DISPATCH)drv_set_information;
-    DriverObject->MajorFunction[IRP_MJ_QUERY_EA]                 = (PDRIVER_DISPATCH)drv_query_ea;
-    DriverObject->MajorFunction[IRP_MJ_SET_EA]                   = (PDRIVER_DISPATCH)drv_set_ea;
-    DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS]            = (PDRIVER_DISPATCH)drv_flush_buffers;
-    DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)drv_query_volume_information;
-    DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION]   = (PDRIVER_DISPATCH)drv_set_volume_information;
-    DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL]        = (PDRIVER_DISPATCH)drv_directory_control;
-    DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL]      = (PDRIVER_DISPATCH)drv_file_system_control;
-    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]           = (PDRIVER_DISPATCH)drv_device_control;
-    DriverObject->MajorFunction[IRP_MJ_SHUTDOWN]                 = (PDRIVER_DISPATCH)drv_shutdown;
-    DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL]             = (PDRIVER_DISPATCH)drv_lock_control;
-    DriverObject->MajorFunction[IRP_MJ_CLEANUP]                  = (PDRIVER_DISPATCH)drv_cleanup;
-    DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY]           = (PDRIVER_DISPATCH)drv_query_security;
-    DriverObject->MajorFunction[IRP_MJ_SET_SECURITY]             = (PDRIVER_DISPATCH)drv_set_security;
-    DriverObject->MajorFunction[IRP_MJ_POWER]                    = (PDRIVER_DISPATCH)drv_power;
-    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL]           = (PDRIVER_DISPATCH)drv_system_control;
-    DriverObject->MajorFunction[IRP_MJ_PNP]                      = (PDRIVER_DISPATCH)drv_pnp;
-#endif
 
     init_fast_io_dispatch(&DriverObject->FastIoDispatch);
 
@@ -5722,7 +5928,7 @@ NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING Regi
     dosdevice_nameW.Length = dosdevice_nameW.MaximumLength = sizeof(dosdevice_name) - sizeof(WCHAR);
 
     Status = IoCreateDevice(DriverObject, sizeof(control_device_extension), &device_nameW, FILE_DEVICE_DISK_FILE_SYSTEM,
-                            FILE_DEVICE_SECURE_OPEN, FALSE, &DeviceObject);
+                            FILE_DEVICE_SECURE_OPEN, false, &DeviceObject);
     if (!NT_SUCCESS(Status)) {
         ERR("IoCreateDevice returned %08x\n", Status);
         return Status;
@@ -5771,26 +5977,39 @@ NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING Regi
     }
 #endif
 
+    Status = IoCreateDevice(DriverObject, sizeof(bus_device_extension), NULL, FILE_DEVICE_UNKNOWN,
+                            FILE_DEVICE_SECURE_OPEN, false, &busobj);
+    if (!NT_SUCCESS(Status)) {
+        ERR("IoCreateDevice returned %08x\n", Status);
+        return Status;
+    }
+
+    bde = (bus_device_extension*)busobj->DeviceExtension;
+
+    RtlZeroMemory(bde, sizeof(bus_device_extension));
+
+    bde->type = VCB_TYPE_BUS;
+
     Status = IoReportDetectedDevice(drvobj, InterfaceTypeUndefined, 0xFFFFFFFF, 0xFFFFFFFF,
-                                    NULL, NULL, 0, &cde->buspdo);
+                                    NULL, NULL, 0, &bde->buspdo);
     if (!NT_SUCCESS(Status)) {
         ERR("IoReportDetectedDevice returned %08x\n", Status);
         return Status;
     }
 
-    Status = IoRegisterDeviceInterface(cde->buspdo, &BtrfsBusInterface, NULL, &cde->bus_name);
+    Status = IoRegisterDeviceInterface(bde->buspdo, &BtrfsBusInterface, NULL, &bde->bus_name);
     if (!NT_SUCCESS(Status))
         WARN("IoRegisterDeviceInterface returned %08x\n", Status);
 
-    cde->attached_device = IoAttachDeviceToDeviceStack(DeviceObject, cde->buspdo);
+    bde->attached_device = IoAttachDeviceToDeviceStack(busobj, bde->buspdo);
+
+    busobj->Flags &= ~DO_DEVICE_INITIALIZING;
 
-    Status = IoSetDeviceInterfaceState(&cde->bus_name, TRUE);
+    Status = IoSetDeviceInterfaceState(&bde->bus_name, true);
     if (!NT_SUCCESS(Status))
         WARN("IoSetDeviceInterfaceState returned %08x\n", Status);
 
-    DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
-
-    IoInvalidateDeviceRelations(cde->buspdo, BusRelations);
+    IoInvalidateDeviceRelations(bde->buspdo, BusRelations);
 
     Status = PsCreateSystemThread(&degraded_wait_handle, 0, NULL, NULL, NULL, degraded_wait_thread, NULL);
     if (!NT_SUCCESS(Status))
@@ -5811,9 +6030,9 @@ NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING Regi
     if (!NT_SUCCESS(Status))
         ERR("IoRegisterPlugPlayNotification returned %08x\n", Status);
 
-    finished_probing = TRUE;
+    finished_probing = true;
 
-    KeInitializeEvent(&mountmgr_thread_event, NotificationEvent, FALSE);
+    KeInitializeEvent(&mountmgr_thread_event, NotificationEvent, false);
 
 #ifndef __REACTOS__
     Status = PsCreateSystemThread(&mountmgr_thread_handle, 0, NULL, NULL, NULL, mountmgr_thread, NULL);
@@ -5823,5 +6042,7 @@ NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING Regi
 
     IoRegisterFileSystem(DeviceObject);
 
+    IoRegisterBootDriverReinitialization(DriverObject, check_system_root, NULL);
+
     return STATUS_SUCCESS;
 }
diff --git a/drivers/filesystems/btrfs/btrfs.h b/drivers/filesystems/btrfs/btrfs.h
index d0d2c933d42..f55ef82683e 100644
--- a/drivers/filesystems/btrfs/btrfs.h
+++ b/drivers/filesystems/btrfs/btrfs.h
@@ -6,10 +6,11 @@
  * you want with it. You don't have to, but I'd appreciate if you let me know if you
  * use it anything cool - mark@harmstone.com. */
 
-#ifndef BTRFS_H_DEFINED
-#define BTRFS_H_DEFINED
+#pragma once
 
-static const UINT64 superblock_addrs[] = { 0x10000, 0x4000000, 0x4000000000, 0x4000000000000, 0 };
+#include <stdint.h>
+
+static const uint64_t superblock_addrs[] = { 0x10000, 0x4000000, 0x4000000000, 0x4000000000000, 0 };
 
 #define BTRFS_MAGIC         0x4d5f53665248425f
 #define MAX_LABEL_SIZE      0x100
@@ -119,13 +120,13 @@ static const UINT64 superblock_addrs[] = { 0x10000, 0x4000000, 0x4000000000, 0x4
 #pragma pack(push, 1)
 
 typedef struct {
-    UINT8 uuid[16];
+    uint8_t uuid[16];
 } BTRFS_UUID;
 
 typedef struct {
-    UINT64 obj_id;
-    UINT8 obj_type;
-    UINT64 offset;
+    uint64_t obj_id;
+    uint8_t obj_type;
+    uint64_t offset;
 } KEY;
 
 #define HEADER_FLAG_WRITTEN         0x000000000000001
@@ -133,42 +134,42 @@ typedef struct {
 #define HEADER_FLAG_MIXED_BACKREF   0x100000000000000
 
 typedef struct {
-    UINT8 csum[32];
+    uint8_t csum[32];
     BTRFS_UUID fs_uuid;
-    UINT64 address;
-    UINT64 flags;
+    uint64_t address;
+    uint64_t flags;
     BTRFS_UUID chunk_tree_uuid;
-    UINT64 generation;
-    UINT64 tree_id;
-    UINT32 num_items;
-    UINT8 level;
+    uint64_t generation;
+    uint64_t tree_id;
+    uint32_t num_items;
+    uint8_t level;
 } tree_header;
 
 typedef struct {
     KEY key;
-    UINT32 offset;
-    UINT32 size;
+    uint32_t offset;
+    uint32_t size;
 } leaf_node;
 
 typedef struct {
     KEY key;
-    UINT64 address;
-    UINT64 generation;
+    uint64_t address;
+    uint64_t generation;
 } internal_node;
 
 typedef struct {
-    UINT64 dev_id;
-    UINT64 num_bytes;
-    UINT64 bytes_used;
-    UINT32 optimal_io_align;
-    UINT32 optimal_io_width;
-    UINT32 minimal_io_size;
-    UINT64 type;
-    UINT64 generation;
-    UINT64 start_offset;
-    UINT32 dev_group;
-    UINT8 seek_speed;
-    UINT8 bandwidth;
+    uint64_t dev_id;
+    uint64_t num_bytes;
+    uint64_t bytes_used;
+    uint32_t optimal_io_align;
+    uint32_t optimal_io_width;
+    uint32_t minimal_io_size;
+    uint64_t type;
+    uint64_t generation;
+    uint64_t start_offset;
+    uint32_t dev_group;
+    uint8_t seek_speed;
+    uint8_t bandwidth;
     BTRFS_UUID device_uuid;
     BTRFS_UUID fs_uuid;
 } DEV_ITEM;
@@ -177,67 +178,67 @@ typedef struct {
 #define BTRFS_NUM_BACKUP_ROOTS 4
 
 typedef struct {
-    UINT64 root_tree_addr;
-    UINT64 root_tree_generation;
-    UINT64 chunk_tree_addr;
-    UINT64 chunk_tree_generation;
-    UINT64 extent_tree_addr;
-    UINT64 extent_tree_generation;
-    UINT64 fs_tree_addr;
-    UINT64 fs_tree_generation;
-    UINT64 dev_root_addr;
-    UINT64 dev_root_generation;
-    UINT64 csum_root_addr;
-    UINT64 csum_root_generation;
-    UINT64 total_bytes;
-    UINT64 bytes_used;
-    UINT64 num_devices;
-    UINT64 reserved[4];
-    UINT8 root_level;
-    UINT8 chunk_root_level;
-    UINT8 extent_root_level;
-    UINT8 fs_root_level;
-    UINT8 dev_root_level;
-    UINT8 csum_root_level;
-    UINT8 reserved2[10];
+    uint64_t root_tree_addr;
+    uint64_t root_tree_generation;
+    uint64_t chunk_tree_addr;
+    uint64_t chunk_tree_generation;
+    uint64_t extent_tree_addr;
+    uint64_t extent_tree_generation;
+    uint64_t fs_tree_addr;
+    uint64_t fs_tree_generation;
+    uint64_t dev_root_addr;
+    uint64_t dev_root_generation;
+    uint64_t csum_root_addr;
+    uint64_t csum_root_generation;
+    uint64_t total_bytes;
+    uint64_t bytes_used;
+    uint64_t num_devices;
+    uint64_t reserved[4];
+    uint8_t root_level;
+    uint8_t chunk_root_level;
+    uint8_t extent_root_level;
+    uint8_t fs_root_level;
+    uint8_t dev_root_level;
+    uint8_t csum_root_level;
+    uint8_t reserved2[10];
 } superblock_backup;
 
 typedef struct {
-    UINT8 checksum[32];
+    uint8_t checksum[32];
     BTRFS_UUID uuid;
-    UINT64 sb_phys_addr;
-    UINT64 flags;
-    UINT64 magic;
-    UINT64 generation;
-    UINT64 root_tree_addr;
-    UINT64 chunk_tree_addr;
-    UINT64 log_tree_addr;
-    UINT64 log_root_transid;
-    UINT64 total_bytes;
-    UINT64 bytes_used;
-    UINT64 root_dir_objectid;
-    UINT64 num_devices;
-    UINT32 sector_size;
-    UINT32 node_size;
-    UINT32 leaf_size;
-    UINT32 stripe_size;
-    UINT32 n;
-    UINT64 chunk_root_generation;
-    UINT64 compat_flags;
-    UINT64 compat_ro_flags;
-    UINT64 incompat_flags;
-    UINT16 csum_type;
-    UINT8 root_level;
-    UINT8 chunk_root_level;
-    UINT8 log_root_level;
+    uint64_t sb_phys_addr;
+    uint64_t flags;
+    uint64_t magic;
+    uint64_t generation;
+    uint64_t root_tree_addr;
+    uint64_t chunk_tree_addr;
+    uint64_t log_tree_addr;
+    uint64_t log_root_transid;
+    uint64_t total_bytes;
+    uint64_t bytes_used;
+    uint64_t root_dir_objectid;
+    uint64_t num_devices;
+    uint32_t sector_size;
+    uint32_t node_size;
+    uint32_t leaf_size;
+    uint32_t stripe_size;
+    uint32_t n;
+    uint64_t chunk_root_generation;
+    uint64_t compat_flags;
+    uint64_t compat_ro_flags;
+    uint64_t incompat_flags;
+    uint16_t csum_type;
+    uint8_t root_level;
+    uint8_t chunk_root_level;
+    uint8_t log_root_level;
     DEV_ITEM dev_item;
     char label[MAX_LABEL_SIZE];
-    UINT64 cache_generation;
-    UINT64 uuid_tree_generation;
-    UINT64 reserved[30];
-    UINT8 sys_chunk_array[SYS_CHUNK_ARRAY_SIZE];
+    uint64_t cache_generation;
+    uint64_t uuid_tree_generation;
+    uint64_t reserved[30];
+    uint8_t sys_chunk_array[SYS_CHUNK_ARRAY_SIZE];
     superblock_backup backup[BTRFS_NUM_BACKUP_ROOTS];
-    UINT8 reserved2[565];
+    uint8_t reserved2[565];
 } superblock;
 
 #define BTRFS_TYPE_UNKNOWN   0
@@ -252,32 +253,32 @@ typedef struct {
 
 typedef struct {
     KEY key;
-    UINT64 transid;
-    UINT16 m;
-    UINT16 n;
-    UINT8 type;
+    uint64_t transid;
+    uint16_t m;
+    uint16_t n;
+    uint8_t type;
     char name[1];
 } DIR_ITEM;
 
 typedef struct {
-    UINT64 seconds;
-    UINT32 nanoseconds;
+    uint64_t seconds;
+    uint32_t nanoseconds;
 } BTRFS_TIME;
 
 typedef struct {
-    UINT64 generation;
-    UINT64 transid;
-    UINT64 st_size;
-    UINT64 st_blocks;
-    UINT64 block_group;
-    UINT32 st_nlink;
-    UINT32 st_uid;
-    UINT32 st_gid;
-    UINT32 st_mode;
-    UINT64 st_rdev;
-    UINT64 flags;
-    UINT64 sequence;
-    UINT8 reserved[32];
+    uint64_t generation;
+    uint64_t transid;
+    uint64_t st_size;
+    uint64_t st_blocks;
+    uint64_t block_group;
+    uint32_t st_nlink;
+    uint32_t st_uid;
+    uint32_t st_gid;
+    uint32_t st_mode;
+    uint64_t st_rdev;
+    uint64_t flags;
+    uint64_t sequence;
+    uint8_t reserved[32];
     BTRFS_TIME st_atime;
     BTRFS_TIME st_ctime;
     BTRFS_TIME st_mtime;
@@ -286,77 +287,77 @@ typedef struct {
 
 typedef struct {
     INODE_ITEM inode;
-    UINT64 generation;
-    UINT64 objid;
-    UINT64 block_number;
-    UINT64 byte_limit;
-    UINT64 bytes_used;
-    UINT64 last_snapshot_generation;
-    UINT64 flags;
-    UINT32 num_references;
+    uint64_t generation;
+    uint64_t objid;
+    uint64_t block_number;
+    uint64_t byte_limit;
+    uint64_t bytes_used;
+    uint64_t last_snapshot_generation;
+    uint64_t flags;
+    uint32_t num_references;
     KEY drop_progress;
-    UINT8 drop_level;
-    UINT8 root_level;
-    UINT64 generation2;
+    uint8_t drop_level;
+    uint8_t root_level;
+    uint64_t generation2;
     BTRFS_UUID uuid;
     BTRFS_UUID parent_uuid;
     BTRFS_UUID received_uuid;
-    UINT64 ctransid;
-    UINT64 otransid;
-    UINT64 stransid;
-    UINT64 rtransid;
+    uint64_t ctransid;
+    uint64_t otransid;
+    uint64_t stransid;
+    uint64_t rtransid;
     BTRFS_TIME ctime;
     BTRFS_TIME otime;
     BTRFS_TIME stime;
     BTRFS_TIME rtime;
-    UINT64 reserved[8];
+    uint64_t reserved[8];
 } ROOT_ITEM;
 
 typedef struct {
-    UINT64 size;
-    UINT64 root_id;
-    UINT64 stripe_length;
-    UINT64 type;
-    UINT32 opt_io_alignment;
-    UINT32 opt_io_width;
-    UINT32 sector_size;
-    UINT16 num_stripes;
-    UINT16 sub_stripes;
+    uint64_t size;
+    uint64_t root_id;
+    uint64_t stripe_length;
+    uint64_t type;
+    uint32_t opt_io_alignment;
+    uint32_t opt_io_width;
+    uint32_t sector_size;
+    uint16_t num_stripes;
+    uint16_t sub_stripes;
 } CHUNK_ITEM;
 
 typedef struct {
-    UINT64 dev_id;
-    UINT64 offset;
+    uint64_t dev_id;
+    uint64_t offset;
     BTRFS_UUID dev_uuid;
 } CHUNK_ITEM_STRIPE;
 
 typedef struct {
-    UINT64 generation;
-    UINT64 decoded_size;
-    UINT8 compression;
-    UINT8 encryption;
-    UINT16 encoding;
-    UINT8 type;
-    UINT8 data[1];
+    uint64_t generation;
+    uint64_t decoded_size;
+    uint8_t compression;
+    uint8_t encryption;
+    uint16_t encoding;
+    uint8_t type;
+    uint8_t data[1];
 } EXTENT_DATA;
 
 typedef struct {
-    UINT64 address;
-    UINT64 size;
-    UINT64 offset;
-    UINT64 num_bytes;
+    uint64_t address;
+    uint64_t size;
+    uint64_t offset;
+    uint64_t num_bytes;
 } EXTENT_DATA2;
 
 typedef struct {
-    UINT64 index;
-    UINT16 n;
+    uint64_t index;
+    uint16_t n;
     char name[1];
 } INODE_REF;
 
 typedef struct {
-    UINT64 dir;
-    UINT64 index;
-    UINT16 n;
+    uint64_t dir;
+    uint64_t index;
+    uint16_t n;
     char name[1];
 } INODE_EXTREF;
 
@@ -365,87 +366,87 @@ typedef struct {
 #define EXTENT_ITEM_SHARED_BACKREFS 0x100
 
 typedef struct {
-    UINT64 refcount;
-    UINT64 generation;
-    UINT64 flags;
+    uint64_t refcount;
+    uint64_t generation;
+    uint64_t flags;
 } EXTENT_ITEM;
 
 typedef struct {
     KEY firstitem;
-    UINT8 level;
+    uint8_t level;
 } EXTENT_ITEM2;
 
 typedef struct {
-    UINT32 refcount;
+    uint32_t refcount;
 } EXTENT_ITEM_V0;
 
 typedef struct {
     EXTENT_ITEM extent_item;
     KEY firstitem;
-    UINT8 level;
+    uint8_t level;
 } EXTENT_ITEM_TREE;
 
 typedef struct {
-    UINT64 offset;
+    uint64_t offset;
 } TREE_BLOCK_REF;
 
 typedef struct {
-    UINT64 root;
-    UINT64 objid;
-    UINT64 offset;
-    UINT32 count;
+    uint64_t root;
+    uint64_t objid;
+    uint64_t offset;
+    uint32_t count;
 } EXTENT_DATA_REF;
 
 typedef struct {
-    UINT64 used;
-    UINT64 chunk_tree;
-    UINT64 flags;
+    uint64_t used;
+    uint64_t chunk_tree;
+    uint64_t flags;
 } BLOCK_GROUP_ITEM;
 
 typedef struct {
-    UINT64 root;
-    UINT64 gen;
-    UINT64 objid;
-    UINT32 count;
+    uint64_t root;
+    uint64_t gen;
+    uint64_t objid;
+    uint32_t count;
 } EXTENT_REF_V0;
 
 typedef struct {
-    UINT64 offset;
+    uint64_t offset;
 } SHARED_BLOCK_REF;
 
 typedef struct {
-    UINT64 offset;
-    UINT32 count;
+    uint64_t offset;
+    uint32_t count;
 } SHARED_DATA_REF;
 
 #define FREE_SPACE_EXTENT 1
 #define FREE_SPACE_BITMAP 2
 
 typedef struct {
-    UINT64 offset;
-    UINT64 size;
-    UINT8 type;
+    uint64_t offset;
+    uint64_t size;
+    uint8_t type;
 } FREE_SPACE_ENTRY;
 
 typedef struct {
     KEY key;
-    UINT64 generation;
-    UINT64 num_entries;
-    UINT64 num_bitmaps;
+    uint64_t generation;
+    uint64_t num_entries;
+    uint64_t num_bitmaps;
 } FREE_SPACE_ITEM;
 
 typedef struct {
-    UINT64 dir;
-    UINT64 index;
-    UINT16 n;
+    uint64_t dir;
+    uint64_t index;
+    uint16_t n;
     char name[1];
 } ROOT_REF;
 
 typedef struct {
-    UINT64 chunktree;
-    UINT64 objid;
-    UINT64 address;
-    UINT64 length;
+    uint64_t chunktree;
+    uint64_t objid;
+    uint64_t address;
+    uint64_t length;
     BTRFS_UUID chunktree_uuid;
 } DEV_EXTENT;
 
@@ -466,50 +467,50 @@ typedef struct {
 #define BALANCE_ARGS_FLAGS_USAGE_RANGE      0x400
 
 typedef struct {
-    UINT64 profiles;
+    uint64_t profiles;
 
     union {
-            UINT64 usage;
+            uint64_t usage;
             struct {
-                    UINT32 usage_start;
-                    UINT32 usage_end;
+                    uint32_t usage_start;
+                    uint32_t usage_end;
             };
     };
 
-    UINT64 devid;
-    UINT64 drange_start;
-    UINT64 drange_end;
-    UINT64 vrange_start;
-    UINT64 vrange_end;
-    UINT64 convert;
-    UINT64 flags;
+    uint64_t devid;
+    uint64_t drange_start;
+    uint64_t drange_end;
+    uint64_t vrange_start;
+    uint64_t vrange_end;
+    uint64_t convert;
+    uint64_t flags;
 
     union {
-            UINT64 limit;
+            uint64_t limit;
             struct {
-                    UINT32 limit_start;
-                    UINT32 limit_end;
+                    uint32_t limit_start;
+                    uint32_t limit_end;
             };
     };
 
-    UINT32 stripes_start;
-    UINT32 stripes_end;
-    UINT8 reserved[48];
+    uint32_t stripes_start;
+    uint32_t stripes_end;
+    uint8_t reserved[48];
 } BALANCE_ARGS;
 
 typedef struct {
-    UINT64 flags;
+    uint64_t flags;
     BALANCE_ARGS data;
     BALANCE_ARGS metadata;
     BALANCE_ARGS system;
-    UINT8 reserved[32];
+    uint8_t reserved[32];
 } BALANCE_ITEM;
 
 #define BTRFS_FREE_SPACE_USING_BITMAPS      1
 
 typedef struct {
-    UINT32 count;
-    UINT32 flags;
+    uint32_t count;
+    uint32_t flags;
 } FREE_SPACE_INFO;
 
 #define BTRFS_DEV_STAT_WRITE_ERRORS          0
@@ -569,21 +570,19 @@ typedef struct {
 #define BTRFS_SEND_MAGIC "btrfs-stream"
 
 typedef struct {
-    UINT8 magic[13];
-    UINT32 version;
+    uint8_t magic[13];
+    uint32_t version;
 } btrfs_send_header;
 
 typedef struct {
-    UINT32 length;
-    UINT16 cmd;
-    UINT32 csum;
+    uint32_t length;
+    uint16_t cmd;
+    uint32_t csum;
 } btrfs_send_command;
 
 typedef struct {
-    UINT16 type;
-    UINT16 length;
+    uint16_t type;
+    uint16_t length;
 } btrfs_send_tlv;
 
 #pragma pack(pop)
-
-#endif
diff --git a/drivers/filesystems/btrfs/btrfs.rc b/drivers/filesystems/btrfs/btrfs.rc
index da8380e5562..c899d599b5d 100644
--- a/drivers/filesystems/btrfs/btrfs.rc
+++ b/drivers/filesystems/btrfs/btrfs.rc
@@ -51,8 +51,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,3,0,0
- PRODUCTVERSION 1,3,0,0
+ FILEVERSION 1,4,0,0
+ PRODUCTVERSION 1,4,0,0
  FILEFLAGSMASK 0x17L
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -68,12 +68,12 @@ BEGIN
         BLOCK "080904b0"
         BEGIN
             VALUE "FileDescription", "WinBtrfs"
-            VALUE "FileVersion", "1.3"
+            VALUE "FileVersion", "1.4"
             VALUE "InternalName", "btrfs"
             VALUE "LegalCopyright", "Copyright (c) Mark Harmstone 2016-19"
             VALUE "OriginalFilename", "btrfs.sys"
             VALUE "ProductName", "WinBtrfs"
-            VALUE "ProductVersion", "1.3"
+            VALUE "ProductVersion", "1.4"
         END
     END
     BLOCK "VarFileInfo"
diff --git a/drivers/filesystems/btrfs/btrfs_drv.h b/drivers/filesystems/btrfs/btrfs_drv.h
index 9439bd49e93..d8397367515 100644
--- a/drivers/filesystems/btrfs/btrfs_drv.h
+++ b/drivers/filesystems/btrfs/btrfs_drv.h
@@ -15,8 +15,7 @@
  * You should have received a copy of the GNU Lesser General Public Licence
  * along with WinBtrfs.  If not, see <http://www.gnu.org/licenses/>. */
 
-#ifndef BTRFS_DRV_H_DEFINED
-#define BTRFS_DRV_H_DEFINED
+#pragma once
 
 #ifndef __REACTOS__
 #undef _WIN32_WINNT
@@ -62,6 +61,8 @@
 #include <stdio.h>
 #include <stdarg.h>
 #include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
 #ifndef __REACTOS__
 // Not actually used
 #include <emmintrin.h>
@@ -73,8 +74,8 @@
 // #define DEBUG_FCB_REFCOUNTS
 // #define DEBUG_LONG_MESSAGES
 // #define DEBUG_FLUSH_TIMES
-// #define DEBUG_STATS
 // #define DEBUG_CHUNK_LOCKS
+// #define DEBUG_TRIM_EMULATION
 #define DEBUG_PARANOID
 #endif
 
@@ -143,9 +144,11 @@
 #define FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL 0x00020000
 #endif
 
+#ifndef _MSC_VER
 typedef struct _FILE_ID_128 {
     UCHAR Identifier[16];
 } FILE_ID_128, *PFILE_ID_128;
+#endif
 
 typedef struct _DUPLICATE_EXTENTS_DATA {
     HANDLE FileHandle;
@@ -210,12 +213,12 @@ typedef struct _fcb_nonpaged {
 struct _root;
 
 typedef struct {
-    UINT64 offset;
-    UINT16 datalen;
-    BOOL unique;
-    BOOL ignore;
-    BOOL inserted;
-    UINT32* csum;
+    uint64_t offset;
+    uint16_t datalen;
+    bool unique;
+    bool ignore;
+    bool inserted;
+    uint32_t* csum;
 
     LIST_ENTRY list_entry;
 
@@ -223,8 +226,8 @@ typedef struct {
 } extent;
 
 typedef struct {
-    UINT64 parent;
-    UINT64 index;
+    uint64_t parent;
+    uint64_t index;
     UNICODE_STRING name;
     ANSI_STRING utf8;
     LIST_ENTRY list_entry;
@@ -234,12 +237,12 @@ struct _file_ref;
 
 typedef struct {
     KEY key;
-    UINT64 index;
-    UINT8 type;
+    uint64_t index;
+    uint8_t type;
     ANSI_STRING utf8;
-    UINT32 hash;
+    uint32_t hash;
     UNICODE_STRING name;
-    UINT32 hash_uc;
+    uint32_t hash_uc;
     UNICODE_STRING name_uc;
     ULONG size;
     struct _file_ref* fileref;
@@ -259,7 +262,7 @@ typedef struct {
     LIST_ENTRY list_entry;
     USHORT namelen;
     USHORT valuelen;
-    BOOL dirty;
+    bool dirty;
     char data[1];
 } xattr;
 
@@ -270,30 +273,30 @@ typedef struct _fcb {
     POOL_TYPE pool_type;
     struct _device_extension* Vcb;
     struct _root* subvol;
-    UINT64 inode;
-    UINT32 hash;
-    UINT8 type;
+    uint64_t inode;
+    uint32_t hash;
+    uint8_t type;
     INODE_ITEM inode_item;
     SECURITY_DESCRIPTOR* sd;
     FILE_LOCK lock;
-    BOOL deleted;
+    bool deleted;
     PKTHREAD lazy_writer_thread;
     ULONG atts;
     SHARE_ACCESS share_access;
     WCHAR* debug_desc;
-    BOOL csum_loaded;
+    bool csum_loaded;
     LIST_ENTRY extents;
     ANSI_STRING reparse_xattr;
     ANSI_STRING ea_xattr;
     ULONG ealen;
     LIST_ENTRY hardlinks;
     struct _file_ref* fileref;
-    BOOL inode_item_changed;
+    bool inode_item_changed;
     enum prop_compression_type prop_compression;
     LIST_ENTRY xattrs;
-    BOOL marked_as_orphan;
-    BOOL case_sensitive;
-    BOOL case_sensitive_set;
+    bool marked_as_orphan;
+    bool case_sensitive;
+    bool case_sensitive_set;
 
     LIST_ENTRY dir_children_index;
     LIST_ENTRY dir_children_hash;
@@ -301,18 +304,18 @@ typedef struct _fcb {
     LIST_ENTRY** hash_ptrs;
     LIST_ENTRY** hash_ptrs_uc;
 
-    BOOL dirty;
-    BOOL sd_dirty, sd_deleted;
-    BOOL atts_changed, atts_deleted;
-    BOOL extents_changed;
-    BOOL reparse_xattr_changed;
-    BOOL ea_changed;
-    BOOL prop_compression_changed;
-    BOOL xattrs_changed;
-    BOOL created;
-
-    BOOL ads;
-    UINT32 adshash;
+    bool dirty;
+    bool sd_dirty, sd_deleted;
+    bool atts_changed, atts_deleted;
+    bool extents_changed;
+    bool reparse_xattr_changed;
+    bool ea_changed;
+    bool prop_compression_changed;
+    bool xattrs_changed;
+    bool created;
+
+    bool ads;
+    uint32_t adshash;
     ULONG adsmaxlen;
     ANSI_STRING adsxattr;
     ANSI_STRING adsdata;
@@ -329,11 +332,11 @@ typedef struct {
 typedef struct _file_ref {
     fcb* fcb;
     ANSI_STRING oldutf8;
-    UINT64 oldindex;
-    BOOL delete_on_close;
-    BOOL posix_delete;
-    BOOL deleted;
-    BOOL created;
+    uint64_t oldindex;
+    bool delete_on_close;
+    bool posix_delete;
+    bool deleted;
+    bool created;
     file_ref_nonpaged* nonpaged;
     LIST_ENTRY children;
     LONG refcount;
@@ -342,7 +345,7 @@ typedef struct _file_ref {
     WCHAR* debug_desc;
     dir_child* dc;
 
-    BOOL dirty;
+    bool dirty;
 
     LIST_ENTRY list_entry;
     LIST_ENTRY list_entry_dirty;
@@ -353,7 +356,7 @@ typedef struct {
     struct _ccb* ccb;
     void* context;
     KEVENT cleared_event;
-    BOOL cancelling;
+    bool cancelling;
     LIST_ENTRY list_entry;
 } send_info;
 
@@ -362,23 +365,23 @@ typedef struct _ccb {
     CSHORT NodeSize;
     ULONG disposition;
     ULONG options;
-    UINT64 query_dir_offset;
+    uint64_t query_dir_offset;
     UNICODE_STRING query_string;
-    BOOL has_wildcard;
-    BOOL specific_file;
-    BOOL manage_volume_privilege;
-    BOOL allow_extended_dasd_io;
-    BOOL reserving;
+    bool has_wildcard;
+    bool specific_file;
+    bool manage_volume_privilege;
+    bool allow_extended_dasd_io;
+    bool reserving;
     ACCESS_MASK access;
     file_ref* fileref;
     UNICODE_STRING filename;
     ULONG ea_index;
-    BOOL case_sensitive;
-    BOOL user_set_creation_time;
-    BOOL user_set_access_time;
-    BOOL user_set_write_time;
-    BOOL user_set_change_time;
-    BOOL lxss;
+    bool case_sensitive;
+    bool user_set_creation_time;
+    bool user_set_access_time;
+    bool user_set_write_time;
+    bool user_set_change_time;
+    bool lxss;
     send_info* send;
     NTSTATUS send_status;
 } ccb;
@@ -386,23 +389,23 @@ typedef struct _ccb {
 struct _device_extension;
 
 typedef struct {
-    UINT64 address;
-    UINT64 generation;
+    uint64_t address;
+    uint64_t generation;
     struct _tree* tree;
 } tree_holder;
 
 typedef struct _tree_data {
     KEY key;
     LIST_ENTRY list_entry;
-    BOOL ignore;
-    BOOL inserted;
+    bool ignore;
+    bool inserted;
 
     union {
         tree_holder treeholder;
 
         struct {
-            UINT16 size;
-            UINT8* data;
+            uint16_t size;
+            uint8_t* data;
         };
     };
 } tree_data;
@@ -414,9 +417,9 @@ typedef struct {
 typedef struct _tree {
     tree_nonpaged* nonpaged;
     tree_header header;
-    UINT32 hash;
-    BOOL has_address;
-    UINT32 size;
+    uint32_t hash;
+    bool has_address;
+    uint32_t size;
     struct _device_extension* Vcb;
     struct _tree* parent;
     tree_data* paritem;
@@ -424,13 +427,13 @@ typedef struct _tree {
     LIST_ENTRY itemlist;
     LIST_ENTRY list_entry;
     LIST_ENTRY list_entry_hash;
-    UINT64 new_address;
-    BOOL has_new_address;
-    BOOL updated_extents;
-    BOOL write;
-    BOOL is_unique;
-    BOOL uniqueness_determined;
-    UINT8* buf;
+    uint64_t new_address;
+    bool has_new_address;
+    bool updated_extents;
+    bool write;
+    bool is_unique;
+    bool uniqueness_determined;
+    uint8_t* buf;
 } tree;
 
 typedef struct {
@@ -438,18 +441,18 @@ typedef struct {
 } root_nonpaged;
 
 typedef struct _root {
-    UINT64 id;
+    uint64_t id;
     LONGLONG lastinode; // signed so we can use InterlockedIncrement64
     tree_holder treeholder;
     root_nonpaged* nonpaged;
     ROOT_ITEM root_item;
-    BOOL dirty;
-    BOOL received;
+    bool dirty;
+    bool received;
     PEPROCESS reserved;
-    UINT64 parent;
+    uint64_t parent;
     LONG send_ops;
-    UINT64 fcbs_version;
-    BOOL checked_for_orphans;
+    uint64_t fcbs_version;
+    bool checked_for_orphans;
     LIST_ENTRY fcbs;
     LIST_ENTRY* fcbs_ptrs[256];
     LIST_ENTRY list_entry;
@@ -475,7 +478,7 @@ enum batch_operation {
 typedef struct {
     KEY key;
     void* data;
-    UINT16 datalen;
+    uint16_t datalen;
     enum batch_operation operation;
     LIST_ENTRY list_entry;
 } batch_item;
@@ -497,26 +500,27 @@ typedef struct _root_cache {
 } root_cache;
 
 typedef struct {
-    UINT64 address;
-    UINT64 size;
+    uint64_t address;
+    uint64_t size;
     LIST_ENTRY list_entry;
     LIST_ENTRY list_entry_size;
 } space;
 
 typedef struct {
     PDEVICE_OBJECT devobj;
+    PFILE_OBJECT fileobj;
     DEV_ITEM devitem;
-    BOOL removable;
-    BOOL seeding;
-    BOOL readonly;
-    BOOL reloc;
-    BOOL trim;
-    BOOL can_flush;
+    bool removable;
+    bool seeding;
+    bool readonly;
+    bool reloc;
+    bool trim;
+    bool can_flush;
     ULONG change_count;
     ULONG disk_num;
     ULONG part_num;
-    UINT64 stats[5];
-    BOOL stats_changed;
+    uint64_t stats[5];
+    bool stats_changed;
     LIST_ENTRY space;
     LIST_ENTRY list_entry;
     ULONG num_trim_entries;
@@ -524,26 +528,27 @@ typedef struct {
 } device;
 
 typedef struct {
-    UINT64 start;
-    UINT64 length;
+    uint64_t start;
+    uint64_t length;
     PETHREAD thread;
     LIST_ENTRY list_entry;
 } range_lock;
 
 typedef struct {
-    UINT64 address;
+    uint64_t address;
     ULONG* bmparr;
+    ULONG bmplen;
     RTL_BITMAP bmp;
     LIST_ENTRY list_entry;
-    UINT8 data[1];
+    uint8_t data[1];
 } partial_stripe;
 
 typedef struct {
     CHUNK_ITEM* chunk_item;
-    UINT16 size;
-    UINT64 offset;
-    UINT64 used;
-    UINT64 oldused;
+    uint16_t size;
+    uint64_t offset;
+    uint64_t used;
+    uint64_t oldused;
     device** devices;
     fcb* cache;
     fcb* old_cache;
@@ -556,15 +561,15 @@ typedef struct {
     KEVENT range_locks_event;
     ERESOURCE lock;
     ERESOURCE changed_extents_lock;
-    BOOL created;
-    BOOL readonly;
-    BOOL reloc;
-    BOOL last_alloc_set;
-    BOOL cache_loaded;
-    BOOL changed;
-    BOOL space_changed;
-    UINT64 last_alloc;
-    UINT16 last_stripe;
+    bool created;
+    bool readonly;
+    bool reloc;
+    bool last_alloc_set;
+    bool cache_loaded;
+    bool changed;
+    bool space_changed;
+    uint64_t last_alloc;
+    uint16_t last_stripe;
     LIST_ENTRY partial_stripes;
     ERESOURCE partial_stripes_lock;
     ULONG balance_num;
@@ -574,20 +579,20 @@ typedef struct {
 } chunk;
 
 typedef struct {
-    UINT64 address;
-    UINT64 size;
-    UINT64 old_size;
-    UINT64 count;
-    UINT64 old_count;
-    BOOL no_csum;
-    BOOL superseded;
+    uint64_t address;
+    uint64_t size;
+    uint64_t old_size;
+    uint64_t count;
+    uint64_t old_count;
+    bool no_csum;
+    bool superseded;
     LIST_ENTRY refs;
     LIST_ENTRY old_refs;
     LIST_ENTRY list_entry;
 } changed_extent;
 
 typedef struct {
-    UINT8 type;
+    uint8_t type;
 
     union {
         EXTENT_DATA_REF edr;
@@ -605,9 +610,9 @@ typedef struct {
 } sys_chunk;
 
 typedef struct {
-    UINT8* data;
-    UINT32* csum;
-    UINT32 sectors;
+    uint8_t* data;
+    uint32_t* csum;
+    uint32_t sectors;
     LONG pos, done;
     KEVENT event;
     LONG refcount;
@@ -618,7 +623,7 @@ typedef struct {
     PDEVICE_OBJECT DeviceObject;
     HANDLE handle;
     KEVENT finished;
-    BOOL quit;
+    bool quit;
 } drv_calc_thread;
 
 typedef struct {
@@ -630,49 +635,28 @@ typedef struct {
 } drv_calc_threads;
 
 typedef struct {
-    BOOL ignore;
-    BOOL compress;
-    BOOL compress_force;
-    UINT8 compress_type;
-    BOOL readonly;
-    UINT32 zlib_level;
-    UINT32 zstd_level;
-    UINT32 flush_interval;
-    UINT32 max_inline;
-    UINT64 subvol_id;
-    BOOL skip_balance;
-    BOOL no_barrier;
-    BOOL no_trim;
-    BOOL clear_cache;
-    BOOL allow_degraded;
+    bool ignore;
+    bool compress;
+    bool compress_force;
+    uint8_t compress_type;
+    bool readonly;
+    uint32_t zlib_level;
+    uint32_t zstd_level;
+    uint32_t flush_interval;
+    uint32_t max_inline;
+    uint64_t subvol_id;
+    bool skip_balance;
+    bool no_barrier;
+    bool no_trim;
+    bool clear_cache;
+    bool allow_degraded;
 } mount_options;
 
 #define VCB_TYPE_FS         1
 #define VCB_TYPE_CONTROL    2
 #define VCB_TYPE_VOLUME     3
 #define VCB_TYPE_PDO        4
-
-#ifdef DEBUG_STATS
-typedef struct {
-    UINT64 num_reads;
-    UINT64 data_read;
-    UINT64 read_total_time;
-    UINT64 read_csum_time;
-    UINT64 read_disk_time;
-
-    UINT64 num_opens;
-    UINT64 open_total_time;
-    UINT64 num_overwrites;
-    UINT64 overwrite_total_time;
-    UINT64 num_creates;
-    UINT64 create_total_time;
-    UINT64 open_fcb_calls;
-    UINT64 open_fcb_time;
-    UINT64 open_fileref_child_calls;
-    UINT64 open_fileref_child_time;
-    UINT64 fcb_lock_time;
-} debug_stats;
-#endif
+#define VCB_TYPE_BUS        5
 
 #define BALANCE_OPTS_DATA       0
 #define BALANCE_OPTS_METADATA   1
@@ -680,14 +664,14 @@ typedef struct {
 
 typedef struct {
     HANDLE thread;
-    UINT64 total_chunks;
-    UINT64 chunks_left;
+    uint64_t total_chunks;
+    uint64_t chunks_left;
     btrfs_balance_opts opts[3];
-    BOOL paused;
-    BOOL stopping;
-    BOOL removing;
-    BOOL shrinking;
-    BOOL dev_readonly;
+    bool paused;
+    bool stopping;
+    bool removing;
+    bool shrinking;
+    bool dev_readonly;
     ULONG balance_num;
     NTSTATUS status;
     KEVENT event;
@@ -695,24 +679,24 @@ typedef struct {
 } balance_info;
 
 typedef struct {
-    UINT64 address;
-    UINT64 device;
-    BOOL recovered;
-    BOOL is_metadata;
-    BOOL parity;
+    uint64_t address;
+    uint64_t device;
+    bool recovered;
+    bool is_metadata;
+    bool parity;
     LIST_ENTRY list_entry;
 
     union {
         struct {
-            UINT64 subvol;
-            UINT64 offset;
-            UINT16 filename_length;
+            uint64_t subvol;
+            uint64_t offset;
+            uint16_t filename_length;
             WCHAR filename[1];
         } data;
 
         struct {
-            UINT64 root;
-            UINT8 level;
+            uint64_t root;
+            uint8_t level;
             KEY firstitem;
         } metadata;
     };
@@ -723,15 +707,15 @@ typedef struct {
     ERESOURCE stats_lock;
     KEVENT event;
     KEVENT finished;
-    BOOL stopping;
-    BOOL paused;
+    bool stopping;
+    bool paused;
     LARGE_INTEGER start_time;
     LARGE_INTEGER finish_time;
     LARGE_INTEGER resume_time;
     LARGE_INTEGER duration;
-    UINT64 total_chunks;
-    UINT64 chunks_left;
-    UINT64 data_scrubbed;
+    uint64_t total_chunks;
+    uint64_t chunks_left;
+    uint64_t data_scrubbed;
     NTSTATUS error;
     ULONG num_errors;
     LIST_ENTRY errors;
@@ -740,25 +724,23 @@ typedef struct {
 struct _volume_device_extension;
 
 typedef struct _device_extension {
-    UINT32 type;
+    uint32_t type;
     mount_options options;
     PVPB Vpb;
     struct _volume_device_extension* vde;
     LIST_ENTRY devices;
-#ifdef DEBUG_STATS
-    debug_stats stats;
-#endif
 #ifdef DEBUG_CHUNK_LOCKS
     LONG chunk_locks_held;
 #endif
-    UINT64 devices_loaded;
+    uint64_t devices_loaded;
     superblock superblock;
-    BOOL readonly;
-    BOOL removing;
-    BOOL locked;
-    BOOL lock_paused_balance;
-    BOOL disallow_dismount;
-    BOOL trim;
+    bool readonly;
+    bool removing;
+    bool locked;
+    bool lock_paused_balance;
+    bool disallow_dismount;
+    LONG page_file_count;
+    bool trim;
     PFILE_OBJECT locked_fileobj;
     fcb* volume_fcb;
     fcb* dummy_fcb;
@@ -770,11 +752,11 @@ typedef struct _device_extension {
     _Has_lock_level_(tree_lock) ERESOURCE tree_lock;
     PNOTIFY_SYNC NotifySync;
     LIST_ENTRY DirNotifyList;
-    BOOL need_write;
-    BOOL stats_changed;
-    UINT64 data_flags;
-    UINT64 metadata_flags;
-    UINT64 system_flags;
+    bool need_write;
+    bool stats_changed;
+    uint64_t data_flags;
+    uint64_t metadata_flags;
+    uint64_t system_flags;
     LIST_ENTRY roots;
     LIST_ENTRY drop_roots;
     root* chunk_root;
@@ -785,8 +767,8 @@ typedef struct _device_extension {
     root* uuid_root;
     root* data_reloc_root;
     root* space_root;
-    BOOL log_to_phys_loaded;
-    BOOL chunk_usage_found;
+    bool log_to_phys_loaded;
+    bool chunk_usage_found;
     LIST_ENTRY sys_chunks;
     LIST_ENTRY chunks;
     LIST_ENTRY trees;
@@ -824,22 +806,26 @@ typedef struct _device_extension {
 } device_extension;
 
 typedef struct {
-    UINT32 type;
+    uint32_t type;
+} control_device_extension;
+
+typedef struct {
+    uint32_t type;
     PDEVICE_OBJECT buspdo;
     PDEVICE_OBJECT attached_device;
     UNICODE_STRING bus_name;
-} control_device_extension;
+} bus_device_extension;
 
 typedef struct {
     BTRFS_UUID uuid;
-    UINT64 devid;
-    UINT64 generation;
+    uint64_t devid;
+    uint64_t generation;
     PDEVICE_OBJECT devobj;
     PFILE_OBJECT fileobj;
     UNICODE_STRING pnp_name;
-    UINT64 size;
-    BOOL seeding;
-    BOOL had_drive_letter;
+    uint64_t size;
+    bool seeding;
+    bool had_drive_letter;
     void* notification_entry;
     ULONG disk_num;
     ULONG part_num;
@@ -849,7 +835,7 @@ typedef struct {
 struct pdo_device_extension;
 
 typedef struct _volume_device_extension {
-    UINT32 type;
+    uint32_t type;
     UNICODE_STRING name;
     PDEVICE_OBJECT device;
     PDEVICE_OBJECT mounted_device;
@@ -857,19 +843,19 @@ typedef struct _volume_device_extension {
     struct pdo_device_extension* pdode;
     UNICODE_STRING bus_name;
     PDEVICE_OBJECT attached_device;
-    BOOL removing;
+    bool removing;
     LONG open_count;
 } volume_device_extension;
 
 typedef struct pdo_device_extension {
-    UINT32 type;
+    uint32_t type;
     BTRFS_UUID uuid;
     volume_device_extension* vde;
     PDEVICE_OBJECT pdo;
-    BOOL removable;
+    bool removable;
 
-    UINT64 num_children;
-    UINT64 children_loaded;
+    uint64_t num_children;
+    uint64_t children_loaded;
     ERESOURCE child_lock;
     LIST_ENTRY children;
 
@@ -879,13 +865,13 @@ typedef struct pdo_device_extension {
 typedef struct {
     LIST_ENTRY listentry;
     PSID sid;
-    UINT32 uid;
+    uint32_t uid;
 } uid_map;
 
 typedef struct {
     LIST_ENTRY listentry;
     PSID sid;
-    UINT32 gid;
+    uint32_t gid;
 } gid_map;
 
 enum write_data_status {
@@ -901,7 +887,7 @@ struct _write_data_context;
 
 typedef struct {
     struct _write_data_context* context;
-    UINT8* buf;
+    uint8_t* buf;
     PMDL mdl;
     device* device;
     PIRP Irp;
@@ -914,15 +900,15 @@ typedef struct _write_data_context {
     KEVENT Event;
     LIST_ENTRY stripes;
     LONG stripes_left;
-    BOOL need_wait;
-    UINT8 *parity1, *parity2, *scratch;
+    bool need_wait;
+    uint8_t *parity1, *parity2, *scratch;
     PMDL mdl, parity1_mdl, parity2_mdl;
 } write_data_context;
 
 typedef struct {
-    UINT64 address;
-    UINT32 length;
-    UINT8* data;
+    uint64_t address;
+    uint32_t length;
+    uint8_t* data;
     chunk* c;
     LIST_ENTRY list_entry;
 } tree_write;
@@ -935,41 +921,13 @@ typedef struct {
 _Requires_lock_not_held_(Vcb->fcb_lock)
 _Acquires_shared_lock_(Vcb->fcb_lock)
 static __inline void acquire_fcb_lock_shared(device_extension* Vcb) {
-#ifdef DEBUG_STATS
-    LARGE_INTEGER time1, time2;
-
-    if (ExAcquireResourceSharedLite(&Vcb->fcb_lock, FALSE))
-        return;
-
-    time1 = KeQueryPerformanceCounter(NULL);
-#endif
-
-    ExAcquireResourceSharedLite(&Vcb->fcb_lock, TRUE);
-
-#ifdef DEBUG_STATS
-    time2 = KeQueryPerformanceCounter(NULL);
-    Vcb->stats.fcb_lock_time += time2.QuadPart - time1.QuadPart;
-#endif
+    ExAcquireResourceSharedLite(&Vcb->fcb_lock, true);
 }
 
 _Requires_lock_not_held_(Vcb->fcb_lock)
 _Acquires_exclusive_lock_(Vcb->fcb_lock)
 static __inline void acquire_fcb_lock_exclusive(device_extension* Vcb) {
-#ifdef DEBUG_STATS
-    LARGE_INTEGER time1, time2;
-
-    if (ExAcquireResourceExclusiveLite(&Vcb->fcb_lock, FALSE))
-        return;
-
-    time1 = KeQueryPerformanceCounter(NULL);
-#endif
-
-    ExAcquireResourceExclusiveLite(&Vcb->fcb_lock, TRUE);
-
-#ifdef DEBUG_STATS
-    time2 = KeQueryPerformanceCounter(NULL);
-    Vcb->stats.fcb_lock_time += time2.QuadPart - time1.QuadPart;
-#endif
+    ExAcquireResourceExclusiveLite(&Vcb->fcb_lock, true);
 }
 
 _Requires_lock_held_(Vcb->fcb_lock)
@@ -986,7 +944,7 @@ static __inline void* map_user_buffer(PIRP Irp, ULONG priority) {
     }
 }
 
-static __inline UINT64 unix_time_to_win(BTRFS_TIME* t) {
+static __inline uint64_t unix_time_to_win(BTRFS_TIME* t) {
     return (t->seconds * 10000000) + (t->nanoseconds / 100) + 116444736000000000;
 }
 
@@ -994,17 +952,17 @@ static __inline void win_time_to_unix(LARGE_INTEGER t, BTRFS_TIME* out) {
     ULONGLONG l = (ULONGLONG)t.QuadPart - 116444736000000000;
 
     out->seconds = l / 10000000;
-    out->nanoseconds = (UINT32)((l % 10000000) * 100);
+    out->nanoseconds = (uint32_t)((l % 10000000) * 100);
 }
 
 _Post_satisfies_(*stripe>=0&&*stripe<num_stripes)
-static __inline void get_raid0_offset(_In_ UINT64 off, _In_ UINT64 stripe_length, _In_ UINT16 num_stripes, _Out_ UINT64* stripeoff, _Out_ UINT16* stripe) {
-    UINT64 initoff, startoff;
+static __inline void get_raid0_offset(_In_ uint64_t off, _In_ uint64_t stripe_length, _In_ uint16_t num_stripes, _Out_ uint64_t* stripeoff, _Out_ uint16_t* stripe) {
+    uint64_t initoff, startoff;
 
     startoff = off % (num_stripes * stripe_length);
     initoff = (off / (num_stripes * stripe_length)) * stripe_length;
 
-    *stripe = (UINT16)(startoff / stripe_length);
+    *stripe = (uint16_t)(startoff / stripe_length);
     *stripeoff = initoff + startoff - (*stripe * stripe_length);
 }
 
@@ -1013,7 +971,7 @@ static __inline void get_raid0_offset(_In_ UINT64 off, _In_ UINT64 stripe_length
  * five for the inode, which should be good enough.
  * Inodes are also 64 bits on Linux, but the Linux driver seems to get round
  * this by tricking it into thinking subvols are separate volumes. */
-static __inline UINT64 make_file_id(root* r, UINT64 inode) {
+static __inline uint64_t make_file_id(root* r, uint64_t inode) {
     return (r->id << 40) | (inode & 0xffffffffff);
 }
 
@@ -1027,24 +985,24 @@ static __inline UINT64 make_file_id(root* r, UINT64 inode) {
     0))))))
 
 _Post_satisfies_(return>=n)
-__inline static UINT64 sector_align(_In_ UINT64 n, _In_ UINT64 a) {
+__inline static uint64_t sector_align(_In_ uint64_t n, _In_ uint64_t a) {
     if (n & (a - 1))
         n = (n + a) & ~(a - 1);
 
     return n;
 }
 
-__inline static BOOL is_subvol_readonly(root* r, PIRP Irp) {
+__inline static bool is_subvol_readonly(root* r, PIRP Irp) {
     if (!(r->root_item.flags & BTRFS_SUBVOL_READONLY))
-        return FALSE;
+        return false;
 
     if (!r->reserved)
-        return TRUE;
+        return true;
 
-    return (!Irp || Irp->RequestorMode == UserMode) && PsGetCurrentProcess() != r->reserved ? TRUE : FALSE;
+    return (!Irp || Irp->RequestorMode == UserMode) && PsGetCurrentProcess() != r->reserved ? true : false;
 }
 
-__inline static UINT16 get_extent_data_len(UINT8 type) {
+__inline static uint16_t get_extent_data_len(uint8_t type) {
     switch (type) {
         case TYPE_TREE_BLOCK_REF:
             return sizeof(TREE_BLOCK_REF);
@@ -1066,7 +1024,7 @@ __inline static UINT16 get_extent_data_len(UINT8 type) {
     }
 }
 
-__inline static UINT32 get_extent_data_refcount(UINT8 type, void* data) {
+__inline static uint32_t get_extent_data_refcount(uint8_t type, void* data) {
     switch (type) {
         case TYPE_TREE_BLOCK_REF:
             return 1;
@@ -1102,35 +1060,35 @@ _Ret_maybenull_
 device* find_device_from_uuid(_In_ device_extension* Vcb, _In_ BTRFS_UUID* uuid);
 
 _Success_(return)
-BOOL get_file_attributes_from_xattr(_In_reads_bytes_(len) char* val, _In_ UINT16 len, _Out_ ULONG* atts);
+bool get_file_attributes_from_xattr(_In_reads_bytes_(len) char* val, _In_ uint16_t len, _Out_ ULONG* atts);
 
-ULONG get_file_attributes(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _In_ UINT64 inode,
-                          _In_ UINT8 type, _In_ BOOL dotfile, _In_ BOOL ignore_xa, _In_opt_ PIRP Irp);
+ULONG get_file_attributes(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _In_ uint64_t inode,
+                          _In_ uint8_t type, _In_ bool dotfile, _In_ bool ignore_xa, _In_opt_ PIRP Irp);
 
 _Success_(return)
-BOOL get_xattr(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* subvol, _In_ UINT64 inode, _In_z_ char* name, _In_ UINT32 crc32,
-               _Out_ UINT8** data, _Out_ UINT16* datalen, _In_opt_ PIRP Irp);
+bool get_xattr(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* subvol, _In_ uint64_t inode, _In_z_ char* name, _In_ uint32_t crc32,
+               _Out_ uint8_t** data, _Out_ uint16_t* datalen, _In_opt_ PIRP Irp);
 
 #ifndef DEBUG_FCB_REFCOUNTS
 void free_fcb(_Inout_ fcb* fcb);
 #endif
 void free_fileref(_Inout_ file_ref* fr);
 void protect_superblocks(_Inout_ chunk* c);
-BOOL is_top_level(_In_ PIRP Irp);
-NTSTATUS create_root(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ UINT64 id,
-                     _Out_ root** rootptr, _In_ BOOL no_tree, _In_ UINT64 offset, _In_opt_ PIRP Irp);
+bool is_top_level(_In_ PIRP Irp);
+NTSTATUS create_root(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ uint64_t id,
+                     _Out_ root** rootptr, _In_ bool no_tree, _In_ uint64_t offset, _In_opt_ PIRP Irp);
 void uninit(_In_ device_extension* Vcb);
 NTSTATUS dev_ioctl(_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG ControlCode, _In_reads_bytes_opt_(InputBufferSize) PVOID InputBuffer, _In_ ULONG InputBufferSize,
-                   _Out_writes_bytes_opt_(OutputBufferSize) PVOID OutputBuffer, _In_ ULONG OutputBufferSize, _In_ BOOLEAN Override, _Out_opt_ IO_STATUS_BLOCK* iosb);
-BOOL is_file_name_valid(_In_ PUNICODE_STRING us, _In_ BOOL posix);
+                   _Out_writes_bytes_opt_(OutputBufferSize) PVOID OutputBuffer, _In_ ULONG OutputBufferSize, _In_ bool Override, _Out_opt_ IO_STATUS_BLOCK* iosb);
+bool is_file_name_valid(_In_ PUNICODE_STRING us, _In_ bool posix);
 void send_notification_fileref(_In_ file_ref* fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream);
 void send_notification_fcb(_In_ file_ref* fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream);
 
 #ifdef DEBUG_CHUNK_LOCKS
-#define acquire_chunk_lock(c, Vcb) { ExAcquireResourceExclusiveLite(&c->lock, TRUE); InterlockedIncrement(&Vcb->chunk_locks_held); }
+#define acquire_chunk_lock(c, Vcb) { ExAcquireResourceExclusiveLite(&c->lock, true); InterlockedIncrement(&Vcb->chunk_locks_held); }
 #define release_chunk_lock(c, Vcb) { InterlockedDecrement(&Vcb->chunk_locks_held); ExReleaseResourceLite(&c->lock); }
 #else
-#define acquire_chunk_lock(c, Vcb) ExAcquireResourceExclusiveLite(&(c)->lock, TRUE)
+#define acquire_chunk_lock(c, Vcb) ExAcquireResourceExclusiveLite(&(c)->lock, true)
 #define release_chunk_lock(c, Vcb) ExReleaseResourceLite(&(c)->lock)
 #endif
 
@@ -1139,26 +1097,28 @@ WCHAR* file_desc(_In_ PFILE_OBJECT FileObject);
 WCHAR* file_desc_fileref(_In_ file_ref* fileref);
 void mark_fcb_dirty(_In_ fcb* fcb);
 void mark_fileref_dirty(_In_ file_ref* fileref);
-NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject, _In_ BOOL make_orphan, _In_opt_ PIRP Irp, _In_ LIST_ENTRY* rollback);
-void chunk_lock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ UINT64 start, _In_ UINT64 length);
-void chunk_unlock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ UINT64 start, _In_ UINT64 length);
-void init_device(_In_ device_extension* Vcb, _Inout_ device* dev, _In_ BOOL get_nums);
+NTSTATUS delete_fileref(_In_ file_ref* fileref, _In_opt_ PFILE_OBJECT FileObject, _In_ bool make_orphan, _In_opt_ PIRP Irp, _In_ LIST_ENTRY* rollback);
+void chunk_lock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ uint64_t start, _In_ uint64_t length);
+void chunk_unlock_range(_In_ device_extension* Vcb, _In_ chunk* c, _In_ uint64_t start, _In_ uint64_t length);
+void init_device(_In_ device_extension* Vcb, _Inout_ device* dev, _In_ bool get_nums);
 void init_file_cache(_In_ PFILE_OBJECT FileObject, _In_ CC_FILE_SIZES* ccfs);
-NTSTATUS sync_read_phys(_In_ PDEVICE_OBJECT DeviceObject, _In_ UINT64 StartingOffset, _In_ ULONG Length,
-                        _Out_writes_bytes_(Length) PUCHAR Buffer, _In_ BOOL override);
+NTSTATUS sync_read_phys(_In_ PDEVICE_OBJECT DeviceObject, _In_ PFILE_OBJECT FileObject, _In_ uint64_t StartingOffset, _In_ ULONG Length,
+                        _Out_writes_bytes_(Length) PUCHAR Buffer, _In_ bool override);
 NTSTATUS get_device_pnp_name(_In_ PDEVICE_OBJECT DeviceObject, _Out_ PUNICODE_STRING pnp_name, _Out_ const GUID** guid);
 void log_device_error(_In_ device_extension* Vcb, _Inout_ device* dev, _In_ int error);
 NTSTATUS find_chunk_usage(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_opt_ PIRP Irp);
-#ifdef __REACTOS__
-NTSTATUS NTAPI AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject);
-#else
-NTSTATUS AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject);
-#endif
+
+_Function_class_(DRIVER_ADD_DEVICE)
+NTSTATUS __stdcall AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject);
+
 void reap_fcb(fcb* fcb);
 void reap_fcbs(device_extension* Vcb);
 void reap_fileref(device_extension* Vcb, file_ref* fr);
 void reap_filerefs(device_extension* Vcb, file_ref* fr);
-UINT64 chunk_estimate_phys_size(device_extension* Vcb, chunk* c, UINT64 u);
+uint64_t chunk_estimate_phys_size(device_extension* Vcb, chunk* c, uint64_t u);
+NTSTATUS utf8_to_utf16(WCHAR* dest, ULONG dest_max, ULONG* dest_len, char* src, ULONG src_len);
+NTSTATUS utf16_to_utf8(char* dest, ULONG dest_max, ULONG* dest_len, WCHAR* src, ULONG src_len);
+uint32_t get_num_of_processors();
 
 #ifdef _MSC_VER
 #define funcname __FUNCTION__
@@ -1166,27 +1126,27 @@ UINT64 chunk_estimate_phys_size(device_extension* Vcb, chunk* c, UINT64 u);
 #define funcname __func__
 #endif
 
-extern BOOL have_sse2;
-
-extern UINT32 mount_compress;
-extern UINT32 mount_compress_force;
-extern UINT32 mount_compress_type;
-extern UINT32 mount_zlib_level;
-extern UINT32 mount_zstd_level;
-extern UINT32 mount_flush_interval;
-extern UINT32 mount_max_inline;
-extern UINT32 mount_skip_balance;
-extern UINT32 mount_no_barrier;
-extern UINT32 mount_no_trim;
-extern UINT32 mount_clear_cache;
-extern UINT32 mount_allow_degraded;
-extern UINT32 mount_readonly;
-extern UINT32 no_pnp;
+extern bool have_sse2;
+
+extern uint32_t mount_compress;
+extern uint32_t mount_compress_force;
+extern uint32_t mount_compress_type;
+extern uint32_t mount_zlib_level;
+extern uint32_t mount_zstd_level;
+extern uint32_t mount_flush_interval;
+extern uint32_t mount_max_inline;
+extern uint32_t mount_skip_balance;
+extern uint32_t mount_no_barrier;
+extern uint32_t mount_no_trim;
+extern uint32_t mount_clear_cache;
+extern uint32_t mount_allow_degraded;
+extern uint32_t mount_readonly;
+extern uint32_t no_pnp;
 
 #ifdef _DEBUG
 
-extern BOOL log_started;
-extern UINT32 debug_log_level;
+extern bool log_started;
+extern uint32_t debug_log_level;
 
 #ifdef DEBUG_LONG_MESSAGES
 
@@ -1230,13 +1190,13 @@ void _free_fcb(_Inout_ fcb* fcb, _In_ const char* func);
 void init_fast_io_dispatch(FAST_IO_DISPATCH** fiod);
 
 // in crc32c.c
-UINT32 calc_crc32c(_In_ UINT32 seed, _In_reads_bytes_(msglen) UINT8* msg, _In_ ULONG msglen);
+uint32_t calc_crc32c(_In_ uint32_t seed, _In_reads_bytes_(msglen) uint8_t* msg, _In_ ULONG msglen);
 
 typedef struct {
     LIST_ENTRY* list;
     LIST_ENTRY* list_size;
-    UINT64 address;
-    UINT64 length;
+    uint64_t address;
+    uint64_t length;
     chunk* chunk;
 } rollback_space;
 
@@ -1272,17 +1232,17 @@ static const char lxdev[] = "$LXDEV";
 
 // in treefuncs.c
 NTSTATUS find_item(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _Out_ traverse_ptr* tp,
-                   _In_ const KEY* searchkey, _In_ BOOL ignore, _In_opt_ PIRP Irp);
-NTSTATUS find_item_to_level(device_extension* Vcb, root* r, traverse_ptr* tp, const KEY* searchkey, BOOL ignore, UINT8 level, PIRP Irp);
-BOOL find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, const traverse_ptr* tp, traverse_ptr* next_tp, BOOL ignore, PIRP Irp);
-BOOL find_prev_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, const traverse_ptr* tp, traverse_ptr* prev_tp, PIRP Irp);
+                   _In_ const KEY* searchkey, _In_ bool ignore, _In_opt_ PIRP Irp);
+NTSTATUS find_item_to_level(device_extension* Vcb, root* r, traverse_ptr* tp, const KEY* searchkey, bool ignore, uint8_t level, PIRP Irp);
+bool find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, const traverse_ptr* tp, traverse_ptr* next_tp, bool ignore, PIRP Irp);
+bool find_prev_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, const traverse_ptr* tp, traverse_ptr* prev_tp, PIRP Irp);
 void free_trees(device_extension* Vcb);
-NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _In_ UINT64 obj_id,
-                          _In_ UINT8 obj_type, _In_ UINT64 offset, _In_reads_bytes_opt_(size) _When_(return >= 0, __drv_aliasesMem) void* data,
-                          _In_ UINT16 size, _Out_opt_ traverse_ptr* ptp, _In_opt_ PIRP Irp);
+NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _In_ uint64_t obj_id,
+                          _In_ uint8_t obj_type, _In_ uint64_t offset, _In_reads_bytes_opt_(size) _When_(return >= 0, __drv_aliasesMem) void* data,
+                          _In_ uint16_t size, _Out_opt_ traverse_ptr* ptp, _In_opt_ PIRP Irp);
 NTSTATUS delete_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _Inout_ traverse_ptr* tp);
 void free_tree(tree* t);
-NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, UINT8* buf, root* r, tree** pt);
+NTSTATUS load_tree(device_extension* Vcb, uint64_t addr, uint8_t* buf, root* r, tree** pt);
 NTSTATUS do_load_tree(device_extension* Vcb, tree_holder* th, root* r, tree* t, tree_data* td, PIRP Irp);
 void clear_rollback(LIST_ENTRY* rollback);
 void do_rollback(device_extension* Vcb, LIST_ENTRY* rollback);
@@ -1290,38 +1250,26 @@ void free_trees_root(device_extension* Vcb, root* r);
 void add_rollback(_In_ LIST_ENTRY* rollback, _In_ enum rollback_type type, _In_ __drv_aliasesMem void* ptr);
 NTSTATUS commit_batch_list(_Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, LIST_ENTRY* batchlist, PIRP Irp);
 void clear_batch_list(device_extension* Vcb, LIST_ENTRY* batchlist);
-NTSTATUS skip_to_difference(device_extension* Vcb, traverse_ptr* tp, traverse_ptr* tp2, BOOL* ended1, BOOL* ended2);
+NTSTATUS skip_to_difference(device_extension* Vcb, traverse_ptr* tp, traverse_ptr* tp2, bool* ended1, bool* ended2);
 
 // in search.c
 NTSTATUS remove_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath);
 
 _Function_class_(KSTART_ROUTINE)
-#ifdef __REACTOS__
-void NTAPI mountmgr_thread(_In_ void* context);
-#else
-void mountmgr_thread(_In_ void* context);
-#endif
+void __stdcall mountmgr_thread(_In_ void* context);
 
 _Function_class_(DRIVER_NOTIFICATION_CALLBACK_ROUTINE)
-#ifdef __REACTOS__
-NTSTATUS NTAPI pnp_notification(PVOID NotificationStructure, PVOID Context);
-#else
-NTSTATUS pnp_notification(PVOID NotificationStructure, PVOID Context);
-#endif
+NTSTATUS __stdcall pnp_notification(PVOID NotificationStructure, PVOID Context);
 
 void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath);
 void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath);
 void volume_removal(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath);
 
 _Function_class_(DRIVER_NOTIFICATION_CALLBACK_ROUTINE)
-#ifdef __REACTOS__
-NTSTATUS NTAPI volume_notification(PVOID NotificationStructure, PVOID Context);
-#else
-NTSTATUS volume_notification(PVOID NotificationStructure, PVOID Context);
-#endif
+NTSTATUS __stdcall volume_notification(PVOID NotificationStructure, PVOID Context);
 
 void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lock) _Releases_exclusive_lock_(_Curr_->child_lock) _In_ volume_device_extension* vde,
-                         _In_ volume_child* vc, _In_ BOOL skip_dev);
+                         _In_ volume_child* vc, _In_ bool skip_dev);
 
 // in cache.c
 NTSTATUS init_cache();
@@ -1329,63 +1277,63 @@ void free_cache();
 extern CACHE_MANAGER_CALLBACKS* cache_callbacks;
 
 // in write.c
-NTSTATUS write_file(device_extension* Vcb, PIRP Irp, BOOLEAN wait, BOOLEAN deferred_write);
-NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void* buf, ULONG* length, BOOLEAN paging_io, BOOLEAN no_cache,
-                     BOOLEAN wait, BOOLEAN deferred_write, BOOLEAN write_irp, LIST_ENTRY* rollback);
-NTSTATUS truncate_file(fcb* fcb, UINT64 end, PIRP Irp, LIST_ENTRY* rollback);
-NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIRP Irp, LIST_ENTRY* rollback);
-NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT64 end_data, PIRP Irp, LIST_ENTRY* rollback);
-chunk* get_chunk_from_address(device_extension* Vcb, UINT64 address);
-NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_size);
-NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_bytes_(length) void* data, _In_ UINT32 length, _In_ write_data_context* wtc,
-                    _In_opt_ PIRP Irp, _In_opt_ chunk* c, _In_ BOOL file_write, _In_ UINT64 irp_offset, _In_ ULONG priority);
-NTSTATUS write_data_complete(device_extension* Vcb, UINT64 address, void* data, UINT32 length, PIRP Irp, chunk* c, BOOL file_write, UINT64 irp_offset, ULONG priority);
+NTSTATUS write_file(device_extension* Vcb, PIRP Irp, bool wait, bool deferred_write);
+NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void* buf, ULONG* length, bool paging_io, bool no_cache,
+                     bool wait, bool deferred_write, bool write_irp, LIST_ENTRY* rollback);
+NTSTATUS truncate_file(fcb* fcb, uint64_t end, PIRP Irp, LIST_ENTRY* rollback);
+NTSTATUS extend_file(fcb* fcb, file_ref* fileref, uint64_t end, bool prealloc, PIRP Irp, LIST_ENTRY* rollback);
+NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, uint64_t start_data, uint64_t end_data, PIRP Irp, LIST_ENTRY* rollback);
+chunk* get_chunk_from_address(device_extension* Vcb, uint64_t address);
+NTSTATUS alloc_chunk(device_extension* Vcb, uint64_t flags, chunk** pc, bool full_size);
+NTSTATUS write_data(_In_ device_extension* Vcb, _In_ uint64_t address, _In_reads_bytes_(length) void* data, _In_ uint32_t length, _In_ write_data_context* wtc,
+                    _In_opt_ PIRP Irp, _In_opt_ chunk* c, _In_ bool file_write, _In_ uint64_t irp_offset, _In_ ULONG priority);
+NTSTATUS write_data_complete(device_extension* Vcb, uint64_t address, void* data, uint32_t length, PIRP Irp, chunk* c, bool file_write, uint64_t irp_offset, ULONG priority);
 void free_write_data_stripes(write_data_context* wtc);
 
 _Dispatch_type_(IRP_MJ_WRITE)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+NTSTATUS __stdcall drv_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 
 _Requires_lock_held_(c->lock)
 _When_(return != 0, _Releases_lock_(c->lock))
-BOOL insert_extent_chunk(_In_ device_extension* Vcb, _In_ fcb* fcb, _In_ chunk* c, _In_ UINT64 start_data, _In_ UINT64 length, _In_ BOOL prealloc, _In_opt_ void* data,
-                         _In_opt_ PIRP Irp, _In_ LIST_ENTRY* rollback, _In_ UINT8 compression, _In_ UINT64 decoded_size, _In_ BOOL file_write, _In_ UINT64 irp_offset);
-
-NTSTATUS do_write_file(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, PIRP Irp, BOOL file_write, UINT32 irp_offset, LIST_ENTRY* rollback);
-NTSTATUS write_compressed(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, PIRP Irp, LIST_ENTRY* rollback);
-BOOL find_data_address_in_chunk(device_extension* Vcb, chunk* c, UINT64 length, UINT64* address);
-void get_raid56_lock_range(chunk* c, UINT64 address, UINT64 length, UINT64* lockaddr, UINT64* locklen);
-NTSTATUS calc_csum(_In_ device_extension* Vcb, _In_reads_bytes_(sectors*Vcb->superblock.sector_size) UINT8* data,
-                   _In_ UINT32 sectors, _Out_writes_bytes_(sectors*sizeof(UINT32)) UINT32* csum);
+bool insert_extent_chunk(_In_ device_extension* Vcb, _In_ fcb* fcb, _In_ chunk* c, _In_ uint64_t start_data, _In_ uint64_t length, _In_ bool prealloc, _In_opt_ void* data,
+                         _In_opt_ PIRP Irp, _In_ LIST_ENTRY* rollback, _In_ uint8_t compression, _In_ uint64_t decoded_size, _In_ bool file_write, _In_ uint64_t irp_offset);
+
+NTSTATUS do_write_file(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, PIRP Irp, bool file_write, uint32_t irp_offset, LIST_ENTRY* rollback);
+NTSTATUS write_compressed(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, PIRP Irp, LIST_ENTRY* rollback);
+bool find_data_address_in_chunk(device_extension* Vcb, chunk* c, uint64_t length, uint64_t* address);
+void get_raid56_lock_range(chunk* c, uint64_t address, uint64_t length, uint64_t* lockaddr, uint64_t* locklen);
+NTSTATUS calc_csum(_In_ device_extension* Vcb, _In_reads_bytes_(sectors*Vcb->superblock.sector_size) uint8_t* data,
+                   _In_ uint32_t sectors, _Out_writes_bytes_(sectors*sizeof(uint32_t)) uint32_t* csum);
 void add_insert_extent_rollback(LIST_ENTRY* rollback, fcb* fcb, extent* ext);
-NTSTATUS add_extent_to_fcb(_In_ fcb* fcb, _In_ UINT64 offset, _In_reads_bytes_(edsize) EXTENT_DATA* ed, _In_ UINT16 edsize,
-                           _In_ BOOL unique, _In_opt_ _When_(return >= 0, __drv_aliasesMem) UINT32* csum, _In_ LIST_ENTRY* rollback);
+NTSTATUS add_extent_to_fcb(_In_ fcb* fcb, _In_ uint64_t offset, _In_reads_bytes_(edsize) EXTENT_DATA* ed, _In_ uint16_t edsize,
+                           _In_ bool unique, _In_opt_ _When_(return >= 0, __drv_aliasesMem) uint32_t* csum, _In_ LIST_ENTRY* rollback);
 void add_extent(_In_ fcb* fcb, _In_ LIST_ENTRY* prevextle, _In_ __drv_aliasesMem extent* newext);
 
 // in dirctrl.c
 
 _Dispatch_type_(IRP_MJ_DIRECTORY_CONTROL)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_directory_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+NTSTATUS __stdcall drv_directory_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 
-ULONG get_reparse_tag(device_extension* Vcb, root* subvol, UINT64 inode, UINT8 type, ULONG atts, BOOL lxss, PIRP Irp);
+ULONG get_reparse_tag(device_extension* Vcb, root* subvol, uint64_t inode, uint8_t type, ULONG atts, bool lxss, PIRP Irp);
 ULONG get_reparse_tag_fcb(fcb* fcb);
 
 // in security.c
 
 _Dispatch_type_(IRP_MJ_QUERY_SECURITY)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_query_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+NTSTATUS __stdcall drv_query_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 
 _Dispatch_type_(IRP_MJ_SET_SECURITY)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+NTSTATUS __stdcall drv_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 
-void fcb_get_sd(fcb* fcb, struct _fcb* parent, BOOL look_for_xattr, PIRP Irp);
-void add_user_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 uid);
-void add_group_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 gid);
-UINT32 sid_to_uid(PSID sid);
-NTSTATUS uid_to_sid(UINT32 uid, PSID* sid);
+void fcb_get_sd(fcb* fcb, struct _fcb* parent, bool look_for_xattr, PIRP Irp);
+void add_user_mapping(WCHAR* sidstring, ULONG sidstringlength, uint32_t uid);
+void add_group_mapping(WCHAR* sidstring, ULONG sidstringlength, uint32_t gid);
+uint32_t sid_to_uid(PSID sid);
+NTSTATUS uid_to_sid(uint32_t uid, PSID* sid);
 NTSTATUS fcb_get_new_sd(fcb* fcb, file_ref* parfileref, ACCESS_STATE* as);
 void find_gid(struct _fcb* fcb, struct _fcb* parfcb, PSECURITY_SUBJECT_CONTEXT subjcont);
 
@@ -1393,22 +1341,22 @@ void find_gid(struct _fcb* fcb, struct _fcb* parfcb, PSECURITY_SUBJECT_CONTEXT s
 
 _Dispatch_type_(IRP_MJ_SET_INFORMATION)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+NTSTATUS __stdcall drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 
 _Dispatch_type_(IRP_MJ_QUERY_INFORMATION)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_query_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+NTSTATUS __stdcall drv_query_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 
 _Dispatch_type_(IRP_MJ_QUERY_EA)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+NTSTATUS __stdcall drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 
 _Dispatch_type_(IRP_MJ_SET_EA)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+NTSTATUS __stdcall drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 
-BOOL has_open_children(file_ref* fileref);
-NTSTATUS stream_set_end_of_file_information(device_extension* Vcb, UINT16 end, fcb* fcb, file_ref* fileref, BOOL advance_only);
+bool has_open_children(file_ref* fileref);
+NTSTATUS stream_set_end_of_file_information(device_extension* Vcb, uint16_t end, fcb* fcb, file_ref* fileref, bool advance_only);
 NTSTATUS fileref_get_filename(file_ref* fileref, PUNICODE_STRING fn, USHORT* name_offset, ULONG* preqlen);
 void insert_dir_child_into_hash_lists(fcb* fcb, dir_child* dc);
 void remove_dir_child_from_hash_lists(fcb* fcb, dir_child* dc);
@@ -1423,52 +1371,49 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp);
 
 _Dispatch_type_(IRP_MJ_CREATE)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+NTSTATUS __stdcall drv_create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 
 NTSTATUS open_fileref(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension* Vcb, _Out_ file_ref** pfr,
-                      _In_ PUNICODE_STRING fnus, _In_opt_ file_ref* related, _In_ BOOL parent, _Out_opt_ USHORT* parsed, _Out_opt_ ULONG* fn_offset, _In_ POOL_TYPE pooltype,
-                      _In_ BOOL case_sensitive, _In_opt_ PIRP Irp);
+                      _In_ PUNICODE_STRING fnus, _In_opt_ file_ref* related, _In_ bool parent, _Out_opt_ USHORT* parsed, _Out_opt_ ULONG* fn_offset, _In_ POOL_TYPE pooltype,
+                      _In_ bool case_sensitive, _In_opt_ PIRP Irp);
 NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension* Vcb,
-                  root* subvol, UINT64 inode, UINT8 type, PANSI_STRING utf8, BOOL always_add_hl, fcb* parent, fcb** pfcb, POOL_TYPE pooltype, PIRP Irp);
-NTSTATUS load_csum(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, UINT32* csum, UINT64 start, UINT64 length, PIRP Irp);
-NTSTATUS load_dir_children(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, fcb* fcb, BOOL ignore_size, PIRP Irp);
-NTSTATUS add_dir_child(fcb* fcb, UINT64 inode, BOOL subvol, PANSI_STRING utf8, PUNICODE_STRING name, UINT8 type, dir_child** pdc);
+                  root* subvol, uint64_t inode, uint8_t type, PANSI_STRING utf8, bool always_add_hl, fcb* parent, fcb** pfcb, POOL_TYPE pooltype, PIRP Irp);
+NTSTATUS load_csum(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, uint32_t* csum, uint64_t start, uint64_t length, PIRP Irp);
+NTSTATUS load_dir_children(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, fcb* fcb, bool ignore_size, PIRP Irp);
+NTSTATUS add_dir_child(fcb* fcb, uint64_t inode, bool subvol, PANSI_STRING utf8, PUNICODE_STRING name, uint8_t type, dir_child** pdc);
 NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension* Vcb,
-                            _In_ file_ref* sf, _In_ PUNICODE_STRING name, _In_ BOOL case_sensitive, _In_ BOOL lastpart, _In_ BOOL streampart,
+                            _In_ file_ref* sf, _In_ PUNICODE_STRING name, _In_ bool case_sensitive, _In_ bool lastpart, _In_ bool streampart,
                             _In_ POOL_TYPE pooltype, _Out_ file_ref** psf2, _In_opt_ PIRP Irp);
 fcb* create_fcb(device_extension* Vcb, POOL_TYPE pool_type);
-NTSTATUS find_file_in_dir(PUNICODE_STRING filename, fcb* fcb, root** subvol, UINT64* inode, dir_child** pdc, BOOL case_sensitive);
-UINT32 inherit_mode(fcb* parfcb, BOOL is_dir);
+NTSTATUS find_file_in_dir(PUNICODE_STRING filename, fcb* fcb, root** subvol, uint64_t* inode, dir_child** pdc, bool case_sensitive);
+uint32_t inherit_mode(fcb* parfcb, bool is_dir);
 file_ref* create_fileref(device_extension* Vcb);
-NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension* Vcb, root* subvol, UINT64 inode, file_ref** pfr, PIRP Irp);
+NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension* Vcb, root* subvol, uint64_t inode, file_ref** pfr, PIRP Irp);
 
 // in fsctl.c
-NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp, UINT32 type);
+NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp, uint32_t type);
 void do_unlock_volume(device_extension* Vcb);
 void trim_whole_device(device* dev);
 void flush_subvol_fcbs(root* subvol);
-BOOL fcb_is_inline(fcb* fcb);
+bool fcb_is_inline(fcb* fcb);
 
 // in flushthread.c
 
 _Function_class_(KSTART_ROUTINE)
-#ifdef __REACTOS__
-void NTAPI flush_thread(void* context);
-#else
-void flush_thread(void* context);
-#endif
+void __stdcall flush_thread(void* context);
 
 NTSTATUS do_write(device_extension* Vcb, PIRP Irp);
 NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENTRY* rollback);
-NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp);
-NTSTATUS write_data_phys(_In_ PDEVICE_OBJECT device, _In_ UINT64 address, _In_reads_bytes_(length) void* data, _In_ UINT32 length);
-BOOL is_tree_unique(device_extension* Vcb, tree* t, PIRP Irp);
-NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, BOOL no_free);
-void add_checksum_entry(device_extension* Vcb, UINT64 address, ULONG length, UINT32* csum, PIRP Irp);
-BOOL find_metadata_address_in_chunk(device_extension* Vcb, chunk* c, UINT64* address);
-void add_trim_entry_avoid_sb(device_extension* Vcb, device* dev, UINT64 address, UINT64 size);
-NTSTATUS insert_tree_item_batch(LIST_ENTRY* batchlist, device_extension* Vcb, root* r, UINT64 objid, UINT8 objtype, UINT64 offset,
-                                _In_opt_ _When_(return >= 0, __drv_aliasesMem) void* data, UINT16 datalen, enum batch_operation operation);
+NTSTATUS flush_fcb(fcb* fcb, bool cache, LIST_ENTRY* batchlist, PIRP Irp);
+NTSTATUS write_data_phys(_In_ PDEVICE_OBJECT device, _In_ PFILE_OBJECT fileobj, _In_ uint64_t address,
+                         _In_reads_bytes_(length) void* data, _In_ uint32_t length);
+bool is_tree_unique(device_extension* Vcb, tree* t, PIRP Irp);
+NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, bool no_free);
+void add_checksum_entry(device_extension* Vcb, uint64_t address, ULONG length, uint32_t* csum, PIRP Irp);
+bool find_metadata_address_in_chunk(device_extension* Vcb, chunk* c, uint64_t* address);
+void add_trim_entry_avoid_sb(device_extension* Vcb, device* dev, uint64_t address, uint64_t size);
+NTSTATUS insert_tree_item_batch(LIST_ENTRY* batchlist, device_extension* Vcb, root* r, uint64_t objid, uint8_t objtype, uint64_t offset,
+                                _In_opt_ _When_(return >= 0, __drv_aliasesMem) void* data, uint16_t datalen, enum batch_operation operation);
 NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* ps);
 NTSTATUS update_dev_item(device_extension* Vcb, device* device, PIRP Irp);
 
@@ -1476,22 +1421,22 @@ NTSTATUS update_dev_item(device_extension* Vcb, device* device, PIRP Irp);
 
 _Dispatch_type_(IRP_MJ_READ)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_read(PDEVICE_OBJECT DeviceObject, PIRP Irp);
+NTSTATUS __stdcall drv_read(PDEVICE_OBJECT DeviceObject, PIRP Irp);
 
-NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 length, _In_reads_bytes_opt_(length*sizeof(UINT32)/Vcb->superblock.sector_size) UINT32* csum,
-                   _In_ BOOL is_tree, _Out_writes_bytes_(length) UINT8* buf, _In_opt_ chunk* c, _Out_opt_ chunk** pc, _In_opt_ PIRP Irp, _In_ UINT64 generation, _In_ BOOL file_read,
+NTSTATUS read_data(_In_ device_extension* Vcb, _In_ uint64_t addr, _In_ uint32_t length, _In_reads_bytes_opt_(length*sizeof(uint32_t)/Vcb->superblock.sector_size) uint32_t* csum,
+                   _In_ bool is_tree, _Out_writes_bytes_(length) uint8_t* buf, _In_opt_ chunk* c, _Out_opt_ chunk** pc, _In_opt_ PIRP Irp, _In_ uint64_t generation, _In_ bool file_read,
                    _In_ ULONG priority);
-NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pbr, PIRP Irp);
-NTSTATUS read_stream(fcb* fcb, UINT8* data, UINT64 start, ULONG length, ULONG* pbr);
-NTSTATUS do_read(PIRP Irp, BOOLEAN wait, ULONG* bytes_read);
-NTSTATUS check_csum(device_extension* Vcb, UINT8* data, UINT32 sectors, UINT32* csum);
-void raid6_recover2(UINT8* sectors, UINT16 num_stripes, ULONG sector_size, UINT16 missing1, UINT16 missing2, UINT8* out);
+NTSTATUS read_file(fcb* fcb, uint8_t* data, uint64_t start, uint64_t length, ULONG* pbr, PIRP Irp);
+NTSTATUS read_stream(fcb* fcb, uint8_t* data, uint64_t start, ULONG length, ULONG* pbr);
+NTSTATUS do_read(PIRP Irp, bool wait, ULONG* bytes_read);
+NTSTATUS check_csum(device_extension* Vcb, uint8_t* data, uint32_t sectors, uint32_t* csum);
+void raid6_recover2(uint8_t* sectors, uint16_t num_stripes, ULONG sector_size, uint16_t missing1, uint16_t missing2, uint8_t* out);
 
 // in pnp.c
 
 _Dispatch_type_(IRP_MJ_PNP)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_pnp(PDEVICE_OBJECT DeviceObject, PIRP Irp);
+NTSTATUS __stdcall drv_pnp(PDEVICE_OBJECT DeviceObject, PIRP Irp);
 
 NTSTATUS pnp_surprise_removal(PDEVICE_OBJECT DeviceObject, PIRP Irp);
 NTSTATUS pnp_query_remove_device(PDEVICE_OBJECT DeviceObject, PIRP Irp);
@@ -1499,76 +1444,72 @@ NTSTATUS pnp_query_remove_device(PDEVICE_OBJECT DeviceObject, PIRP Irp);
 // in free-space.c
 NTSTATUS load_cache_chunk(device_extension* Vcb, chunk* c, PIRP Irp);
 NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PIRP Irp);
-NTSTATUS allocate_cache(device_extension* Vcb, BOOL* changed, PIRP Irp, LIST_ENTRY* rollback);
+NTSTATUS allocate_cache(device_extension* Vcb, bool* changed, PIRP Irp, LIST_ENTRY* rollback);
 NTSTATUS update_chunk_caches(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback);
 NTSTATUS update_chunk_caches_tree(device_extension* Vcb, PIRP Irp);
-NTSTATUS add_space_entry(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 offset, UINT64 size);
-void space_list_add(chunk* c, UINT64 address, UINT64 length, LIST_ENTRY* rollback);
-void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UINT64 length, chunk* c, LIST_ENTRY* rollback);
-void space_list_subtract(chunk* c, BOOL deleting, UINT64 address, UINT64 length, LIST_ENTRY* rollback);
-void space_list_subtract2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UINT64 length, chunk* c, LIST_ENTRY* rollback);
-NTSTATUS load_stored_free_space_cache(device_extension* Vcb, chunk* c, BOOL load_only, PIRP Irp);
+NTSTATUS add_space_entry(LIST_ENTRY* list, LIST_ENTRY* list_size, uint64_t offset, uint64_t size);
+void space_list_add(chunk* c, uint64_t address, uint64_t length, LIST_ENTRY* rollback);
+void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, uint64_t address, uint64_t length, chunk* c, LIST_ENTRY* rollback);
+void space_list_subtract(chunk* c, bool deleting, uint64_t address, uint64_t length, LIST_ENTRY* rollback);
+void space_list_subtract2(LIST_ENTRY* list, LIST_ENTRY* list_size, uint64_t address, uint64_t length, chunk* c, LIST_ENTRY* rollback);
+NTSTATUS load_stored_free_space_cache(device_extension* Vcb, chunk* c, bool load_only, PIRP Irp);
 
 // in extent-tree.c
-NTSTATUS increase_extent_refcount_data(device_extension* Vcb, UINT64 address, UINT64 size, UINT64 root, UINT64 inode, UINT64 offset, UINT32 refcount, PIRP Irp);
-NTSTATUS decrease_extent_refcount_data(device_extension* Vcb, UINT64 address, UINT64 size, UINT64 root, UINT64 inode, UINT64 offset,
-                                       UINT32 refcount, BOOL superseded, PIRP Irp);
-NTSTATUS decrease_extent_refcount_tree(device_extension* Vcb, UINT64 address, UINT64 size, UINT64 root, UINT8 level, PIRP Irp);
-UINT64 get_extent_refcount(device_extension* Vcb, UINT64 address, UINT64 size, PIRP Irp);
-BOOL is_extent_unique(device_extension* Vcb, UINT64 address, UINT64 size, PIRP Irp);
-NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64 size, UINT8 type, void* data, KEY* firstitem, UINT8 level, PIRP Irp);
-UINT64 get_extent_flags(device_extension* Vcb, UINT64 address, PIRP Irp);
-void update_extent_flags(device_extension* Vcb, UINT64 address, UINT64 flags, PIRP Irp);
-NTSTATUS update_changed_extent_ref(device_extension* Vcb, chunk* c, UINT64 address, UINT64 size, UINT64 root, UINT64 objid, UINT64 offset,
-                                   INT32 count, BOOL no_csum, BOOL superseded, PIRP Irp);
-void add_changed_extent_ref(chunk* c, UINT64 address, UINT64 size, UINT64 root, UINT64 objid, UINT64 offset, UINT32 count, BOOL no_csum);
-UINT64 find_extent_shared_tree_refcount(device_extension* Vcb, UINT64 address, UINT64 parent, PIRP Irp);
-UINT32 find_extent_shared_data_refcount(device_extension* Vcb, UINT64 address, UINT64 parent, PIRP Irp);
-NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64 size, UINT8 type, void* data, KEY* firstitem,
-                                  UINT8 level, UINT64 parent, BOOL superseded, PIRP Irp);
-UINT64 get_extent_data_ref_hash2(UINT64 root, UINT64 objid, UINT64 offset);
+NTSTATUS increase_extent_refcount_data(device_extension* Vcb, uint64_t address, uint64_t size, uint64_t root, uint64_t inode, uint64_t offset, uint32_t refcount, PIRP Irp);
+NTSTATUS decrease_extent_refcount_data(device_extension* Vcb, uint64_t address, uint64_t size, uint64_t root, uint64_t inode, uint64_t offset,
+                                       uint32_t refcount, bool superseded, PIRP Irp);
+NTSTATUS decrease_extent_refcount_tree(device_extension* Vcb, uint64_t address, uint64_t size, uint64_t root, uint8_t level, PIRP Irp);
+uint64_t get_extent_refcount(device_extension* Vcb, uint64_t address, uint64_t size, PIRP Irp);
+bool is_extent_unique(device_extension* Vcb, uint64_t address, uint64_t size, PIRP Irp);
+NTSTATUS increase_extent_refcount(device_extension* Vcb, uint64_t address, uint64_t size, uint8_t type, void* data, KEY* firstitem, uint8_t level, PIRP Irp);
+uint64_t get_extent_flags(device_extension* Vcb, uint64_t address, PIRP Irp);
+void update_extent_flags(device_extension* Vcb, uint64_t address, uint64_t flags, PIRP Irp);
+NTSTATUS update_changed_extent_ref(device_extension* Vcb, chunk* c, uint64_t address, uint64_t size, uint64_t root, uint64_t objid, uint64_t offset,
+                                   int32_t count, bool no_csum, bool superseded, PIRP Irp);
+void add_changed_extent_ref(chunk* c, uint64_t address, uint64_t size, uint64_t root, uint64_t objid, uint64_t offset, uint32_t count, bool no_csum);
+uint64_t find_extent_shared_tree_refcount(device_extension* Vcb, uint64_t address, uint64_t parent, PIRP Irp);
+uint32_t find_extent_shared_data_refcount(device_extension* Vcb, uint64_t address, uint64_t parent, PIRP Irp);
+NTSTATUS decrease_extent_refcount(device_extension* Vcb, uint64_t address, uint64_t size, uint8_t type, void* data, KEY* firstitem,
+                                  uint8_t level, uint64_t parent, bool superseded, PIRP Irp);
+uint64_t get_extent_data_ref_hash2(uint64_t root, uint64_t objid, uint64_t offset);
 
 // in worker-thread.c
-void do_read_job(PIRP Irp);
-void do_write_job(device_extension* Vcb, PIRP Irp);
-BOOL add_thread_job(device_extension* Vcb, PIRP Irp);
+NTSTATUS do_read_job(PIRP Irp);
+NTSTATUS do_write_job(device_extension* Vcb, PIRP Irp);
+bool add_thread_job(device_extension* Vcb, PIRP Irp);
 
 // in registry.c
-void read_registry(PUNICODE_STRING regpath, BOOL refresh);
+void read_registry(PUNICODE_STRING regpath, bool refresh);
 NTSTATUS registry_mark_volume_mounted(BTRFS_UUID* uuid);
 NTSTATUS registry_mark_volume_unmounted(BTRFS_UUID* uuid);
 NTSTATUS registry_load_volume_options(device_extension* Vcb);
 void watch_registry(HANDLE regh);
 
 // in compress.c
-NTSTATUS zlib_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen);
-NTSTATUS lzo_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen, UINT32 inpageoff);
-NTSTATUS zstd_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen);
-NTSTATUS write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback);
+NTSTATUS zlib_decompress(uint8_t* inbuf, uint32_t inlen, uint8_t* outbuf, uint32_t outlen);
+NTSTATUS lzo_decompress(uint8_t* inbuf, uint32_t inlen, uint8_t* outbuf, uint32_t outlen, uint32_t inpageoff);
+NTSTATUS zstd_decompress(uint8_t* inbuf, uint32_t inlen, uint8_t* outbuf, uint32_t outlen);
+NTSTATUS write_compressed_bit(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, bool* compressed, PIRP Irp, LIST_ENTRY* rollback);
 
 // in galois.c
-void galois_double(UINT8* data, UINT32 len);
-void galois_divpower(UINT8* data, UINT8 div, UINT32 readlen);
-UINT8 gpow2(UINT8 e);
-UINT8 gmul(UINT8 a, UINT8 b);
-UINT8 gdiv(UINT8 a, UINT8 b);
+void galois_double(uint8_t* data, uint32_t len);
+void galois_divpower(uint8_t* data, uint8_t div, uint32_t readlen);
+uint8_t gpow2(uint8_t e);
+uint8_t gmul(uint8_t a, uint8_t b);
+uint8_t gdiv(uint8_t a, uint8_t b);
 
 // in devctrl.c
 
 _Dispatch_type_(IRP_MJ_DEVICE_CONTROL)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_device_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
+NTSTATUS __stdcall drv_device_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 
 // in calcthread.c
 
 _Function_class_(KSTART_ROUTINE)
-#ifdef __REACTOS__
-void NTAPI calc_thread(void* context);
-#else
-void calc_thread(void* context);
-#endif
+void __stdcall calc_thread(void* context);
 
-NTSTATUS add_calc_job(device_extension* Vcb, UINT8* data, UINT32 sectors, UINT32* csum, calc_job** pcj);
+NTSTATUS add_calc_job(device_extension* Vcb, uint8_t* data, uint32_t sectors, uint32_t* csum, calc_job** pcj);
 void free_calc_job(calc_job* cj);
 
 // in balance.c
@@ -1581,11 +1522,7 @@ NTSTATUS look_for_balance_item(_Requires_lock_held_(_Curr_->tree_lock) device_ex
 NTSTATUS remove_device(device_extension* Vcb, void* data, ULONG length, KPROCESSOR_MODE processor_mode);
 
 _Function_class_(KSTART_ROUTINE)
-#ifdef __REACTOS__
-void NTAPI balance_thread(void* context);
-#else
-void balance_thread(void* context);
-#endif
+void __stdcall balance_thread(void* context);
 
 // in volume.c
 NTSTATUS vol_create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
@@ -1607,16 +1544,11 @@ NTSTATUS vol_device_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 NTSTATUS vol_shutdown(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 NTSTATUS vol_query_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
 NTSTATUS vol_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-NTSTATUS vol_power(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
-void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath, UINT64 length, ULONG disk_num, ULONG part_num);
+void add_volume_device(superblock* sb, PUNICODE_STRING devpath, uint64_t length, ULONG disk_num, ULONG part_num);
 NTSTATUS mountmgr_add_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath);
 
 _Function_class_(DRIVER_NOTIFICATION_CALLBACK_ROUTINE)
-#ifdef __REACTOS__
-NTSTATUS NTAPI pnp_removal(PVOID NotificationStructure, PVOID Context);
-#else
-NTSTATUS pnp_removal(PVOID NotificationStructure, PVOID Context);
-#endif
+NTSTATUS __stdcall pnp_removal(PVOID NotificationStructure, PVOID Context);
 
 // in scrub.c
 NTSTATUS start_scrub(device_extension* Vcb, KPROCESSOR_MODE processor_mode);
@@ -1629,8 +1561,14 @@ NTSTATUS stop_scrub(device_extension* Vcb, KPROCESSOR_MODE processor_mode);
 NTSTATUS send_subvol(device_extension* Vcb, void* data, ULONG datalen, PFILE_OBJECT FileObject, PIRP Irp);
 NTSTATUS read_send_buffer(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen, ULONG_PTR* retlen, KPROCESSOR_MODE processor_mode);
 
+// in fsrtl.c
+NTSTATUS compat_FsRtlValidateReparsePointBuffer(IN ULONG BufferLength, IN PREPARSE_DATA_BUFFER ReparseBuffer);
+
+// in boot.c
+void __stdcall check_system_root(PDRIVER_OBJECT DriverObject, PVOID Context, ULONG Count);
+
 // based on function in sys/sysmacros.h
-#define makedev(major, minor) (((minor) & 0xFF) | (((major) & 0xFFF) << 8) | (((UINT64)((minor) & ~0xFF)) << 12) | (((UINT64)((major) & ~0xFFF)) << 32))
+#define makedev(major, minor) (((minor) & 0xFF) | (((major) & 0xFFF) << 8) | (((uint64_t)((minor) & ~0xFF)) << 12) | (((uint64_t)((major) & ~0xFFF)) << 32))
 
 #define fast_io_possible(fcb) (!FsRtlAreThereCurrentFileLocks(&fcb->lock) && !fcb->Vcb->readonly ? FastIoIsPossible : FastIoIsQuestionable)
 
@@ -1639,32 +1577,32 @@ static __inline void print_open_trees(device_extension* Vcb) {
     while (le != &Vcb->trees) {
         tree* t = CONTAINING_RECORD(le, tree, list_entry);
         tree_data* td = CONTAINING_RECORD(t->itemlist.Flink, tree_data, list_entry);
-        ERR("tree %p: root %llx, level %u, first key (%llx,%x,%llx)\n",
+        ERR("tree %p: root %I64x, level %u, first key (%I64x,%x,%I64x)\n",
                       t, t->root->id, t->header.level, td->key.obj_id, td->key.obj_type, td->key.offset);
 
         le = le->Flink;
     }
 }
 
-static __inline BOOL write_fcb_compressed(fcb* fcb) {
+static __inline bool write_fcb_compressed(fcb* fcb) {
     // make sure we don't accidentally write the cache inodes or pagefile compressed
     if (fcb->subvol->id == BTRFS_ROOT_ROOT || fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE)
-        return FALSE;
+        return false;
 
     if (fcb->Vcb->options.compress_force)
-        return TRUE;
+        return true;
 
     if (fcb->inode_item.flags & BTRFS_INODE_NOCOMPRESS)
-        return FALSE;
+        return false;
 
     if (fcb->inode_item.flags & BTRFS_INODE_COMPRESS || fcb->Vcb->options.compress)
-        return TRUE;
+        return true;
 
-    return FALSE;
+    return false;
 }
 
-static __inline void do_xor(UINT8* buf1, UINT8* buf2, UINT32 len) {
-    UINT32 j;
+static __inline void do_xor(uint8_t* buf1, uint8_t* buf2, uint32_t len) {
+    uint32_t j;
 #ifndef __REACTOS__
     __m128i x1, x2;
 #endif
@@ -1786,10 +1724,10 @@ static __inline void do_xor(UINT8* buf1, UINT8* buf2, UINT32 len) {
 #endif
 
 // based on functions in sys/sysmacros.h
-#define major(rdev) ((((rdev) >> 8) & 0xFFF) | ((UINT32)((rdev) >> 32) & ~0xFFF))
-#define minor(rdev) (((rdev) & 0xFF) | ((UINT32)((rdev) >> 12) & ~0xFF))
+#define major(rdev) ((((rdev) >> 8) & 0xFFF) | ((uint32_t)((rdev) >> 32) & ~0xFFF))
+#define minor(rdev) (((rdev) & 0xFF) | ((uint32_t)((rdev) >> 12) & ~0xFF))
 
-static __inline UINT64 fcb_alloc_size(fcb* fcb) {
+static __inline uint64_t fcb_alloc_size(fcb* fcb) {
     if (S_ISDIR(fcb->inode_item.st_mode))
         return 0;
     else if (fcb->atts & FILE_ATTRIBUTE_SPARSE_FILE)
@@ -1813,17 +1751,26 @@ typedef BOOLEAN (*tCcCopyReadEx)(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOff
 #define CC_ENABLE_DISK_IO_ACCOUNTING 0x00000010
 #endif
 
+#if defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_VISTA)
+typedef struct _ECP_LIST ECP_LIST;
+typedef struct _ECP_LIST *PECP_LIST;
+#endif
+
 typedef VOID (*tCcSetAdditionalCacheAttributesEx)(PFILE_OBJECT FileObject, ULONG Flags);
 
 typedef VOID (*tFsRtlUpdateDiskCounters)(ULONG64 BytesRead, ULONG64 BytesWritten);
 
-#ifndef __REACTOS__
-#ifndef _MSC_VER
+typedef NTSTATUS (*tIoUnregisterPlugPlayNotificationEx)(PVOID NotificationEntry);
 
-#undef RtlIsNtDdiVersionAvailable
+typedef NTSTATUS (*tFsRtlGetEcpListFromIrp)(PIRP Irp, PECP_LIST* EcpList);
 
-BOOLEAN RtlIsNtDdiVersionAvailable(ULONG Version);
+typedef NTSTATUS (*tFsRtlGetNextExtraCreateParameter)(PECP_LIST EcpList, PVOID CurrentEcpContext, LPGUID NextEcpType,
+                                                      PVOID* NextEcpContext, ULONG* NextEcpContextSize);
 
+typedef NTSTATUS (*tFsRtlValidateReparsePointBuffer)(ULONG BufferLength, PREPARSE_DATA_BUFFER ReparseBuffer);
+
+#ifndef __REACTOS__
+#ifndef _MSC_VER
 PEPROCESS PsGetThreadProcess(_In_ PETHREAD Thread); // not in mingw
 #endif
 
@@ -1885,33 +1832,3 @@ NTSTATUS NTAPI ZwQueryInformationProcess(
 );
 #endif
 #endif
-
-#if defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_VISTA)
-typedef struct _ECP_LIST ECP_LIST;
-typedef struct _ECP_LIST *PECP_LIST;
-#endif
-
-#if defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_WIN7)
-NTSTATUS WINAPI RtlUnicodeToUTF8N(CHAR *utf8_dest, ULONG utf8_bytes_max,
-                                  ULONG *utf8_bytes_written,
-                                  const WCHAR *uni_src, ULONG uni_bytes);
-NTSTATUS WINAPI RtlUTF8ToUnicodeN(WCHAR *uni_dest, ULONG uni_bytes_max,
-                                  ULONG *uni_bytes_written,
-                                  const CHAR *utf8_src, ULONG utf8_bytes);
-#endif /* defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_WIN7) */
-#if defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_VISTA)
-NTSTATUS NTAPI FsRtlRemoveDotsFromPath(PWSTR OriginalString,
-                                       USHORT PathLength, USHORT *NewLength);
-NTSTATUS NTAPI FsRtlValidateReparsePointBuffer(ULONG BufferLength,
-                                               PREPARSE_DATA_BUFFER ReparseBuffer);
-ULONG NTAPI KeQueryActiveProcessorCount(PKAFFINITY ActiveProcessors);
-NTSTATUS NTAPI FsRtlGetEcpListFromIrp(IN PIRP Irp,
-                                      OUT PECP_LIST *EcpList);
-NTSTATUS NTAPI FsRtlGetNextExtraCreateParameter(IN PECP_LIST EcpList,
-                                                IN PVOID CurrentEcpContext,
-                                                OUT LPGUID NextEcpType OPTIONAL,
-                                                OUT PVOID *NextEcpContext,
-                                                OUT PULONG NextEcpContextSize OPTIONAL);
-#endif /* defined(__REACTOS__) && (NTDDI_VERSION < NTDDI_VISTA) */
-
-#endif
diff --git a/drivers/filesystems/btrfs/btrfsioctl.h b/drivers/filesystems/btrfs/btrfsioctl.h
index a7f53b33174..e08713119c6 100644
--- a/drivers/filesystems/btrfs/btrfsioctl.h
+++ b/drivers/filesystems/btrfs/btrfsioctl.h
@@ -1,7 +1,6 @@
 // No copyright claimed in this file - do what you want with it.
 
-#ifndef BTRFSIOCTL_H_DEFINED
-#define BTRFSIOCTL_H_DEFINED
+#pragma once
 
 #include "btrfs.h"
 
@@ -39,8 +38,8 @@
 #define FSCTL_BTRFS_RESIZE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x848, METHOD_IN_DIRECT, FILE_ANY_ACCESS)
 
 typedef struct {
-    UINT64 subvol;
-    UINT64 inode;
+    uint64_t subvol;
+    uint64_t inode;
     BOOL top;
 } btrfs_get_file_ids;
 
@@ -48,7 +47,7 @@ typedef struct {
     HANDLE subvol;
     BOOL readonly;
     BOOL posix;
-    UINT16 namelen;
+    uint16_t namelen;
     WCHAR name[1];
 } btrfs_create_snapshot;
 
@@ -56,7 +55,7 @@ typedef struct {
     void* POINTER_32 subvol;
     BOOL readonly;
     BOOL posix;
-    UINT16 namelen;
+    uint16_t namelen;
     WCHAR name[1];
 } btrfs_create_snapshot32;
 
@@ -66,77 +65,63 @@ typedef struct {
 #define BTRFS_COMPRESSION_ZSTD  3
 
 typedef struct {
-    UINT64 subvol;
-    UINT64 inode;
+    uint64_t subvol;
+    uint64_t inode;
     BOOL top;
-    UINT8 type;
-    UINT32 st_uid;
-    UINT32 st_gid;
-    UINT32 st_mode;
-    UINT64 st_rdev;
-    UINT64 flags;
-    UINT32 inline_length;
-    UINT64 disk_size[3];
-    UINT8 compression_type;
+    uint8_t type;
+    uint32_t st_uid;
+    uint32_t st_gid;
+    uint32_t st_mode;
+    uint64_t st_rdev;
+    uint64_t flags;
+    uint32_t inline_length;
+    uint64_t disk_size_uncompressed;
+    uint64_t disk_size_zlib;
+    uint64_t disk_size_lzo;
+    uint8_t compression_type;
+    uint64_t disk_size_zstd;
+    uint64_t sparse_size;
+    uint32_t num_extents;
 } btrfs_inode_info;
 
 typedef struct {
-    UINT64 subvol;
-    UINT64 inode;
-    BOOL top;
-    UINT8 type;
-    UINT32 st_uid;
-    UINT32 st_gid;
-    UINT32 st_mode;
-    UINT64 st_rdev;
-    UINT64 flags;
-    UINT32 inline_length;
-    UINT64 disk_size_uncompressed;
-    UINT64 disk_size_zlib;
-    UINT64 disk_size_lzo;
-    UINT8 compression_type;
-    UINT64 disk_size_zstd;
-    UINT64 sparse_size;
-} btrfs_inode_info2;
-
-typedef struct {
-    UINT64 flags;
+    uint64_t flags;
     BOOL flags_changed;
-    UINT32 st_uid;
+    uint32_t st_uid;
     BOOL uid_changed;
-    UINT32 st_gid;
+    uint32_t st_gid;
     BOOL gid_changed;
-    UINT32 st_mode;
+    uint32_t st_mode;
     BOOL mode_changed;
-    UINT8 compression_type;
+    uint8_t compression_type;
     BOOL compression_type_changed;
 } btrfs_set_inode_info;
 
 typedef struct {
-    UINT32 next_entry;
-    UINT64 dev_id;
-    UINT64 size;
-    UINT64 max_size;
+    uint32_t next_entry;
+    uint64_t dev_id;
+    uint64_t size;
+    uint64_t max_size;
     BOOL readonly;
     BOOL missing;
     ULONG device_number;
     ULONG partition_number;
-    UINT64 stats[5];
+    uint64_t stats[5];
     USHORT namelen;
     WCHAR name[1];
 } btrfs_device;
 
 typedef struct {
-    UINT64 dev_id;
-    UINT64 alloc;
+    uint64_t dev_id;
+    uint64_t alloc;
 } btrfs_usage_device;
 
 typedef struct {
-    UINT32 next_entry;
-    UINT64 type;
-    UINT64 size;
-    UINT64 used;
-    UINT64 num_devices;
+    uint32_t next_entry;
+    uint64_t type;
+    uint64_t size;
+    uint64_t used;
+    uint64_t num_devices;
     btrfs_usage_device devices[1];
 } btrfs_usage;
 
@@ -154,20 +139,20 @@ typedef struct {
 #define BLOCK_FLAG_SINGLE 0x1000000000000 // only used in balance
 
 typedef struct {
-    UINT64 flags;
-    UINT64 profiles;
-    UINT64 devid;
-    UINT64 drange_start;
-    UINT64 drange_end;
-    UINT64 vrange_start;
-    UINT64 vrange_end;
-    UINT64 limit_start;
-    UINT64 limit_end;
-    UINT16 stripes_start;
-    UINT16 stripes_end;
-    UINT8 usage_start;
-    UINT8 usage_end;
-    UINT64 convert;
+    uint64_t flags;
+    uint64_t profiles;
+    uint64_t devid;
+    uint64_t drange_start;
+    uint64_t drange_end;
+    uint64_t vrange_start;
+    uint64_t vrange_end;
+    uint64_t limit_start;
+    uint64_t limit_end;
+    uint16_t stripes_start;
+    uint16_t stripes_end;
+    uint8_t usage_start;
+    uint8_t usage_end;
+    uint64_t convert;
 } btrfs_balance_opts;
 
 #define BTRFS_BALANCE_STOPPED   0
@@ -178,9 +163,9 @@ typedef struct {
 #define BTRFS_BALANCE_SHRINKING 16
 
 typedef struct {
-    UINT32 status;
-    UINT64 chunks_left;
-    UINT64 total_chunks;
+    uint32_t status;
+    uint64_t chunks_left;
+    uint64_t total_chunks;
     NTSTATUS error;
     btrfs_balance_opts data_opts;
     btrfs_balance_opts metadata_opts;
@@ -192,16 +177,16 @@ typedef struct {
 } btrfs_start_balance;
 
 typedef struct {
-    UINT8 uuid[16];
+    uint8_t uuid[16];
     BOOL missing;
     USHORT name_length;
     WCHAR name[1];
 } btrfs_filesystem_device;
 
 typedef struct {
-    UINT32 next_entry;
-    UINT8 uuid[16];
-    UINT32 num_devices;
+    uint32_t next_entry;
+    uint8_t uuid[16];
+    uint32_t num_devices;
     btrfs_filesystem_device device;
 } btrfs_filesystem;
 
@@ -210,52 +195,52 @@ typedef struct {
 #define BTRFS_SCRUB_PAUSED      2
 
 typedef struct {
-    UINT32 next_entry;
-    UINT64 address;
-    UINT64 device;
+    uint32_t next_entry;
+    uint64_t address;
+    uint64_t device;
     BOOL recovered;
     BOOL is_metadata;
     BOOL parity;
 
     union {
         struct {
-            UINT64 subvol;
-            UINT64 offset;
-            UINT16 filename_length;
+            uint64_t subvol;
+            uint64_t offset;
+            uint16_t filename_length;
             WCHAR filename[1];
         } data;
 
         struct {
-            UINT64 root;
-            UINT8 level;
+            uint64_t root;
+            uint8_t level;
             KEY firstitem;
         } metadata;
     };
 } btrfs_scrub_error;
 
 typedef struct {
-    UINT32 status;
+    uint32_t status;
     LARGE_INTEGER start_time;
     LARGE_INTEGER finish_time;
-    UINT64 chunks_left;
-    UINT64 total_chunks;
-    UINT64 data_scrubbed;
-    UINT64 duration;
+    uint64_t chunks_left;
+    uint64_t total_chunks;
+    uint64_t data_scrubbed;
+    uint64_t duration;
     NTSTATUS error;
-    UINT32 num_errors;
+    uint32_t num_errors;
     btrfs_scrub_error errors;
 } btrfs_query_scrub;
 
 typedef struct {
-    UINT64 inode;
-    UINT8 type;
-    UINT64 st_rdev;
-    UINT16 namelen;
+    uint64_t inode;
+    uint8_t type;
+    uint64_t st_rdev;
+    uint16_t namelen;
     WCHAR name[1];
 } btrfs_mknod;
 
 typedef struct {
-    UINT64 generation;
+    uint64_t generation;
     BTRFS_UUID uuid;
 } btrfs_received_subvol;
 
@@ -274,7 +259,7 @@ typedef struct {
 
 typedef struct {
     BTRFS_UUID uuid;
-    UINT64 ctransid;
+    uint64_t ctransid;
 } btrfs_find_subvol;
 
 typedef struct {
@@ -290,8 +275,6 @@ typedef struct {
 } btrfs_send_subvol32;
 
 typedef struct {
-    UINT64 device;
-    UINT64 size;
+    uint64_t device;
+    uint64_t size;
 } btrfs_resize;
-
-#endif
diff --git a/drivers/filesystems/btrfs/cache.c b/drivers/filesystems/btrfs/cache.c
index 22d8d65c0d9..42ce02c03da 100644
--- a/drivers/filesystems/btrfs/cache.c
+++ b/drivers/filesystems/btrfs/cache.c
@@ -19,36 +19,28 @@
 
 CACHE_MANAGER_CALLBACKS* cache_callbacks;
 
-#ifdef __REACTOS__
-static BOOLEAN NTAPI acquire_for_lazy_write(PVOID Context, BOOLEAN Wait) {
-#else
-static BOOLEAN acquire_for_lazy_write(PVOID Context, BOOLEAN Wait) {
-#endif
+static BOOLEAN __stdcall acquire_for_lazy_write(PVOID Context, BOOLEAN Wait) {
     PFILE_OBJECT FileObject = Context;
     fcb* fcb = FileObject->FsContext;
 
     TRACE("(%p, %u)\n", Context, Wait);
 
     if (!ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, Wait))
-        return FALSE;
+        return false;
 
     if (!ExAcquireResourceExclusiveLite(fcb->Header.Resource, Wait)) {
         ExReleaseResourceLite(&fcb->Vcb->tree_lock);
-        return FALSE;
+        return false;
     }
 
     fcb->lazy_writer_thread = KeGetCurrentThread();
 
     IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 
-    return TRUE;
+    return true;
 }
 
-#ifdef __REACTOS__
-static void NTAPI release_from_lazy_write(PVOID Context) {
-#else
-static void release_from_lazy_write(PVOID Context) {
-#endif
+static void __stdcall release_from_lazy_write(PVOID Context) {
     PFILE_OBJECT FileObject = Context;
     fcb* fcb = FileObject->FsContext;
 
@@ -64,29 +56,21 @@ static void release_from_lazy_write(PVOID Context) {
         IoSetTopLevelIrp(NULL);
 }
 
-#ifdef __REACTOS__
-static BOOLEAN NTAPI acquire_for_read_ahead(PVOID Context, BOOLEAN Wait) {
-#else
-static BOOLEAN acquire_for_read_ahead(PVOID Context, BOOLEAN Wait) {
-#endif
+static BOOLEAN __stdcall acquire_for_read_ahead(PVOID Context, BOOLEAN Wait) {
     PFILE_OBJECT FileObject = Context;
     fcb* fcb = FileObject->FsContext;
 
     TRACE("(%p, %u)\n", Context, Wait);
 
     if (!ExAcquireResourceSharedLite(fcb->Header.Resource, Wait))
-        return FALSE;
+        return false;
 
     IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 
-    return TRUE;
+    return true;
 }
 
-#ifdef __REACTOS__
-static void NTAPI release_from_read_ahead(PVOID Context) {
-#else
-static void release_from_read_ahead(PVOID Context) {
-#endif
+static void __stdcall release_from_read_ahead(PVOID Context) {
     PFILE_OBJECT FileObject = Context;
     fcb* fcb = FileObject->FsContext;
 
diff --git a/drivers/filesystems/btrfs/calcthread.c b/drivers/filesystems/btrfs/calcthread.c
index 9bfb45a74c7..3784428f40f 100644
--- a/drivers/filesystems/btrfs/calcthread.c
+++ b/drivers/filesystems/btrfs/calcthread.c
@@ -19,7 +19,7 @@
 
 #define SECTOR_BLOCK 16
 
-NTSTATUS add_calc_job(device_extension* Vcb, UINT8* data, UINT32 sectors, UINT32* csum, calc_job** pcj) {
+NTSTATUS add_calc_job(device_extension* Vcb, uint8_t* data, uint32_t sectors, uint32_t* csum, calc_job** pcj) {
     calc_job* cj;
 
     cj = ExAllocatePoolWithTag(NonPagedPool, sizeof(calc_job), ALLOC_TAG);
@@ -34,13 +34,13 @@ NTSTATUS add_calc_job(device_extension* Vcb, UINT8* data, UINT32 sectors, UINT32
     cj->pos = 0;
     cj->done = 0;
     cj->refcount = 1;
-    KeInitializeEvent(&cj->event, NotificationEvent, FALSE);
+    KeInitializeEvent(&cj->event, NotificationEvent, false);
 
-    ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, true);
 
     InsertTailList(&Vcb->calcthreads.job_list, &cj->list_entry);
 
-    KeSetEvent(&Vcb->calcthreads.event, 0, FALSE);
+    KeSetEvent(&Vcb->calcthreads.event, 0, false);
     KeClearEvent(&Vcb->calcthreads.event);
 
     ExReleaseResourceLite(&Vcb->calcthreads.lock);
@@ -57,16 +57,16 @@ void free_calc_job(calc_job* cj) {
         ExFreePool(cj);
 }
 
-static BOOL do_calc(device_extension* Vcb, calc_job* cj) {
+static bool do_calc(device_extension* Vcb, calc_job* cj) {
     LONG pos, done;
-    UINT32* csum;
-    UINT8* data;
+    uint32_t* csum;
+    uint8_t* data;
     ULONG blocksize, i;
 
     pos = InterlockedIncrement(&cj->pos) - 1;
 
-    if ((UINT32)pos * SECTOR_BLOCK >= cj->sectors)
-        return FALSE;
+    if ((uint32_t)pos * SECTOR_BLOCK >= cj->sectors)
+        return false;
 
     csum = &cj->csum[pos * SECTOR_BLOCK];
     data = cj->data + (pos * SECTOR_BLOCK * Vcb->superblock.sector_size);
@@ -80,36 +80,32 @@ static BOOL do_calc(device_extension* Vcb, calc_job* cj) {
 
     done = InterlockedIncrement(&cj->done);
 
-    if ((UINT32)done * SECTOR_BLOCK >= cj->sectors) {
-        ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, TRUE);
+    if ((uint32_t)done * SECTOR_BLOCK >= cj->sectors) {
+        ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, true);
         RemoveEntryList(&cj->list_entry);
         ExReleaseResourceLite(&Vcb->calcthreads.lock);
 
-        KeSetEvent(&cj->event, 0, FALSE);
+        KeSetEvent(&cj->event, 0, false);
     }
 
-    return TRUE;
+    return true;
 }
 
 _Function_class_(KSTART_ROUTINE)
-#ifdef __REACTOS__
-void NTAPI calc_thread(void* context) {
-#else
-void calc_thread(void* context) {
-#endif
+void __stdcall calc_thread(void* context) {
     drv_calc_thread* thread = context;
     device_extension* Vcb = thread->DeviceObject->DeviceExtension;
 
     ObReferenceObject(thread->DeviceObject);
 
-    while (TRUE) {
-        KeWaitForSingleObject(&Vcb->calcthreads.event, Executive, KernelMode, FALSE, NULL);
+    while (true) {
+        KeWaitForSingleObject(&Vcb->calcthreads.event, Executive, KernelMode, false, NULL);
 
-        while (TRUE) {
+        while (true) {
             calc_job* cj;
-            BOOL b;
+            bool b;
 
-            ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, TRUE);
+            ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, true);
 
             if (IsListEmpty(&Vcb->calcthreads.job_list)) {
                 ExReleaseResourceLite(&Vcb->calcthreads.lock);
@@ -135,7 +131,7 @@ void calc_thread(void* context) {
 
     ObDereferenceObject(thread->DeviceObject);
 
-    KeSetEvent(&thread->finished, 0, FALSE);
+    KeSetEvent(&thread->finished, 0, false);
 
     PsTerminateSystemThread(STATUS_SUCCESS);
 }
diff --git a/drivers/filesystems/btrfs/compress.c b/drivers/filesystems/btrfs/compress.c
index 3c9a4d63866..56ac3c5621a 100644
--- a/drivers/filesystems/btrfs/compress.c
+++ b/drivers/filesystems/btrfs/compress.c
@@ -43,20 +43,20 @@
 
 #include "zstd/zstd.h"
 
-#define LINUX_PAGE_SIZE 4096
+#define LZO_PAGE_SIZE 4096
 
 typedef struct {
-    UINT8* in;
-    UINT32 inlen;
-    UINT32 inpos;
-    UINT8* out;
-    UINT32 outlen;
-    UINT32 outpos;
-    BOOL error;
+    uint8_t* in;
+    uint32_t inlen;
+    uint32_t inpos;
+    uint8_t* out;
+    uint32_t outlen;
+    uint32_t outpos;
+    bool error;
     void* wrkmem;
 } lzo_stream;
 
-#define LZO1X_MEM_COMPRESS ((UINT32) (16384L * sizeof(UINT8*)))
+#define LZO1X_MEM_COMPRESS ((uint32_t) (16384L * sizeof(uint8_t*)))
 
 #define M1_MAX_OFFSET 0x0400
 #define M2_MAX_OFFSET 0x0800
@@ -70,8 +70,8 @@ typedef struct {
 #define M3_MARKER 32
 #define M4_MARKER 16
 
-#define _DV2(p, shift1, shift2) (((( (UINT32)(p[2]) << shift1) ^ p[1]) << shift2) ^ p[0])
-#define DVAL_NEXT(dv, p) dv ^= p[-1]; dv = (((dv) >> 5) ^ ((UINT32)(p[2]) << (2*5)))
+#define _DV2(p, shift1, shift2) (((( (uint32_t)(p[2]) << shift1) ^ p[1]) << shift2) ^ p[0])
+#define DVAL_NEXT(dv, p) dv ^= p[-1]; dv = (((dv) >> 5) ^ ((uint32_t)(p[2]) << (2*5)))
 #define _DV(p, shift) _DV2(p, shift, shift)
 #define DVAL_FIRST(dv, p) dv = _DV((p), 5)
 #define _DINDEX(dv, p) ((40799u * (dv)) >> 5)
@@ -81,7 +81,7 @@ typedef struct {
 
 #define LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, max_offset) \
     ((void*) m_pos < (void*) in || \
-    (m_off = (UINT8*) ip - (UINT8*) m_pos) <= 0 || \
+    (m_off = (uint8_t*) ip - (uint8_t*) m_pos) <= 0 || \
     m_off > max_offset)
 
 #define LZO_BYTE(x) ((unsigned char) (x))
@@ -100,11 +100,11 @@ ZSTD_customMem zstd_mem = { .customAlloc = zstd_malloc, .customFree = zstd_free,
 ZSTD_customMem zstd_mem = { zstd_malloc, zstd_free, NULL };
 #endif
 
-static UINT8 lzo_nextbyte(lzo_stream* stream) {
-    UINT8 c;
+static uint8_t lzo_nextbyte(lzo_stream* stream) {
+    uint8_t c;
 
     if (stream->inpos >= stream->inlen) {
-        stream->error = TRUE;
+        stream->error = true;
         return 0;
     }
 
@@ -132,12 +132,12 @@ static int lzo_len(lzo_stream* stream, int byte, int mask) {
 
 static void lzo_copy(lzo_stream* stream, int len) {
     if (stream->inpos + len > stream->inlen) {
-        stream->error = TRUE;
+        stream->error = true;
         return;
     }
 
     if (stream->outpos + len > stream->outlen) {
-        stream->error = TRUE;
+        stream->error = true;
         return;
     }
 
@@ -149,14 +149,14 @@ static void lzo_copy(lzo_stream* stream, int len) {
     } while (len > 0);
 }
 
-static void lzo_copyback(lzo_stream* stream, UINT32 back, int len) {
+static void lzo_copyback(lzo_stream* stream, uint32_t back, int len) {
     if (stream->outpos < back) {
-        stream->error = TRUE;
+        stream->error = true;
         return;
     }
 
     if (stream->outpos + len > stream->outlen) {
-        stream->error = TRUE;
+        stream->error = true;
         return;
     }
 
@@ -168,17 +168,17 @@ static void lzo_copyback(lzo_stream* stream, UINT32 back, int len) {
 }
 
 static NTSTATUS do_lzo_decompress(lzo_stream* stream) {
-    UINT8 byte;
-    UINT32 len, back;
-    BOOL backcopy = FALSE;
+    uint8_t byte;
+    uint32_t len, back;
+    bool backcopy = false;
 
-    stream->error = FALSE;
+    stream->error = false;
 
     byte = lzo_nextbyte(stream);
     if (stream->error) return STATUS_INTERNAL_ERROR;
 
     if (byte > 17) {
-        lzo_copy(stream, min((UINT8)(byte - 17), (UINT32)(stream->outlen - stream->outpos)));
+        lzo_copy(stream, min((uint8_t)(byte - 17), (uint32_t)(stream->outlen - stream->outpos)));
         if (stream->error) return STATUS_INTERNAL_ERROR;
 
         if (stream->outlen == stream->outpos)
@@ -192,7 +192,7 @@ static NTSTATUS do_lzo_decompress(lzo_stream* stream) {
 
     while (1) {
         if (byte >> 4) {
-            backcopy = TRUE;
+            backcopy = true;
             if (byte >> 6) {
                 len = (byte >> 5) - 1;
                 back = (lzo_nextbyte(stream) << 3) + ((byte >> 2) & 7) + 1;
@@ -275,29 +275,29 @@ static NTSTATUS do_lzo_decompress(lzo_stream* stream) {
     return STATUS_SUCCESS;
 }
 
-NTSTATUS lzo_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen, UINT32 inpageoff) {
+NTSTATUS lzo_decompress(uint8_t* inbuf, uint32_t inlen, uint8_t* outbuf, uint32_t outlen, uint32_t inpageoff) {
     NTSTATUS Status;
-    UINT32 partlen, inoff, outoff;
+    uint32_t partlen, inoff, outoff;
     lzo_stream stream;
 
     inoff = 0;
     outoff = 0;
 
     do {
-        partlen = *(UINT32*)&inbuf[inoff];
+        partlen = *(uint32_t*)&inbuf[inoff];
 
         if (partlen + inoff > inlen) {
-            ERR("overflow: %x + %x > %llx\n", partlen, inoff, inlen);
+            ERR("overflow: %x + %x > %I64x\n", partlen, inoff, inlen);
             return STATUS_INTERNAL_ERROR;
         }
 
-        inoff += sizeof(UINT32);
+        inoff += sizeof(uint32_t);
 
         stream.in = &inbuf[inoff];
         stream.inlen = partlen;
         stream.inpos = 0;
         stream.out = &outbuf[outoff];
-        stream.outlen = min(outlen, LINUX_PAGE_SIZE);
+        stream.outlen = min(outlen, LZO_PAGE_SIZE);
         stream.outpos = 0;
 
         Status = do_lzo_decompress(&stream);
@@ -312,8 +312,8 @@ NTSTATUS lzo_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen
         inoff += partlen;
         outoff += stream.outlen;
 
-        if (LINUX_PAGE_SIZE - ((inpageoff + inoff) % LINUX_PAGE_SIZE) < sizeof(UINT32))
-            inoff = ((((inpageoff + inoff) / LINUX_PAGE_SIZE) + 1) * LINUX_PAGE_SIZE) - inpageoff;
+        if (LZO_PAGE_SIZE - ((inpageoff + inoff) % LZO_PAGE_SIZE) < sizeof(uint32_t))
+            inoff = ((((inpageoff + inoff) / LZO_PAGE_SIZE) + 1) * LZO_PAGE_SIZE) - inpageoff;
 
         outlen -= stream.outlen;
     } while (inoff < inlen && outlen > 0);
@@ -333,7 +333,7 @@ static void zlib_free(void* opaque, void* ptr) {
     ExFreePool(ptr);
 }
 
-NTSTATUS zlib_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen) {
+NTSTATUS zlib_decompress(uint8_t* inbuf, uint32_t inlen, uint8_t* outbuf, uint32_t outlen) {
     z_stream c_stream;
     int ret;
 
@@ -379,18 +379,18 @@ NTSTATUS zlib_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outle
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback) {
+static NTSTATUS zlib_write_compressed_bit(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, bool* compressed, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
-    UINT8 compression;
-    UINT32 comp_length;
-    UINT8* comp_data;
-    UINT32 out_left;
+    uint8_t compression;
+    uint32_t comp_length;
+    uint8_t* comp_data;
+    uint32_t out_left;
     LIST_ENTRY* le;
     chunk* c;
     z_stream c_stream;
     int ret;
 
-    comp_data = ExAllocatePoolWithTag(PagedPool, (UINT32)(end_data - start_data), ALLOC_TAG);
+    comp_data = ExAllocatePoolWithTag(PagedPool, (uint32_t)(end_data - start_data), ALLOC_TAG);
     if (!comp_data) {
         ERR("out of memory\n");
         return STATUS_INSUFFICIENT_RESOURCES;
@@ -415,9 +415,9 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
         return STATUS_INTERNAL_ERROR;
     }
 
-    c_stream.avail_in = (UINT32)(end_data - start_data);
+    c_stream.avail_in = (uint32_t)(end_data - start_data);
     c_stream.next_in = data;
-    c_stream.avail_out = (UINT32)(end_data - start_data);
+    c_stream.avail_out = (uint32_t)(end_data - start_data);
     c_stream.next_out = comp_data;
 
     do {
@@ -443,24 +443,24 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
     if (out_left < fcb->Vcb->superblock.sector_size) { // compressed extent would be larger than or same size as uncompressed extent
         ExFreePool(comp_data);
 
-        comp_length = (UINT32)(end_data - start_data);
+        comp_length = (uint32_t)(end_data - start_data);
         comp_data = data;
         compression = BTRFS_COMPRESSION_NONE;
 
-        *compressed = FALSE;
+        *compressed = false;
     } else {
-        UINT32 cl;
+        uint32_t cl;
 
         compression = BTRFS_COMPRESSION_ZLIB;
-        cl = (UINT32)(end_data - start_data - out_left);
-        comp_length = (UINT32)sector_align(cl, fcb->Vcb->superblock.sector_size);
+        cl = (uint32_t)(end_data - start_data - out_left);
+        comp_length = (uint32_t)sector_align(cl, fcb->Vcb->superblock.sector_size);
 
         RtlZeroMemory(comp_data + cl, comp_length - cl);
 
-        *compressed = TRUE;
+        *compressed = true;
     }
 
-    ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, true);
 
     le = fcb->Vcb->chunks.Flink;
     while (le != &fcb->Vcb->chunks) {
@@ -470,7 +470,7 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
             acquire_chunk_lock(c, fcb->Vcb);
 
             if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
-                if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
+                if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
                     ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
                     if (compression != BTRFS_COMPRESSION_NONE)
@@ -488,9 +488,9 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
 
     ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
-    ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, true);
 
-    Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, FALSE);
+    Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, false);
 
     ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
@@ -507,7 +507,7 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
         acquire_chunk_lock(c, fcb->Vcb);
 
         if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
-            if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
+            if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
                 if (compression != BTRFS_COMPRESSION_NONE)
                     ExFreePool(comp_data);
 
@@ -518,7 +518,7 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
         release_chunk_lock(c, fcb->Vcb);
     }
 
-    WARN("couldn't find any data chunks with %llx bytes free\n", comp_length);
+    WARN("couldn't find any data chunks with %I64x bytes free\n", comp_length);
 
     if (compression != BTRFS_COMPRESSION_NONE)
         ExFreePool(comp_data);
@@ -526,14 +526,14 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
     return STATUS_DISK_FULL;
 }
 
-static NTSTATUS lzo_do_compress(const UINT8* in, UINT32 in_len, UINT8* out, UINT32* out_len, void* wrkmem) {
-    const UINT8* ip;
-    UINT32 dv;
-    UINT8* op;
-    const UINT8* in_end = in + in_len;
-    const UINT8* ip_end = in + in_len - 9 - 4;
-    const UINT8* ii;
-    const UINT8** dict = (const UINT8**)wrkmem;
+static NTSTATUS lzo_do_compress(const uint8_t* in, uint32_t in_len, uint8_t* out, uint32_t* out_len, void* wrkmem) {
+    const uint8_t* ip;
+    uint32_t dv;
+    uint8_t* op;
+    const uint8_t* in_end = in + in_len;
+    const uint8_t* ip_end = in + in_len - 9 - 4;
+    const uint8_t* ii;
+    const uint8_t** dict = (const uint8_t**)wrkmem;
 
     op = out;
     ip = in;
@@ -545,17 +545,17 @@ static NTSTATUS lzo_do_compress(const UINT8* in, UINT32 in_len, UINT8* out, UINT
     DVAL_NEXT(dv, ip);  UPDATE_D(dict, cycle, dv, ip); ip++;
 
     while (1) {
-        const UINT8* m_pos;
-        UINT32 m_len;
+        const uint8_t* m_pos;
+        uint32_t m_len;
         ptrdiff_t m_off;
-        UINT32 lit, dindex;
+        uint32_t lit, dindex;
 
         dindex = DINDEX(dv, ip);
         m_pos = dict[dindex];
         UPDATE_I(dict, cycle, dindex, ip);
 
         if (!LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M4_MAX_OFFSET) && m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2]) {
-            lit = (UINT32)(ip - ii);
+            lit = (uint32_t)(ip - ii);
             m_pos += 3;
             if (m_off <= M2_MAX_OFFSET)
                 goto match;
@@ -584,7 +584,7 @@ static NTSTATUS lzo_do_compress(const UINT8* in, UINT32 in_len, UINT8* out, UINT
 match:
         /* store current literal run */
         if (lit > 0) {
-            UINT32 t = lit;
+            uint32_t t = lit;
 
             if (t <= 3) {
                 if (op - 2 <= out)
@@ -594,7 +594,7 @@ match:
             } else if (t <= 18)
                 *op++ = LZO_BYTE(t - 3);
             else {
-                UINT32 tt = t - 18;
+                uint32_t tt = t - 18;
 
                 *op++ = 0;
                 while (tt > 255) {
@@ -623,7 +623,7 @@ code_match:
         if (*m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++ ||
             *m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++) {
             --ip;
-            m_len = (UINT32)(ip - ii);
+            m_len = (uint32_t)(ip - ii);
 
             if (m_len < 3 || m_len > 8)
                 return STATUS_INTERNAL_ERROR;
@@ -646,11 +646,11 @@ code_match:
                 goto m3_m4_offset;
             }
         } else {
-            const UINT8* end;
+            const uint8_t* end;
             end = in_end;
             while (ip < end && *m_pos == *ip)
                 m_pos++, ip++;
-            m_len = (UINT32)(ip - ii);
+            m_len = (uint32_t)(ip - ii);
 
             if (m_len < 3)
                 return STATUS_INTERNAL_ERROR;
@@ -701,7 +701,7 @@ m3_m4_offset:
 
     /* store final literal run */
     if (in_end - ii > 0) {
-        UINT32 t = (UINT32)(in_end - ii);
+        uint32_t t = (uint32_t)(in_end - ii);
 
         if (op == out && t <= 238)
             *op++ = LZO_BYTE(17 + t);
@@ -710,7 +710,7 @@ m3_m4_offset:
         else if (t <= 18)
             *op++ = LZO_BYTE(t - 3);
         else {
-            UINT32 tt = t - 18;
+            uint32_t tt = t - 18;
 
             *op++ = 0;
             while (tt > 255) {
@@ -729,13 +729,13 @@ m3_m4_offset:
         } while (--t > 0);
     }
 
-    *out_len = (UINT32)(op - out);
+    *out_len = (uint32_t)(op - out);
 
     return STATUS_SUCCESS;
 }
 
 static NTSTATUS lzo1x_1_compress(lzo_stream* stream) {
-    UINT8 *op = stream->out;
+    uint8_t *op = stream->out;
     NTSTATUS Status = STATUS_SUCCESS;
 
     if (stream->inlen <= 0)
@@ -748,7 +748,7 @@ static NTSTATUS lzo1x_1_compress(lzo_stream* stream) {
             *op++ = stream->in[stream->inpos];
             stream->inpos++;
         } while (stream->inlen < stream->inpos);
-        stream->outlen = (UINT32)(op - stream->out);
+        stream->outlen = (uint32_t)(op - stream->out);
     } else
         Status = lzo_do_compress(stream->in, stream->inlen, stream->out, &stream->outlen, stream->wrkmem);
 
@@ -763,29 +763,29 @@ static NTSTATUS lzo1x_1_compress(lzo_stream* stream) {
     return Status;
 }
 
-static __inline UINT32 lzo_max_outlen(UINT32 inlen) {
+static __inline uint32_t lzo_max_outlen(uint32_t inlen) {
     return inlen + (inlen / 16) + 64 + 3; // formula comes from LZO.FAQ
 }
 
-static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback) {
+static NTSTATUS lzo_write_compressed_bit(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, bool* compressed, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
-    UINT8 compression;
-    UINT64 comp_length;
+    uint8_t compression;
+    uint64_t comp_length;
     ULONG comp_data_len, num_pages, i;
-    UINT8* comp_data;
-    BOOL skip_compression = FALSE;
+    uint8_t* comp_data;
+    bool skip_compression = false;
     lzo_stream stream;
-    UINT32* out_size;
+    uint32_t* out_size;
     LIST_ENTRY* le;
     chunk* c;
 
-    num_pages = (ULONG)((sector_align(end_data - start_data, LINUX_PAGE_SIZE)) / LINUX_PAGE_SIZE);
+    num_pages = (ULONG)((sector_align(end_data - start_data, LZO_PAGE_SIZE)) / LZO_PAGE_SIZE);
 
     // Four-byte overall header
     // Another four-byte header page
-    // Each page has a maximum size of lzo_max_outlen(LINUX_PAGE_SIZE)
+    // Each page has a maximum size of lzo_max_outlen(LZO_PAGE_SIZE)
     // Plus another four bytes for possible padding
-    comp_data_len = sizeof(UINT32) + ((lzo_max_outlen(LINUX_PAGE_SIZE) + (2 * sizeof(UINT32))) * num_pages);
+    comp_data_len = sizeof(uint32_t) + ((lzo_max_outlen(LZO_PAGE_SIZE) + (2 * sizeof(uint32_t))) * num_pages);
 
     comp_data = ExAllocatePoolWithTag(PagedPool, comp_data_len, ALLOC_TAG);
     if (!comp_data) {
@@ -808,34 +808,34 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
         return Status;
     }
 
-    out_size = (UINT32*)comp_data;
-    *out_size = sizeof(UINT32);
+    out_size = (uint32_t*)comp_data;
+    *out_size = sizeof(uint32_t);
 
     stream.in = data;
-    stream.out = comp_data + (2 * sizeof(UINT32));
+    stream.out = comp_data + (2 * sizeof(uint32_t));
 
     for (i = 0; i < num_pages; i++) {
-        UINT32* pagelen = (UINT32*)(stream.out - sizeof(UINT32));
+        uint32_t* pagelen = (uint32_t*)(stream.out - sizeof(uint32_t));
 
-        stream.inlen = (UINT32)min(LINUX_PAGE_SIZE, end_data - start_data - (i * LINUX_PAGE_SIZE));
+        stream.inlen = (uint32_t)min(LZO_PAGE_SIZE, end_data - start_data - (i * LZO_PAGE_SIZE));
 
         Status = lzo1x_1_compress(&stream);
         if (!NT_SUCCESS(Status)) {
             ERR("lzo1x_1_compress returned %08x\n", Status);
-            skip_compression = TRUE;
+            skip_compression = true;
             break;
         }
 
         *pagelen = stream.outlen;
-        *out_size += stream.outlen + sizeof(UINT32);
+        *out_size += stream.outlen + sizeof(uint32_t);
 
-        stream.in += LINUX_PAGE_SIZE;
-        stream.out += stream.outlen + sizeof(UINT32);
+        stream.in += LZO_PAGE_SIZE;
+        stream.out += stream.outlen + sizeof(uint32_t);
 
-        if (LINUX_PAGE_SIZE - (*out_size % LINUX_PAGE_SIZE) < sizeof(UINT32)) {
-            RtlZeroMemory(stream.out, LINUX_PAGE_SIZE - (*out_size % LINUX_PAGE_SIZE));
-            stream.out += LINUX_PAGE_SIZE - (*out_size % LINUX_PAGE_SIZE);
-            *out_size += LINUX_PAGE_SIZE - (*out_size % LINUX_PAGE_SIZE);
+        if (LZO_PAGE_SIZE - (*out_size % LZO_PAGE_SIZE) < sizeof(uint32_t)) {
+            RtlZeroMemory(stream.out, LZO_PAGE_SIZE - (*out_size % LZO_PAGE_SIZE));
+            stream.out += LZO_PAGE_SIZE - (*out_size % LZO_PAGE_SIZE);
+            *out_size += LZO_PAGE_SIZE - (*out_size % LZO_PAGE_SIZE);
         }
     }
 
@@ -848,17 +848,17 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
         comp_data = data;
         compression = BTRFS_COMPRESSION_NONE;
 
-        *compressed = FALSE;
+        *compressed = false;
     } else {
         compression = BTRFS_COMPRESSION_LZO;
         comp_length = sector_align(*out_size, fcb->Vcb->superblock.sector_size);
 
         RtlZeroMemory(comp_data + *out_size, (ULONG)(comp_length - *out_size));
 
-        *compressed = TRUE;
+        *compressed = true;
     }
 
-    ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, true);
 
     le = fcb->Vcb->chunks.Flink;
     while (le != &fcb->Vcb->chunks) {
@@ -868,7 +868,7 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
             acquire_chunk_lock(c, fcb->Vcb);
 
             if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
-                if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
+                if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
                     ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
                     if (compression != BTRFS_COMPRESSION_NONE)
@@ -886,9 +886,9 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
 
     ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
-    ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, true);
 
-    Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, FALSE);
+    Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, false);
 
     ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
@@ -905,7 +905,7 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
         acquire_chunk_lock(c, fcb->Vcb);
 
         if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
-            if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
+            if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
                 if (compression != BTRFS_COMPRESSION_NONE)
                     ExFreePool(comp_data);
 
@@ -916,7 +916,7 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
         release_chunk_lock(c, fcb->Vcb);
     }
 
-    WARN("couldn't find any data chunks with %llx bytes free\n", comp_length);
+    WARN("couldn't find any data chunks with %I64x bytes free\n", comp_length);
 
     if (compression != BTRFS_COMPRESSION_NONE)
         ExFreePool(comp_data);
@@ -924,12 +924,12 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
     return STATUS_DISK_FULL;
 }
 
-static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback) {
+static NTSTATUS zstd_write_compressed_bit(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, bool* compressed, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
-    UINT8 compression;
-    UINT32 comp_length;
-    UINT8* comp_data;
-    UINT32 out_left;
+    uint8_t compression;
+    uint32_t comp_length;
+    uint8_t* comp_data;
+    uint32_t out_left;
     LIST_ENTRY* le;
     chunk* c;
     ZSTD_CStream* stream;
@@ -938,7 +938,7 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
     ZSTD_outBuffer output;
     ZSTD_parameters params;
 
-    comp_data = ExAllocatePoolWithTag(PagedPool, (UINT32)(end_data - start_data), ALLOC_TAG);
+    comp_data = ExAllocatePoolWithTag(PagedPool, (uint32_t)(end_data - start_data), ALLOC_TAG);
     if (!comp_data) {
         ERR("out of memory\n");
         return STATUS_INSUFFICIENT_RESOURCES;
@@ -959,12 +959,12 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
         return STATUS_INTERNAL_ERROR;
     }
 
-    params = ZSTD_getParams(fcb->Vcb->options.zstd_level, (UINT32)(end_data - start_data), 0);
+    params = ZSTD_getParams(fcb->Vcb->options.zstd_level, (uint32_t)(end_data - start_data), 0);
 
     if (params.cParams.windowLog > ZSTD_BTRFS_MAX_WINDOWLOG)
         params.cParams.windowLog = ZSTD_BTRFS_MAX_WINDOWLOG;
 
-    init_res = ZSTD_initCStream_advanced(stream, NULL, 0, params, (UINT32)(end_data - start_data));
+    init_res = ZSTD_initCStream_advanced(stream, NULL, 0, params, (uint32_t)(end_data - start_data));
 
     if (ZSTD_isError(init_res)) {
         ERR("ZSTD_initCStream_advanced failed: %s\n", ZSTD_getErrorName(init_res));
@@ -974,11 +974,11 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
     }
 
     input.src = data;
-    input.size = (UINT32)(end_data - start_data);
+    input.size = (uint32_t)(end_data - start_data);
     input.pos = 0;
 
     output.dst = comp_data;
-    output.size = (UINT32)(end_data - start_data);
+    output.size = (uint32_t)(end_data - start_data);
     output.pos = 0;
 
     while (input.pos < input.size && output.pos < output.size) {
@@ -1007,24 +1007,24 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
     if (out_left < fcb->Vcb->superblock.sector_size) { // compressed extent would be larger than or same size as uncompressed extent
         ExFreePool(comp_data);
 
-        comp_length = (UINT32)(end_data - start_data);
+        comp_length = (uint32_t)(end_data - start_data);
         comp_data = data;
         compression = BTRFS_COMPRESSION_NONE;
 
-        *compressed = FALSE;
+        *compressed = false;
     } else {
-        UINT32 cl;
+        uint32_t cl;
 
         compression = BTRFS_COMPRESSION_ZSTD;
-        cl = (UINT32)(end_data - start_data - out_left);
-        comp_length = (UINT32)sector_align(cl, fcb->Vcb->superblock.sector_size);
+        cl = (uint32_t)(end_data - start_data - out_left);
+        comp_length = (uint32_t)sector_align(cl, fcb->Vcb->superblock.sector_size);
 
         RtlZeroMemory(comp_data + cl, comp_length - cl);
 
-        *compressed = TRUE;
+        *compressed = true;
     }
 
-    ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, true);
 
     le = fcb->Vcb->chunks.Flink;
     while (le != &fcb->Vcb->chunks) {
@@ -1034,7 +1034,7 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
             acquire_chunk_lock(c, fcb->Vcb);
 
             if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
-                if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
+                if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
                     ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
                     if (compression != BTRFS_COMPRESSION_NONE)
@@ -1052,9 +1052,9 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
 
     ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
-    ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, true);
 
-    Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, FALSE);
+    Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, false);
 
     ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
@@ -1071,7 +1071,7 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
         acquire_chunk_lock(c, fcb->Vcb);
 
         if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
-            if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
+            if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
                 if (compression != BTRFS_COMPRESSION_NONE)
                     ExFreePool(comp_data);
 
@@ -1082,7 +1082,7 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
         release_chunk_lock(c, fcb->Vcb);
     }
 
-    WARN("couldn't find any data chunks with %llx bytes free\n", comp_length);
+    WARN("couldn't find any data chunks with %I64x bytes free\n", comp_length);
 
     if (compression != BTRFS_COMPRESSION_NONE)
         ExFreePool(comp_data);
@@ -1090,8 +1090,8 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
     return STATUS_DISK_FULL;
 }
 
-NTSTATUS write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback) {
-    UINT8 type;
+NTSTATUS write_compressed_bit(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, bool* compressed, PIRP Irp, LIST_ENTRY* rollback) {
+    uint8_t type;
 
     if (fcb->Vcb->options.compress_type != 0 && fcb->prop_compression == PropCompression_None)
         type = fcb->Vcb->options.compress_type;
@@ -1130,7 +1130,7 @@ static void zstd_free(void* opaque, void* address) {
     ExFreePool(address);
 }
 
-NTSTATUS zstd_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen) {
+NTSTATUS zstd_decompress(uint8_t* inbuf, uint32_t inlen, uint8_t* outbuf, uint32_t outlen) {
     NTSTATUS Status;
     ZSTD_DStream* stream;
     size_t init_res, read;
diff --git a/drivers/filesystems/btrfs/crc32c.c b/drivers/filesystems/btrfs/crc32c.c
index e3ef75c9fbd..8d09cad0faf 100644
--- a/drivers/filesystems/btrfs/crc32c.c
+++ b/drivers/filesystems/btrfs/crc32c.c
@@ -18,11 +18,15 @@
 #include <windef.h>
 #ifndef __REACTOS__
 #include <smmintrin.h>
+#endif /* __REACTOS__ */
+#include <stdint.h>
+#include <stdbool.h>
 
-extern BOOL have_sse42;
+#ifndef __REACTOS__
+extern bool have_sse42;
 #endif /* __REACTOS__ */
 
-static const UINT32 crctable[] = {
+static const uint32_t crctable[] = {
     0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
     0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24,
     0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
@@ -68,7 +72,7 @@ static const UINT32 crctable[] = {
     }                                                                   \
   } while(0)
 
-static UINT32 crc32c_hw(const void *input, ULONG len, UINT32 crc) {
+static uint32_t crc32c_hw(const void *input, ULONG len, uint32_t crc) {
     const char* buf = (const char*)input;
 
     // Annoyingly, the CRC32 intrinsics don't work properly in modern versions of MSVC -
@@ -86,31 +90,31 @@ static UINT32 crc32c_hw(const void *input, ULONG len, UINT32 crc) {
 #ifdef _AMD64_
 #ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning(disable:4244) // _mm_crc32_u64 wants to return UINT64(!)
+#pragma warning(disable:4244) // _mm_crc32_u64 wants to return uint64_t(!)
 #pragma warning(disable:4242)
 #endif
-    CALC_CRC(_mm_crc32_u64, crc, UINT64, buf, len);
+    CALC_CRC(_mm_crc32_u64, crc, uint64_t, buf, len);
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 #endif
-    CALC_CRC(_mm_crc32_u32, crc, UINT32, buf, len);
+    CALC_CRC(_mm_crc32_u32, crc, uint32_t, buf, len);
 
 #ifdef _MSC_VER
     for (; len > 0; len--, buf++) {
         crc = crctable[(crc ^ *buf) & 0xff] ^ (crc >> 8);
     }
 #else
-    CALC_CRC(_mm_crc32_u16, crc, UINT16, buf, len);
-    CALC_CRC(_mm_crc32_u8, crc, UINT8, buf, len);
+    CALC_CRC(_mm_crc32_u16, crc, uint16_t, buf, len);
+    CALC_CRC(_mm_crc32_u8, crc, uint8_t, buf, len);
 #endif
 
     return crc;
 }
 #endif
 
-UINT32 calc_crc32c(_In_ UINT32 seed, _In_reads_bytes_(msglen) UINT8* msg, _In_ ULONG msglen) {
-    UINT32 rem;
+uint32_t calc_crc32c(_In_ uint32_t seed, _In_reads_bytes_(msglen) uint8_t* msg, _In_ ULONG msglen) {
+    uint32_t rem;
     ULONG i;
 
 #ifndef __REACTOS__
diff --git a/drivers/filesystems/btrfs/create.c b/drivers/filesystems/btrfs/create.c
index 2d996edc7c5..039fe287f13 100644
--- a/drivers/filesystems/btrfs/create.c
+++ b/drivers/filesystems/btrfs/create.c
@@ -22,6 +22,9 @@
 #include <ntddstor.h>
 
 extern PDEVICE_OBJECT master_devobj;
+extern tFsRtlGetEcpListFromIrp fFsRtlGetEcpListFromIrp;
+extern tFsRtlGetNextExtraCreateParameter fFsRtlGetNextExtraCreateParameter;
+extern tFsRtlValidateReparsePointBuffer fFsRtlValidateReparsePointBuffer;
 
 static const WCHAR datastring[] = L"::$DATA";
 
@@ -141,16 +144,16 @@ file_ref* create_fileref(device_extension* Vcb) {
     return fr;
 }
 
-NTSTATUS find_file_in_dir(PUNICODE_STRING filename, fcb* fcb, root** subvol, UINT64* inode, dir_child** pdc, BOOL case_sensitive) {
+NTSTATUS find_file_in_dir(PUNICODE_STRING filename, fcb* fcb, root** subvol, uint64_t* inode, dir_child** pdc, bool case_sensitive) {
     NTSTATUS Status;
     UNICODE_STRING fnus;
-    UINT32 hash;
+    uint32_t hash;
     LIST_ENTRY* le;
-    UINT8 c;
-    BOOL locked = FALSE;
+    uint8_t c;
+    bool locked = false;
 
     if (!case_sensitive) {
-        Status = RtlUpcaseUnicodeString(&fnus, filename, TRUE);
+        Status = RtlUpcaseUnicodeString(&fnus, filename, true);
 
         if (!NT_SUCCESS(Status)) {
             ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
@@ -159,13 +162,13 @@ NTSTATUS find_file_in_dir(PUNICODE_STRING filename, fcb* fcb, root** subvol, UIN
     } else
         fnus = *filename;
 
-    hash = calc_crc32c(0xffffffff, (UINT8*)fnus.Buffer, fnus.Length);
+    hash = calc_crc32c(0xffffffff, (uint8_t*)fnus.Buffer, fnus.Length);
 
     c = hash >> 24;
 
     if (!ExIsResourceAcquiredSharedLite(&fcb->nonpaged->dir_children_lock)) {
-        ExAcquireResourceSharedLite(&fcb->nonpaged->dir_children_lock, TRUE);
-        locked = TRUE;
+        ExAcquireResourceSharedLite(&fcb->nonpaged->dir_children_lock, true);
+        locked = true;
     }
 
     if (case_sensitive) {
@@ -276,9 +279,9 @@ end:
     return Status;
 }
 
-static NTSTATUS split_path(device_extension* Vcb, PUNICODE_STRING path, LIST_ENTRY* parts, BOOL* stream) {
+static NTSTATUS split_path(device_extension* Vcb, PUNICODE_STRING path, LIST_ENTRY* parts, bool* stream) {
     ULONG len, i;
-    BOOL has_stream;
+    bool has_stream;
     WCHAR* buf;
     name_bit* nb;
     NTSTATUS Status;
@@ -292,12 +295,12 @@ static NTSTATUS split_path(device_extension* Vcb, PUNICODE_STRING path, LIST_ENT
         return STATUS_OBJECT_NAME_INVALID;
     }
 
-    has_stream = FALSE;
+    has_stream = false;
     for (i = 0; i < len; i++) {
         if (path->Buffer[i] == '/' || path->Buffer[i] == '\\') {
-            has_stream = FALSE;
+            has_stream = false;
         } else if (path->Buffer[i] == ':') {
-            has_stream = TRUE;
+            has_stream = true;
         }
     }
 
@@ -362,10 +365,10 @@ static NTSTATUS split_path(device_extension* Vcb, PUNICODE_STRING path, LIST_ENT
                 }
 
                 nb2->us.Buffer = &nb->us.Buffer[i+1];
-                nb2->us.Length = nb2->us.MaximumLength = (UINT16)(nb->us.Length - (i * sizeof(WCHAR)) - sizeof(WCHAR));
+                nb2->us.Length = nb2->us.MaximumLength = (uint16_t)(nb->us.Length - (i * sizeof(WCHAR)) - sizeof(WCHAR));
                 InsertTailList(parts, &nb2->list_entry);
 
-                nb->us.Length = (UINT16)i * sizeof(WCHAR);
+                nb->us.Length = (uint16_t)i * sizeof(WCHAR);
                 nb->us.MaximumLength = nb->us.Length;
 
                 nb = nb2;
@@ -383,7 +386,7 @@ static NTSTATUS split_path(device_extension* Vcb, PUNICODE_STRING path, LIST_ENT
             RemoveTailList(parts);
             ExFreeToPagedLookasideList(&Vcb->name_bit_lookaside, nb);
 
-            has_stream = FALSE;
+            has_stream = false;
         }
     }
 
@@ -408,18 +411,18 @@ cleanup:
     return Status;
 }
 
-NTSTATUS load_csum(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, UINT32* csum, UINT64 start, UINT64 length, PIRP Irp) {
+NTSTATUS load_csum(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, uint32_t* csum, uint64_t start, uint64_t length, PIRP Irp) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp, next_tp;
-    UINT64 i, j;
-    BOOL b;
+    uint64_t i, j;
+    bool b;
 
     searchkey.obj_id = EXTENT_CSUM_ID;
     searchkey.obj_type = TYPE_EXTENT_CSUM;
     searchkey.offset = start;
 
-    Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
@@ -435,34 +438,34 @@ NTSTATUS load_csum(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb
             else
                 j = ((start - tp.item->key.offset) / Vcb->superblock.sector_size) + i;
 
-            if (j * sizeof(UINT32) > tp.item->size || tp.item->key.offset > start + (i * Vcb->superblock.sector_size)) {
-                ERR("checksum not found for %llx\n", start + (i * Vcb->superblock.sector_size));
+            if (j * sizeof(uint32_t) > tp.item->size || tp.item->key.offset > start + (i * Vcb->superblock.sector_size)) {
+                ERR("checksum not found for %I64x\n", start + (i * Vcb->superblock.sector_size));
                 return STATUS_INTERNAL_ERROR;
             }
 
-            readlen = (ULONG)min((tp.item->size / sizeof(UINT32)) - j, length - i);
-            RtlCopyMemory(&csum[i], tp.item->data + (j * sizeof(UINT32)), readlen * sizeof(UINT32));
+            readlen = (ULONG)min((tp.item->size / sizeof(uint32_t)) - j, length - i);
+            RtlCopyMemory(&csum[i], tp.item->data + (j * sizeof(uint32_t)), readlen * sizeof(uint32_t));
             i += readlen;
 
             if (i == length)
                 break;
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, Irp);
+        b = find_next_item(Vcb, &tp, &next_tp, false, Irp);
 
         if (b)
             tp = next_tp;
     } while (b);
 
     if (i < length) {
-        ERR("could not read checksums: offset %llx, length %llx sectors\n", start, length);
+        ERR("could not read checksums: offset %I64x, length %I64x sectors\n", start, length);
         return STATUS_INTERNAL_ERROR;
     }
 
     return STATUS_SUCCESS;
 }
 
-NTSTATUS load_dir_children(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, fcb* fcb, BOOL ignore_size, PIRP Irp) {
+NTSTATUS load_dir_children(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, fcb* fcb, bool ignore_size, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp, next_tp;
     NTSTATUS Status;
@@ -491,16 +494,16 @@ NTSTATUS load_dir_children(_Requires_lock_held_(_Curr_->tree_lock) device_extens
     searchkey.obj_type = TYPE_DIR_INDEX;
     searchkey.offset = 2;
 
-    Status = find_item(Vcb, fcb->subvol, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, fcb->subvol, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
     }
 
     if (keycmp(tp.item->key, searchkey) == -1) {
-        if (find_next_item(Vcb, &tp, &next_tp, FALSE, Irp)) {
+        if (find_next_item(Vcb, &tp, &next_tp, false, Irp)) {
             tp = next_tp;
-            TRACE("moving on to %llx,%x,%llx\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+            TRACE("moving on to %I64x,%x,%I64x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
         }
     }
 
@@ -510,18 +513,18 @@ NTSTATUS load_dir_children(_Requires_lock_held_(_Curr_->tree_lock) device_extens
         ULONG utf16len;
 
         if (tp.item->size < sizeof(DIR_ITEM)) {
-            WARN("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DIR_ITEM));
+            WARN("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(DIR_ITEM));
             goto cont;
         }
 
         if (di->n == 0) {
-            WARN("(%llx,%x,%llx): DIR_ITEM name length is zero\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+            WARN("(%I64x,%x,%I64x): DIR_ITEM name length is zero\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
             goto cont;
         }
 
-        Status = RtlUTF8ToUnicodeN(NULL, 0, &utf16len, di->name, di->n);
+        Status = utf8_to_utf16(NULL, 0, &utf16len, di->name, di->n);
         if (!NT_SUCCESS(Status)) {
-            ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
+            ERR("utf8_to_utf16 1 returned %08x\n", Status);
             goto cont;
         }
 
@@ -546,7 +549,7 @@ NTSTATUS load_dir_children(_Requires_lock_held_(_Curr_->tree_lock) device_extens
 
         RtlCopyMemory(dc->utf8.Buffer, di->name, di->n);
 
-        dc->name.MaximumLength = dc->name.Length = (UINT16)utf16len;
+        dc->name.MaximumLength = dc->name.Length = (uint16_t)utf16len;
         dc->name.Buffer = ExAllocatePoolWithTag(PagedPool, dc->name.MaximumLength, ALLOC_TAG);
         if (!dc->name.Buffer) {
             ERR("out of memory\n");
@@ -555,16 +558,16 @@ NTSTATUS load_dir_children(_Requires_lock_held_(_Curr_->tree_lock) device_extens
             return STATUS_INSUFFICIENT_RESOURCES;
         }
 
-        Status = RtlUTF8ToUnicodeN(dc->name.Buffer, utf16len, &utf16len, di->name, di->n);
+        Status = utf8_to_utf16(dc->name.Buffer, utf16len, &utf16len, di->name, di->n);
         if (!NT_SUCCESS(Status)) {
-            ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
+            ERR("utf8_to_utf16 2 returned %08x\n", Status);
             ExFreePool(dc->utf8.Buffer);
             ExFreePool(dc->name.Buffer);
             ExFreePool(dc);
             goto cont;
         }
 
-        Status = RtlUpcaseUnicodeString(&dc->name_uc, &dc->name, TRUE);
+        Status = RtlUpcaseUnicodeString(&dc->name_uc, &dc->name, true);
         if (!NT_SUCCESS(Status)) {
             ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
             ExFreePool(dc->utf8.Buffer);
@@ -573,8 +576,8 @@ NTSTATUS load_dir_children(_Requires_lock_held_(_Curr_->tree_lock) device_extens
             goto cont;
         }
 
-        dc->hash = calc_crc32c(0xffffffff, (UINT8*)dc->name.Buffer, dc->name.Length);
-        dc->hash_uc = calc_crc32c(0xffffffff, (UINT8*)dc->name_uc.Buffer, dc->name_uc.Length);
+        dc->hash = calc_crc32c(0xffffffff, (uint8_t*)dc->name.Buffer, dc->name.Length);
+        dc->hash_uc = calc_crc32c(0xffffffff, (uint8_t*)dc->name_uc.Buffer, dc->name_uc.Length);
 
         InsertTailList(&fcb->dir_children_index, &dc->list_entry_index);
 
@@ -583,7 +586,7 @@ NTSTATUS load_dir_children(_Requires_lock_held_(_Curr_->tree_lock) device_extens
         num_children++;
 
 cont:
-        if (find_next_item(Vcb, &tp, &next_tp, FALSE, Irp))
+        if (find_next_item(Vcb, &tp, &next_tp, false, Irp))
             tp = next_tp;
         else
             break;
@@ -593,18 +596,18 @@ cont:
 }
 
 NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension* Vcb,
-                  root* subvol, UINT64 inode, UINT8 type, PANSI_STRING utf8, BOOL always_add_hl, fcb* parent, fcb** pfcb, POOL_TYPE pooltype, PIRP Irp) {
+                  root* subvol, uint64_t inode, uint8_t type, PANSI_STRING utf8, bool always_add_hl, fcb* parent, fcb** pfcb, POOL_TYPE pooltype, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp, next_tp;
     NTSTATUS Status;
     fcb *fcb, *deleted_fcb = NULL;
-    BOOL atts_set = FALSE, sd_set = FALSE, no_data;
+    bool atts_set = false, sd_set = false, no_data;
     LIST_ENTRY* lastle = NULL;
     EXTENT_DATA* ed = NULL;
-    UINT64 fcbs_version;
-    UINT32 hash;
+    uint64_t fcbs_version;
+    uint32_t hash;
 
-    hash = calc_crc32c(0xffffffff, (UINT8*)&inode, sizeof(UINT64));
+    hash = calc_crc32c(0xffffffff, (uint8_t*)&inode, sizeof(uint64_t));
 
     acquire_fcb_lock_shared(Vcb);
 
@@ -622,7 +625,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
 #ifdef DEBUG_FCB_REFCOUNTS
                         LONG rc = InterlockedIncrement(&fcb->refcount);
 
-                        WARN("fcb %p: refcount now %i (subvol %llx, inode %llx)\n", fcb, rc, fcb->subvol->id, fcb->inode);
+                        WARN("fcb %p: refcount now %i (subvol %I64x, inode %I64x)\n", fcb, rc, fcb->subvol->id, fcb->inode);
 #else
                         InterlockedIncrement(&fcb->refcount);
 #endif
@@ -675,7 +678,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
     searchkey.obj_type = TYPE_INODE_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, subvol, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, subvol, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         reap_fcb(fcb);
@@ -683,7 +686,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
     }
 
     if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-        WARN("couldn't find INODE_ITEM for inode %llx in subvol %llx\n", inode, subvol->id);
+        WARN("couldn't find INODE_ITEM for inode %I64x in subvol %I64x\n", inode, subvol->id);
         reap_fcb(fcb);
         return STATUS_INVALID_PARAMETER;
     }
@@ -710,7 +713,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
 
     no_data = fcb->inode_item.st_size == 0 || (fcb->type != BTRFS_TYPE_FILE && fcb->type != BTRFS_TYPE_SYMLINK);
 
-    while (find_next_item(Vcb, &tp, &next_tp, FALSE, Irp)) {
+    while (find_next_item(Vcb, &tp, &next_tp, false, Irp)) {
         tp = next_tp;
 
         if (tp.item->key.obj_id > inode)
@@ -747,15 +750,15 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                     RtlCopyMemory(hl->utf8.Buffer, ir->name, ir->n);
                 }
 
-                Status = RtlUTF8ToUnicodeN(NULL, 0, &stringlen, ir->name, ir->n);
+                Status = utf8_to_utf16(NULL, 0, &stringlen, ir->name, ir->n);
                 if (!NT_SUCCESS(Status)) {
-                    ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
+                    ERR("utf8_to_utf16 1 returned %08x\n", Status);
                     ExFreePool(hl);
                     reap_fcb(fcb);
                     return Status;
                 }
 
-                hl->name.Length = hl->name.MaximumLength = (UINT16)stringlen;
+                hl->name.Length = hl->name.MaximumLength = (uint16_t)stringlen;
 
                 if (stringlen == 0)
                     hl->name.Buffer = NULL;
@@ -769,9 +772,9 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                         return STATUS_INSUFFICIENT_RESOURCES;
                     }
 
-                    Status = RtlUTF8ToUnicodeN(hl->name.Buffer, stringlen, &stringlen, ir->name, ir->n);
+                    Status = utf8_to_utf16(hl->name.Buffer, stringlen, &stringlen, ir->name, ir->n);
                     if (!NT_SUCCESS(Status)) {
-                        ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
+                        ERR("utf8_to_utf16 2 returned %08x\n", Status);
                         ExFreePool(hl->name.Buffer);
                         ExFreePool(hl);
                         reap_fcb(fcb);
@@ -812,15 +815,15 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                     RtlCopyMemory(hl->utf8.Buffer, ier->name, ier->n);
                 }
 
-                Status = RtlUTF8ToUnicodeN(NULL, 0, &stringlen, ier->name, ier->n);
+                Status = utf8_to_utf16(NULL, 0, &stringlen, ier->name, ier->n);
                 if (!NT_SUCCESS(Status)) {
-                    ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
+                    ERR("utf8_to_utf16 1 returned %08x\n", Status);
                     ExFreePool(hl);
                     reap_fcb(fcb);
                     return Status;
                 }
 
-                hl->name.Length = hl->name.MaximumLength = (UINT16)stringlen;
+                hl->name.Length = hl->name.MaximumLength = (uint16_t)stringlen;
 
                 if (stringlen == 0)
                     hl->name.Buffer = NULL;
@@ -834,9 +837,9 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                         return STATUS_INSUFFICIENT_RESOURCES;
                     }
 
-                    Status = RtlUTF8ToUnicodeN(hl->name.Buffer, stringlen, &stringlen, ier->name, ier->n);
+                    Status = utf8_to_utf16(hl->name.Buffer, stringlen, &stringlen, ier->name, ier->n);
                     if (!NT_SUCCESS(Status)) {
-                        ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
+                        ERR("utf8_to_utf16 2 returned %08x\n", Status);
                         ExFreePool(hl->name.Buffer);
                         ExFreePool(hl);
                         reap_fcb(fcb);
@@ -856,7 +859,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
             static const char xapref[] = "user.";
 
             if (tp.item->size < offsetof(DIR_ITEM, name[0])) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, offsetof(DIR_ITEM, name[0]));
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, offsetof(DIR_ITEM, name[0]));
                 continue;
             }
 
@@ -913,14 +916,14 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                                 if (eainfo->NextEntryOffset == 0)
                                     break;
 
-                                eainfo = (FILE_FULL_EA_INFORMATION*)(((UINT8*)eainfo) + eainfo->NextEntryOffset);
-                            } while (TRUE);
+                                eainfo = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)eainfo) + eainfo->NextEntryOffset);
+                            } while (true);
                         }
                     }
                 } else if (tp.item->key.offset == EA_DOSATTRIB_HASH && di->n == sizeof(EA_DOSATTRIB) - 1 && RtlCompareMemory(EA_DOSATTRIB, di->name, di->n) == di->n) {
                     if (di->m > 0) {
                         if (get_file_attributes_from_xattr(&di->name[di->n], di->m, &fcb->atts)) {
-                            atts_set = TRUE;
+                            atts_set = true;
 
                             if (fcb->type == BTRFS_TYPE_DIRECTORY)
                                 fcb->atts |= FILE_ATTRIBUTE_DIRECTORY;
@@ -954,7 +957,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                         if (!RtlValidRelativeSecurityDescriptor(fcb->sd, di->m, 0))
                             ExFreePool(fcb->sd);
                         else
-                            sd_set = TRUE;
+                            sd_set = true;
                     }
                 } else if (tp.item->key.offset == EA_PROP_COMPRESSION_HASH && di->n == sizeof(EA_PROP_COMPRESSION) - 1 && RtlCompareMemory(EA_PROP_COMPRESSION, di->name, di->n) == di->n) {
                     if (di->m > 0) {
@@ -974,15 +977,15 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                 } else if (tp.item->key.offset == EA_CASE_SENSITIVE_HASH && di->n == sizeof(EA_CASE_SENSITIVE) - 1 && RtlCompareMemory(EA_CASE_SENSITIVE, di->name, di->n) == di->n) {
                     if (di->m > 0) {
                         fcb->case_sensitive = di->m == 1 && di->name[di->n] == '1';
-                        fcb->case_sensitive_set = TRUE;
+                        fcb->case_sensitive_set = true;
                     }
                 } else if (di->n > sizeof(xapref) - 1 && RtlCompareMemory(xapref, di->name, sizeof(xapref) - 1) == sizeof(xapref) - 1) {
                     dir_child* dc;
                     ULONG utf16len;
 
-                    Status = RtlUTF8ToUnicodeN(NULL, 0, &utf16len, &di->name[sizeof(xapref) - 1], di->n + 1 - sizeof(xapref));
+                    Status = utf8_to_utf16(NULL, 0, &utf16len, &di->name[sizeof(xapref) - 1], di->n + 1 - sizeof(xapref));
                     if (!NT_SUCCESS(Status)) {
-                        ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
+                        ERR("utf8_to_utf16 1 returned %08x\n", Status);
                         reap_fcb(fcb);
                         return Status;
                     }
@@ -1007,7 +1010,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
 
                     RtlCopyMemory(dc->utf8.Buffer, &di->name[sizeof(xapref) - 1], dc->utf8.Length);
 
-                    dc->name.MaximumLength = dc->name.Length = (UINT16)utf16len;
+                    dc->name.MaximumLength = dc->name.Length = (uint16_t)utf16len;
                     dc->name.Buffer = ExAllocatePoolWithTag(PagedPool, dc->name.MaximumLength, ALLOC_TAG);
                     if (!dc->name.Buffer) {
                         ERR("out of memory\n");
@@ -1017,9 +1020,9 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                         return STATUS_INSUFFICIENT_RESOURCES;
                     }
 
-                    Status = RtlUTF8ToUnicodeN(dc->name.Buffer, utf16len, &utf16len, dc->utf8.Buffer, dc->utf8.Length);
+                    Status = utf8_to_utf16(dc->name.Buffer, utf16len, &utf16len, dc->utf8.Buffer, dc->utf8.Length);
                     if (!NT_SUCCESS(Status)) {
-                        ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
+                        ERR("utf8_to_utf16 2 returned %08x\n", Status);
                         ExFreePool(dc->utf8.Buffer);
                         ExFreePool(dc->name.Buffer);
                         ExFreePool(dc);
@@ -1027,7 +1030,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                         return Status;
                     }
 
-                    Status = RtlUpcaseUnicodeString(&dc->name_uc, &dc->name, TRUE);
+                    Status = RtlUpcaseUnicodeString(&dc->name_uc, &dc->name, true);
                     if (!NT_SUCCESS(Status)) {
                         ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
                         ExFreePool(dc->utf8.Buffer);
@@ -1052,7 +1055,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
 
                     xa->namelen = di->n;
                     xa->valuelen = di->m;
-                    xa->dirty = FALSE;
+                    xa->dirty = false;
                     RtlCopyMemory(xa->data, di->name, di->m + di->n);
 
                     InsertTailList(&fcb->xattrs, &xa->list_entry);
@@ -1064,15 +1067,15 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                     break;
 
                 di = (DIR_ITEM*)&di->name[di->m + di->n];
-            } while (TRUE);
+            } while (true);
         } else if (tp.item->key.obj_type == TYPE_EXTENT_DATA) {
             extent* ext;
-            BOOL unique = FALSE;
+            bool unique = false;
 
             ed = (EXTENT_DATA*)tp.item->data;
 
             if (tp.item->size < sizeof(EXTENT_DATA)) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                     tp.item->size, sizeof(EXTENT_DATA));
 
                 reap_fcb(fcb);
@@ -1083,7 +1086,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
                 EXTENT_DATA2* ed2 = (EXTENT_DATA2*)&ed->data[0];
 
                 if (tp.item->size < sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2)) {
-                    ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+                    ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                         tp.item->size, sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2));
 
                     reap_fcb(fcb);
@@ -1108,8 +1111,8 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
             RtlCopyMemory(&ext->extent_data, tp.item->data, tp.item->size);
             ext->datalen = tp.item->size;
             ext->unique = unique;
-            ext->ignore = FALSE;
-            ext->inserted = FALSE;
+            ext->ignore = false;
+            ext->inserted = false;
             ext->csum = NULL;
 
             InsertTailList(&fcb->extents, &ext->list_entry);
@@ -1117,7 +1120,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
     }
 
     if (fcb->type == BTRFS_TYPE_DIRECTORY) {
-        Status = load_dir_children(Vcb, fcb, FALSE, Irp);
+        Status = load_dir_children(Vcb, fcb, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("load_dir_children returned %08x\n", Status);
             reap_fcb(fcb);
@@ -1140,16 +1143,21 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
     }
 
     if (!atts_set)
-        fcb->atts = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type, utf8 && utf8->Buffer[0] == '.', TRUE, Irp);
+        fcb->atts = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type, utf8 && utf8->Buffer[0] == '.', true, Irp);
 
     if (!sd_set)
-        fcb_get_sd(fcb, parent, FALSE, Irp);
+        fcb_get_sd(fcb, parent, false, Irp);
 
     acquire_fcb_lock_exclusive(Vcb);
 
-    if (lastle && subvol->fcbs_version == fcbs_version)
+    if (lastle && subvol->fcbs_version == fcbs_version) {
         InsertHeadList(lastle, &fcb->list_entry);
-    else {
+
+        if (!subvol->fcbs_ptrs[hash >> 24] || CONTAINING_RECORD(subvol->fcbs_ptrs[hash >> 24], struct _fcb, list_entry)->hash > hash)
+            subvol->fcbs_ptrs[hash >> 24] = &fcb->list_entry;
+    } else {
+        lastle = NULL;
+
         if (subvol->fcbs_ptrs[hash >> 24]) {
             LIST_ENTRY* le = subvol->fcbs_ptrs[hash >> 24];
 
@@ -1164,7 +1172,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
 #ifdef DEBUG_FCB_REFCOUNTS
                             LONG rc = InterlockedIncrement(&fcb2->refcount);
 
-                            WARN("fcb %p: refcount now %i (subvol %llx, inode %llx)\n", fcb2, rc, fcb2->subvol->id, fcb2->inode);
+                            WARN("fcb %p: refcount now %i (subvol %I64x, inode %I64x)\n", fcb2, rc, fcb2->subvol->id, fcb2->inode);
 #else
                             InterlockedIncrement(&fcb2->refcount);
 #endif
@@ -1196,16 +1204,16 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
             fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
 
             if (!Vcb->readonly && !is_subvol_readonly(subvol, Irp)) {
-                fcb->atts_changed = TRUE;
+                fcb->atts_changed = true;
                 mark_fcb_dirty(fcb);
             }
         }
 
         if (!lastle) {
-            UINT8 c = hash >> 24;
+            uint8_t c = hash >> 24;
 
             if (c != 0xff) {
-                UINT8 d = c + 1;
+                uint8_t d = c + 1;
 
                 do {
                     if (subvol->fcbs_ptrs[d]) {
@@ -1247,14 +1255,14 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
 static NTSTATUS open_fcb_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension* Vcb,
                                 dir_child* dc, fcb* parent, fcb** pfcb, PIRP Irp) {
     fcb* fcb;
-    UINT8* xattrdata;
-    UINT16 xattrlen, overhead;
+    uint8_t* xattrdata;
+    uint16_t xattrlen, overhead;
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
     static const char xapref[] = "user.";
     ANSI_STRING xattr;
-    UINT32 crc32;
+    uint32_t crc32;
 
     xattr.Length = sizeof(xapref) - 1 + dc->utf8.Length;
     xattr.MaximumLength = xattr.Length + 1;
@@ -1277,7 +1285,7 @@ static NTSTATUS open_fcb_stream(_Requires_lock_held_(_Curr_->tree_lock) _Require
 
     fcb->Vcb = Vcb;
 
-    crc32 = calc_crc32c(0xfffffffe, (UINT8*)xattr.Buffer, xattr.Length);
+    crc32 = calc_crc32c(0xfffffffe, (uint8_t*)xattr.Buffer, xattr.Length);
 
     if (!get_xattr(Vcb, parent->subvol, parent->inode, xattr.Buffer, crc32, &xattrdata, &xattrlen, Irp)) {
         ERR("get_xattr failed\n");
@@ -1289,7 +1297,7 @@ static NTSTATUS open_fcb_stream(_Requires_lock_held_(_Curr_->tree_lock) _Require
     fcb->subvol = parent->subvol;
     fcb->inode = parent->inode;
     fcb->type = parent->type;
-    fcb->ads = TRUE;
+    fcb->ads = true;
     fcb->adshash = crc32;
     fcb->adsxattr = xattr;
 
@@ -1299,7 +1307,7 @@ static NTSTATUS open_fcb_stream(_Requires_lock_held_(_Curr_->tree_lock) _Require
     searchkey.obj_type = TYPE_XATTR_ITEM;
     searchkey.offset = crc32;
 
-    Status = find_item(Vcb, parent->subvol, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, parent->subvol, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         reap_fcb(fcb);
@@ -1313,7 +1321,7 @@ static NTSTATUS open_fcb_stream(_Requires_lock_held_(_Curr_->tree_lock) _Require
     }
 
     if (tp.item->size < xattrlen) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, xattrlen);
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, xattrlen);
         reap_fcb(fcb);
         return STATUS_INTERNAL_ERROR;
     }
@@ -1338,7 +1346,7 @@ static NTSTATUS open_fcb_stream(_Requires_lock_held_(_Curr_->tree_lock) _Require
 }
 
 NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension* Vcb,
-                            _In_ file_ref* sf, _In_ PUNICODE_STRING name, _In_ BOOL case_sensitive, _In_ BOOL lastpart, _In_ BOOL streampart,
+                            _In_ file_ref* sf, _In_ PUNICODE_STRING name, _In_ bool case_sensitive, _In_ bool lastpart, _In_ bool streampart,
                             _In_ POOL_TYPE pooltype, _Out_ file_ref** psf2, _In_opt_ PIRP Irp) {
     NTSTATUS Status;
     file_ref* sf2;
@@ -1347,7 +1355,7 @@ NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ex
         return STATUS_OBJECT_NAME_NOT_FOUND;
 
     if (streampart) {
-        BOOL locked = FALSE;
+        bool locked = false;
         LIST_ENTRY* le;
         UNICODE_STRING name_uc;
         dir_child* dc = NULL;
@@ -1356,7 +1364,7 @@ NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ex
         file_ref* duff_fr = NULL;
 
         if (!case_sensitive) {
-            Status = RtlUpcaseUnicodeString(&name_uc, name, TRUE);
+            Status = RtlUpcaseUnicodeString(&name_uc, name, true);
             if (!NT_SUCCESS(Status)) {
                 ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
                 return Status;
@@ -1364,8 +1372,8 @@ NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ex
         }
 
         if (!ExIsResourceAcquiredSharedLite(&sf->fcb->nonpaged->dir_children_lock)) {
-            ExAcquireResourceSharedLite(&sf->fcb->nonpaged->dir_children_lock, TRUE);
-            locked = TRUE;
+            ExAcquireResourceSharedLite(&sf->fcb->nonpaged->dir_children_lock, true);
+            locked = true;
         }
 
         le = sf->fcb->dir_children_index.Flink;
@@ -1424,7 +1432,7 @@ NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ex
         acquire_fcb_lock_exclusive(Vcb);
 
         if (sf->fcb->subvol->fcbs_ptrs[fcb->hash >> 24]) {
-            LIST_ENTRY* le = sf->fcb->subvol->fcbs_ptrs[fcb->hash >> 24];
+            le = sf->fcb->subvol->fcbs_ptrs[fcb->hash >> 24];
 
             while (le != &sf->fcb->subvol->fcbs) {
                 struct _fcb* fcb2 = CONTAINING_RECORD(le, struct _fcb, list_entry);
@@ -1462,7 +1470,7 @@ NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ex
             return STATUS_INSUFFICIENT_RESOURCES;
         }
 
-        ExAcquireResourceExclusiveLite(&sf->fcb->nonpaged->dir_children_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&sf->fcb->nonpaged->dir_children_lock, true);
 
         if (dc->fileref) {
             duff_fr = sf2;
@@ -1483,7 +1491,7 @@ NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ex
             reap_fileref(Vcb, duff_fr);
     } else {
         root* subvol;
-        UINT64 inode;
+        uint64_t inode;
         dir_child* dc;
 
         Status = find_file_in_dir(name, sf->fcb, &subvol, &inode, &dc, case_sensitive);
@@ -1497,9 +1505,6 @@ NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ex
         } else {
             fcb* fcb;
             file_ref* duff_fr = NULL;
-#ifdef DEBUG_STATS
-            LARGE_INTEGER time1, time2;
-#endif
 
             if (dc->fileref) {
                 if (!lastpart && dc->type != BTRFS_TYPE_DIRECTORY) {
@@ -1516,15 +1521,7 @@ NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ex
                 fcb = Vcb->dummy_fcb;
                 InterlockedIncrement(&fcb->refcount);
             } else {
-#ifdef DEBUG_STATS
-                time1 = KeQueryPerformanceCounter(NULL);
-#endif
-                Status = open_fcb(Vcb, subvol, inode, dc->type, &dc->utf8, FALSE, sf->fcb, &fcb, pooltype, Irp);
-#ifdef DEBUG_STATS
-                time2 = KeQueryPerformanceCounter(NULL);
-                Vcb->stats.open_fcb_calls++;
-                Vcb->stats.open_fcb_time += time2.QuadPart - time1.QuadPart;
-#endif
+                Status = open_fcb(Vcb, subvol, inode, dc->type, &dc->utf8, false, sf->fcb, &fcb, pooltype, Irp);
 
                 if (!NT_SUCCESS(Status)) {
                     ERR("open_fcb returned %08x\n", Status);
@@ -1550,7 +1547,7 @@ NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ex
             if (dc->type == BTRFS_TYPE_DIRECTORY)
                 fcb->fileref = sf2;
 
-            ExAcquireResourceExclusiveLite(&sf->fcb->nonpaged->dir_children_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&sf->fcb->nonpaged->dir_children_lock, true);
 
             if (!dc->fileref) {
                 sf2->parent = (struct _file_ref*)sf;
@@ -1577,12 +1574,12 @@ NTSTATUS open_fileref_child(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ex
 }
 
 NTSTATUS open_fileref(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension* Vcb, _Out_ file_ref** pfr,
-                      _In_ PUNICODE_STRING fnus, _In_opt_ file_ref* related, _In_ BOOL parent, _Out_opt_ USHORT* parsed, _Out_opt_ ULONG* fn_offset, _In_ POOL_TYPE pooltype,
-                      _In_ BOOL case_sensitive, _In_opt_ PIRP Irp) {
+                      _In_ PUNICODE_STRING fnus, _In_opt_ file_ref* related, _In_ bool parent, _Out_opt_ USHORT* parsed, _Out_opt_ ULONG* fn_offset, _In_ POOL_TYPE pooltype,
+                      _In_ bool case_sensitive, _In_opt_ PIRP Irp) {
     UNICODE_STRING fnus2;
     file_ref *dir, *sf, *sf2;
     LIST_ENTRY parts;
-    BOOL has_stream;
+    bool has_stream;
     NTSTATUS Status;
     LIST_ENTRY* le;
 
@@ -1671,7 +1668,7 @@ NTSTATUS open_fileref(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusiv
             nb = CONTAINING_RECORD(RemoveTailList(&parts), name_bit, list_entry);
             ExFreePool(nb);
 
-            has_stream = FALSE;
+            has_stream = false;
         }
     }
 
@@ -1688,16 +1685,9 @@ NTSTATUS open_fileref(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusiv
     le = parts.Flink;
     do {
         name_bit* nb = CONTAINING_RECORD(le, name_bit, list_entry);
-        BOOL lastpart = le->Flink == &parts || (has_stream && le->Flink->Flink == &parts);
-        BOOL streampart = has_stream && le->Flink == &parts;
-#ifdef DEBUG_STATS
-        LARGE_INTEGER time1, time2;
-#endif
-
-#ifdef DEBUG_STATS
-        time1 = KeQueryPerformanceCounter(NULL);
-#endif
-        BOOL cs = case_sensitive;
+        bool lastpart = le->Flink == &parts || (has_stream && le->Flink->Flink == &parts);
+        bool streampart = has_stream && le->Flink == &parts;
+        bool cs = case_sensitive;
 
         if (!cs) {
             if (streampart)
@@ -1707,11 +1697,7 @@ NTSTATUS open_fileref(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusiv
         }
 
         Status = open_fileref_child(Vcb, sf, &nb->us, cs, lastpart, streampart, pooltype, &sf2, Irp);
-#ifdef DEBUG_STATS
-        time2 = KeQueryPerformanceCounter(NULL);
-        Vcb->stats.open_fileref_child_calls++;
-        Vcb->stats.open_fileref_child_time += time2.QuadPart - time1.QuadPart;
-#endif
+
         if (!NT_SUCCESS(Status)) {
             if (Status == STATUS_OBJECT_PATH_NOT_FOUND || Status == STATUS_OBJECT_NAME_NOT_FOUND)
                 TRACE("open_fileref_child returned %08x\n", Status);
@@ -1768,10 +1754,10 @@ end2:
     return Status;
 }
 
-NTSTATUS add_dir_child(fcb* fcb, UINT64 inode, BOOL subvol, PANSI_STRING utf8, PUNICODE_STRING name, UINT8 type, dir_child** pdc) {
+NTSTATUS add_dir_child(fcb* fcb, uint64_t inode, bool subvol, PANSI_STRING utf8, PUNICODE_STRING name, uint8_t type, dir_child** pdc) {
     NTSTATUS Status;
     dir_child* dc;
-    BOOL locked;
+    bool locked;
 
     dc = ExAllocatePoolWithTag(PagedPool, sizeof(dir_child), ALLOC_TAG);
     if (!dc) {
@@ -1806,7 +1792,7 @@ NTSTATUS add_dir_child(fcb* fcb, UINT64 inode, BOOL subvol, PANSI_STRING utf8, P
     dc->name.Length = dc->name.MaximumLength = name->Length;
     RtlCopyMemory(dc->name.Buffer, name->Buffer, name->Length);
 
-    Status = RtlUpcaseUnicodeString(&dc->name_uc, name, TRUE);
+    Status = RtlUpcaseUnicodeString(&dc->name_uc, name, true);
     if (!NT_SUCCESS(Status)) {
         ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
         ExFreePool(dc->utf8.Buffer);
@@ -1815,13 +1801,13 @@ NTSTATUS add_dir_child(fcb* fcb, UINT64 inode, BOOL subvol, PANSI_STRING utf8, P
         return Status;
     }
 
-    dc->hash = calc_crc32c(0xffffffff, (UINT8*)dc->name.Buffer, dc->name.Length);
-    dc->hash_uc = calc_crc32c(0xffffffff, (UINT8*)dc->name_uc.Buffer, dc->name_uc.Length);
+    dc->hash = calc_crc32c(0xffffffff, (uint8_t*)dc->name.Buffer, dc->name.Length);
+    dc->hash_uc = calc_crc32c(0xffffffff, (uint8_t*)dc->name_uc.Buffer, dc->name_uc.Length);
 
     locked = ExIsResourceAcquiredExclusive(&fcb->nonpaged->dir_children_lock);
 
     if (!locked)
-        ExAcquireResourceExclusiveLite(&fcb->nonpaged->dir_children_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&fcb->nonpaged->dir_children_lock, true);
 
     if (IsListEmpty(&fcb->dir_children_index))
         dc->index = 2;
@@ -1843,8 +1829,8 @@ NTSTATUS add_dir_child(fcb* fcb, UINT64 inode, BOOL subvol, PANSI_STRING utf8, P
     return STATUS_SUCCESS;
 }
 
-UINT32 inherit_mode(fcb* parfcb, BOOL is_dir) {
-    UINT32 mode;
+uint32_t inherit_mode(fcb* parfcb, bool is_dir) {
+    uint32_t mode;
 
     if (!parfcb)
         return 0755;
@@ -1862,14 +1848,14 @@ UINT32 inherit_mode(fcb* parfcb, BOOL is_dir) {
 static NTSTATUS file_create_parse_ea(fcb* fcb, FILE_FULL_EA_INFORMATION* ea) {
     NTSTATUS Status;
     LIST_ENTRY ealist, *le;
-    UINT16 size = 0;
+    uint16_t size = 0;
     char* buf;
 
     InitializeListHead(&ealist);
 
     do {
         STRING s;
-        BOOL found = FALSE;
+        bool found = false;
 
         s.Length = s.MaximumLength = ea->EaNameLength;
         s.Buffer = ea->EaName;
@@ -1884,7 +1870,7 @@ static NTSTATUS file_create_parse_ea(fcb* fcb, FILE_FULL_EA_INFORMATION* ea) {
                 item->flags = ea->Flags;
                 item->value.Length = item->value.MaximumLength = ea->EaValueLength;
                 item->value.Buffer = &ea->EaName[ea->EaNameLength + 1];
-                found = TRUE;
+                found = true;
                 break;
             }
 
@@ -1913,8 +1899,8 @@ static NTSTATUS file_create_parse_ea(fcb* fcb, FILE_FULL_EA_INFORMATION* ea) {
         if (ea->NextEntryOffset == 0)
             break;
 
-        ea = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ea) + ea->NextEntryOffset);
-    } while (TRUE);
+        ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
+    } while (true);
 
     // handle LXSS values
     le = ealist.Flink;
@@ -1923,40 +1909,40 @@ static NTSTATUS file_create_parse_ea(fcb* fcb, FILE_FULL_EA_INFORMATION* ea) {
         ea_item* item = CONTAINING_RECORD(le, ea_item, list_entry);
 
         if (item->name.Length == sizeof(lxuid) - 1 && RtlCompareMemory(item->name.Buffer, lxuid, item->name.Length) == item->name.Length) {
-            if (item->value.Length < sizeof(UINT32)) {
+            if (item->value.Length < sizeof(uint32_t)) {
                 ERR("uid value was shorter than expected\n");
                 Status = STATUS_INVALID_PARAMETER;
                 goto end;
             }
 
-            RtlCopyMemory(&fcb->inode_item.st_uid, item->value.Buffer, sizeof(UINT32));
-            fcb->sd_dirty = TRUE;
-            fcb->sd_deleted = FALSE;
+            RtlCopyMemory(&fcb->inode_item.st_uid, item->value.Buffer, sizeof(uint32_t));
+            fcb->sd_dirty = true;
+            fcb->sd_deleted = false;
 
             RemoveEntryList(&item->list_entry);
             ExFreePool(item);
         } else if (item->name.Length == sizeof(lxgid) - 1 && RtlCompareMemory(item->name.Buffer, lxgid, item->name.Length) == item->name.Length) {
-            if (item->value.Length < sizeof(UINT32)) {
+            if (item->value.Length < sizeof(uint32_t)) {
                 ERR("gid value was shorter than expected\n");
                 Status = STATUS_INVALID_PARAMETER;
                 goto end;
             }
 
-            RtlCopyMemory(&fcb->inode_item.st_gid, item->value.Buffer, sizeof(UINT32));
+            RtlCopyMemory(&fcb->inode_item.st_gid, item->value.Buffer, sizeof(uint32_t));
 
             RemoveEntryList(&item->list_entry);
             ExFreePool(item);
         } else if (item->name.Length == sizeof(lxmod) - 1 && RtlCompareMemory(item->name.Buffer, lxmod, item->name.Length) == item->name.Length) {
-            UINT32 allowed = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH | S_ISGID | S_ISVTX | S_ISUID;
-            UINT32 val;
+            uint32_t allowed = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH | S_ISGID | S_ISVTX | S_ISUID;
+            uint32_t val;
 
-            if (item->value.Length < sizeof(UINT32)) {
+            if (item->value.Length < sizeof(uint32_t)) {
                 ERR("mode value was shorter than expected\n");
                 Status = STATUS_INVALID_PARAMETER;
                 goto end;
             }
 
-            RtlCopyMemory(&val, item->value.Buffer, sizeof(UINT32));
+            RtlCopyMemory(&val, item->value.Buffer, sizeof(uint32_t));
 
             if (fcb->type != BTRFS_TYPE_DIRECTORY)
                 allowed |= __S_IFIFO | __S_IFCHR | __S_IFBLK | __S_IFSOCK;
@@ -1978,16 +1964,16 @@ static NTSTATUS file_create_parse_ea(fcb* fcb, FILE_FULL_EA_INFORMATION* ea) {
             RemoveEntryList(&item->list_entry);
             ExFreePool(item);
         } else if (item->name.Length == sizeof(lxdev) - 1 && RtlCompareMemory(item->name.Buffer, lxdev, item->name.Length) == item->name.Length) {
-            UINT32 major, minor;
+            uint32_t major, minor;
 
-            if (item->value.Length < sizeof(UINT64)) {
+            if (item->value.Length < sizeof(uint64_t)) {
                 ERR("dev value was shorter than expected\n");
                 Status = STATUS_INVALID_PARAMETER;
                 goto end;
             }
 
-            major = *(UINT32*)item->value.Buffer;
-            minor = *(UINT32*)&item->value.Buffer[sizeof(UINT32)];
+            major = *(uint32_t*)item->value.Buffer;
+            minor = *(uint32_t*)&item->value.Buffer[sizeof(uint32_t)];
 
             fcb->inode_item.st_rdev = (minor & 0xFFFFF) | ((major & 0xFFFFFFFFFFF) << 20);
 
@@ -2011,7 +1997,7 @@ static NTSTATUS file_create_parse_ea(fcb* fcb, FILE_FULL_EA_INFORMATION* ea) {
         if (size % 4 > 0)
             size += 4 - (size % 4);
 
-        size += (UINT16)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + item->name.Length + 1 + item->value.Length;
+        size += (uint16_t)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + item->name.Length + 1 + item->value.Length;
 
         le = le->Flink;
     }
@@ -2039,7 +2025,7 @@ static NTSTATUS file_create_parse_ea(fcb* fcb, FILE_FULL_EA_INFORMATION* ea) {
             if (ea->NextEntryOffset % 4 > 0)
                 ea->NextEntryOffset += 4 - (ea->NextEntryOffset % 4);
 
-            ea = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ea) + ea->NextEntryOffset);
+            ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
         } else
             ea = (FILE_FULL_EA_INFORMATION*)fcb->ea_xattr.Buffer;
 
@@ -2057,7 +2043,7 @@ static NTSTATUS file_create_parse_ea(fcb* fcb, FILE_FULL_EA_INFORMATION* ea) {
         le = le->Flink;
     }
 
-    fcb->ea_changed = TRUE;
+    fcb->ea_changed = true;
 
     Status = STATUS_SUCCESS;
 
@@ -2073,13 +2059,13 @@ end:
 
 static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension* Vcb, _In_ PUNICODE_STRING fpus,
                              _In_ file_ref* parfileref, _In_ ULONG options, _In_reads_bytes_opt_(ealen) FILE_FULL_EA_INFORMATION* ea, _In_ ULONG ealen,
-                             _Out_ file_ref** pfr, BOOL case_sensitive, _In_ LIST_ENTRY* rollback) {
+                             _Out_ file_ref** pfr, bool case_sensitive, _In_ LIST_ENTRY* rollback) {
     NTSTATUS Status;
     fcb* fcb;
     ULONG utf8len;
     char* utf8 = NULL;
-    UINT64 inode;
-    UINT8 type;
+    uint64_t inode;
+    uint8_t type;
     LARGE_INTEGER time;
     BTRFS_TIME now;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
@@ -2100,9 +2086,9 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
     if (options & FILE_DIRECTORY_FILE && IrpSp->Parameters.Create.FileAttributes & FILE_ATTRIBUTE_TEMPORARY)
         return STATUS_INVALID_PARAMETER;
 
-    Status = RtlUnicodeToUTF8N(NULL, 0, &utf8len, fpus->Buffer, fpus->Length);
+    Status = utf16_to_utf8(NULL, 0, &utf8len, fpus->Buffer, fpus->Length);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUnicodeToUTF8N returned %08x\n", Status);
+        ERR("utf16_to_utf8 returned %08x\n", Status);
         return Status;
     }
 
@@ -2112,9 +2098,9 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    Status = RtlUnicodeToUTF8N(utf8, utf8len, &utf8len, fpus->Buffer, fpus->Length);
+    Status = utf16_to_utf8(utf8, utf8len, &utf8len, fpus->Buffer, fpus->Length);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUnicodeToUTF8N returned %08x\n", Status);
+        ERR("utf16_to_utf8 returned %08x\n", Status);
         ExFreePool(utf8);
         return Status;
     }
@@ -2125,17 +2111,17 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
     win_time_to_unix(time, &now);
 
     TRACE("create file %.*S\n", fpus->Length / sizeof(WCHAR), fpus->Buffer);
-    ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
-    TRACE("parfileref->fcb->inode_item.st_size (inode %llx) was %llx\n", parfileref->fcb->inode, parfileref->fcb->inode_item.st_size);
+    ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
+    TRACE("parfileref->fcb->inode_item.st_size (inode %I64x) was %I64x\n", parfileref->fcb->inode, parfileref->fcb->inode_item.st_size);
     parfileref->fcb->inode_item.st_size += utf8len * 2;
-    TRACE("parfileref->fcb->inode_item.st_size (inode %llx) now %llx\n", parfileref->fcb->inode, parfileref->fcb->inode_item.st_size);
+    TRACE("parfileref->fcb->inode_item.st_size (inode %I64x) now %I64x\n", parfileref->fcb->inode, parfileref->fcb->inode_item.st_size);
     parfileref->fcb->inode_item.transid = Vcb->superblock.generation;
     parfileref->fcb->inode_item.sequence++;
     parfileref->fcb->inode_item.st_ctime = now;
     parfileref->fcb->inode_item.st_mtime = now;
     ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
-    parfileref->fcb->inode_item_changed = TRUE;
+    parfileref->fcb->inode_item_changed = true;
     mark_fcb_dirty(parfileref->fcb);
 
     inode = InterlockedIncrement64(&parfileref->fcb->subvol->lastinode);
@@ -2172,7 +2158,7 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
         ERR("out of memory\n");
         ExFreePool(utf8);
 
-        ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+        ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
         parfileref->fcb->inode_item.st_size -= utf8len * 2;
         ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
@@ -2181,10 +2167,8 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
 
     fcb->Vcb = Vcb;
 
-    if (IrpSp->Flags & SL_OPEN_PAGING_FILE) {
+    if (IrpSp->Flags & SL_OPEN_PAGING_FILE)
         fcb->Header.Flags2 |= FSRTL_FLAG2_IS_PAGING_FILE;
-        Vcb->disallow_dismount = TRUE;
-    }
 
     fcb->inode_item.generation = Vcb->superblock.generation;
     fcb->inode_item.transid = Vcb->superblock.generation;
@@ -2227,7 +2211,7 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
     fcb->prop_compression = parfileref->fcb->prop_compression;
     fcb->prop_compression_changed = fcb->prop_compression != PropCompression_None;
 
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
 
     fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
     fcb->Header.AllocationSize.QuadPart = 0;
@@ -2246,10 +2230,10 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
     fcb->subvol = parfileref->fcb->subvol;
     fcb->inode = inode;
     fcb->type = type;
-    fcb->created = TRUE;
-    fcb->deleted = TRUE;
+    fcb->created = true;
+    fcb->deleted = true;
 
-    fcb->hash = calc_crc32c(0xffffffff, (UINT8*)&inode, sizeof(UINT64));
+    fcb->hash = calc_crc32c(0xffffffff, (uint8_t*)&inode, sizeof(uint64_t));
 
     acquire_fcb_lock_exclusive(Vcb);
 
@@ -2269,10 +2253,10 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
     }
 
     if (!lastle) {
-        UINT8 c = fcb->hash >> 24;
+        uint8_t c = fcb->hash >> 24;
 
         if (c != 0xff) {
-            UINT8 d = c + 1;
+            uint8_t d = c + 1;
 
             do {
                 if (fcb->subvol->fcbs_ptrs[d]) {
@@ -2311,7 +2295,7 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
         ERR("fcb_get_new_sd returned %08x\n", Status);
         free_fcb(fcb);
 
-        ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+        ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
         parfileref->fcb->inode_item.st_size -= utf8len * 2;
         ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
@@ -2320,7 +2304,7 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
         return Status;
     }
 
-    fcb->sd_dirty = TRUE;
+    fcb->sd_dirty = true;
 
     if (ea && ealen > 0) {
         Status = file_create_parse_ea(fcb, ea);
@@ -2328,7 +2312,7 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
             ERR("file_create_parse_ea returned %08x\n", Status);
             free_fcb(fcb);
 
-            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
             parfileref->fcb->inode_item.st_size -= utf8len * 2;
             ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
@@ -2343,7 +2327,7 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
         ERR("out of memory\n");
         free_fcb(fcb);
 
-        ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+        ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
         parfileref->fcb->inode_item.st_size -= utf8len * 2;
         ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
@@ -2355,13 +2339,13 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
     fileref->fcb = fcb;
 
     if (Irp->Overlay.AllocationSize.QuadPart > 0 && !write_fcb_compressed(fcb)) {
-        Status = extend_file(fcb, fileref, Irp->Overlay.AllocationSize.QuadPart, TRUE, NULL, rollback);
+        Status = extend_file(fcb, fileref, Irp->Overlay.AllocationSize.QuadPart, true, NULL, rollback);
 
         if (!NT_SUCCESS(Status)) {
             ERR("extend_file returned %08x\n", Status);
             reap_fileref(Vcb, fileref);
 
-            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
             parfileref->fcb->inode_item.st_size -= utf8len * 2;
             ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
@@ -2377,7 +2361,7 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
             ERR("out of memory\n");
             reap_fileref(Vcb, fileref);
 
-            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
             parfileref->fcb->inode_item.st_size -= utf8len * 2;
             ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
@@ -2393,7 +2377,7 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
             ERR("out of memory\n");
             reap_fileref(Vcb, fileref);
 
-            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
             parfileref->fcb->inode_item.st_size -= utf8len * 2;
             ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
@@ -2405,26 +2389,26 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
         RtlZeroMemory(fcb->hash_ptrs_uc, sizeof(LIST_ENTRY*) * 256);
     }
 
-    fcb->deleted = FALSE;
+    fcb->deleted = false;
 
-    fileref->created = TRUE;
+    fileref->created = true;
 
     fcb->subvol->root_item.ctransid = Vcb->superblock.generation;
     fcb->subvol->root_item.ctime = now;
 
     utf8as.Buffer = utf8;
-    utf8as.Length = utf8as.MaximumLength = (UINT16)utf8len;
+    utf8as.Length = utf8as.MaximumLength = (uint16_t)utf8len;
 
-    ExAcquireResourceExclusiveLite(&parfileref->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&parfileref->fcb->nonpaged->dir_children_lock, true);
 
     // check again doesn't already exist
     if (case_sensitive) {
-        UINT32 dc_hash = calc_crc32c(0xffffffff, (UINT8*)fpus->Buffer, fpus->Length);
+        uint32_t dc_hash = calc_crc32c(0xffffffff, (uint8_t*)fpus->Buffer, fpus->Length);
 
         if (parfileref->fcb->hash_ptrs[dc_hash >> 24]) {
             LIST_ENTRY* le = parfileref->fcb->hash_ptrs[dc_hash >> 24];
             while (le != &parfileref->fcb->dir_children_hash) {
-                dir_child* dc = CONTAINING_RECORD(le, dir_child, list_entry_hash);
+                dc = CONTAINING_RECORD(le, dir_child, list_entry_hash);
 
                 if (dc->hash == dc_hash && dc->name.Length == fpus->Length && RtlCompareMemory(dc->name.Buffer, fpus->Buffer, fpus->Length) == fpus->Length) {
                     existing_fileref = dc->fileref;
@@ -2441,13 +2425,13 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
         UINT32 dc_hash;
 #endif
 
-        Status = RtlUpcaseUnicodeString(&fpusuc, fpus, TRUE);
+        Status = RtlUpcaseUnicodeString(&fpusuc, fpus, true);
         if (!NT_SUCCESS(Status)) {
             ExReleaseResourceLite(&parfileref->fcb->nonpaged->dir_children_lock);
             ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
             reap_fileref(Vcb, fileref);
 
-            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
             parfileref->fcb->inode_item.st_size -= utf8len * 2;
             ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
@@ -2465,7 +2449,7 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
         if (parfileref->fcb->hash_ptrs_uc[dc_hash >> 24]) {
             LIST_ENTRY* le = parfileref->fcb->hash_ptrs_uc[dc_hash >> 24];
             while (le != &parfileref->fcb->dir_children_hash_uc) {
-                dir_child* dc = CONTAINING_RECORD(le, dir_child, list_entry_hash_uc);
+                dc = CONTAINING_RECORD(le, dir_child, list_entry_hash_uc);
 
                 if (dc->hash_uc == dc_hash && dc->name.Length == fpusuc.Length && RtlCompareMemory(dc->name.Buffer, fpusuc.Buffer, fpusuc.Length) == fpusuc.Length) {
                     existing_fileref = dc->fileref;
@@ -2484,7 +2468,7 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
         ExReleaseResourceLite(&parfileref->fcb->nonpaged->dir_children_lock);
         reap_fileref(Vcb, fileref);
 
-        ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+        ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
         parfileref->fcb->inode_item.st_size -= utf8len * 2;
         ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
@@ -2496,13 +2480,13 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
         return STATUS_OBJECT_NAME_COLLISION;
     }
 
-    Status = add_dir_child(parfileref->fcb, fcb->inode, FALSE, &utf8as, fpus, fcb->type, &dc);
+    Status = add_dir_child(parfileref->fcb, fcb->inode, false, &utf8as, fpus, fcb->type, &dc);
     if (!NT_SUCCESS(Status)) {
         ExReleaseResourceLite(&parfileref->fcb->nonpaged->dir_children_lock);
         ERR("add_dir_child returned %08x\n", Status);
         reap_fileref(Vcb, fileref);
 
-        ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+        ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
         parfileref->fcb->inode_item.st_size -= utf8len * 2;
         ExReleaseResourceLite(parfileref->fcb->Header.Resource);
 
@@ -2528,14 +2512,14 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr
 
     *pfr = fileref;
 
-    TRACE("created new file %S in subvol %llx, inode %llx\n", file_desc_fileref(fileref), fcb->subvol->id, fcb->inode);
+    TRACE("created new file %S in subvol %I64x, inode %I64x\n", file_desc_fileref(fileref), fcb->subvol->id, fcb->inode);
 
     return STATUS_SUCCESS;
 }
 
 static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension* Vcb,
                               file_ref** pfileref, file_ref** pparfileref, PUNICODE_STRING fpus, PUNICODE_STRING stream, PIRP Irp,
-                              ULONG options, POOL_TYPE pool_type, BOOL case_sensitive, LIST_ENTRY* rollback) {
+                              ULONG options, POOL_TYPE pool_type, bool case_sensitive, LIST_ENTRY* rollback) {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     file_ref *fileref, *newpar, *parfileref;
     fcb* fcb;
@@ -2568,12 +2552,12 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
     if (parfileref->fcb == Vcb->dummy_fcb)
         return STATUS_ACCESS_DENIED;
 
-    Status = open_fileref(Vcb, &newpar, fpus, parfileref, FALSE, NULL, NULL, PagedPool, case_sensitive, Irp);
+    Status = open_fileref(Vcb, &newpar, fpus, parfileref, false, NULL, NULL, PagedPool, case_sensitive, Irp);
 
     if (Status == STATUS_OBJECT_NAME_NOT_FOUND) {
         UNICODE_STRING fpus2;
 
-        if (!is_file_name_valid(fpus, FALSE))
+        if (!is_file_name_valid(fpus, false))
             return STATUS_OBJECT_NAME_INVALID;
 
         fpus2.Length = fpus2.MaximumLength = fpus->Length;
@@ -2589,7 +2573,7 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
         SeLockSubjectContext(&IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext);
 
         if (!SeAccessCheck(parfileref->fcb->sd, &IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext,
-                           TRUE, options & FILE_DIRECTORY_FILE ? FILE_ADD_SUBDIRECTORY : FILE_ADD_FILE, 0, NULL,
+                           true, options & FILE_DIRECTORY_FILE ? FILE_ADD_SUBDIRECTORY : FILE_ADD_FILE, 0, NULL,
                            IoGetFileObjectGenericMapping(), IrpSp->Flags & SL_FORCE_ACCESS_CHECK ? UserMode : Irp->RequestorMode,
                            &granted_access, &Status)) {
             SeUnlockSubjectContext(&IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext);
@@ -2638,7 +2622,7 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
     SeLockSubjectContext(&IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext);
 
     if (!SeAccessCheck(parfileref->fcb->sd, &IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext,
-                       TRUE, FILE_WRITE_DATA, 0, NULL, IoGetFileObjectGenericMapping(), IrpSp->Flags & SL_FORCE_ACCESS_CHECK ? UserMode : Irp->RequestorMode,
+                       true, FILE_WRITE_DATA, 0, NULL, IoGetFileObjectGenericMapping(), IrpSp->Flags & SL_FORCE_ACCESS_CHECK ? UserMode : Irp->RequestorMode,
                        &granted_access, &Status)) {
         SeUnlockSubjectContext(&IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext);
         free_fileref(parfileref);
@@ -2679,17 +2663,17 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
     fcb->inode = parfileref->fcb->inode;
     fcb->type = parfileref->fcb->type;
 
-    fcb->ads = TRUE;
+    fcb->ads = true;
 
-    Status = RtlUnicodeToUTF8N(NULL, 0, &utf8len, stream->Buffer, stream->Length);
+    Status = utf16_to_utf8(NULL, 0, &utf8len, stream->Buffer, stream->Length);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUnicodeToUTF8N 1 returned %08x\n", Status);
+        ERR("utf16_to_utf8 1 returned %08x\n", Status);
         reap_fcb(fcb);
         free_fileref(parfileref);
         return Status;
     }
 
-    fcb->adsxattr.Length = (UINT16)utf8len + sizeof(xapref) - 1;
+    fcb->adsxattr.Length = (uint16_t)utf8len + sizeof(xapref) - 1;
     fcb->adsxattr.MaximumLength = fcb->adsxattr.Length + 1;
     fcb->adsxattr.Buffer = ExAllocatePoolWithTag(pool_type, fcb->adsxattr.MaximumLength, ALLOC_TAG);
     if (!fcb->adsxattr.Buffer) {
@@ -2701,9 +2685,9 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
 
     RtlCopyMemory(fcb->adsxattr.Buffer, xapref, sizeof(xapref) - 1);
 
-    Status = RtlUnicodeToUTF8N(&fcb->adsxattr.Buffer[sizeof(xapref) - 1], utf8len, &utf8len, stream->Buffer, stream->Length);
+    Status = utf16_to_utf8(&fcb->adsxattr.Buffer[sizeof(xapref) - 1], utf8len, &utf8len, stream->Buffer, stream->Length);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUnicodeToUTF8N 2 returned %08x\n", Status);
+        ERR("utf16_to_utf8 2 returned %08x\n", Status);
         reap_fcb(fcb);
         free_fileref(parfileref);
         return Status;
@@ -2713,14 +2697,14 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
 
     TRACE("adsxattr = %s\n", fcb->adsxattr.Buffer);
 
-    fcb->adshash = calc_crc32c(0xfffffffe, (UINT8*)fcb->adsxattr.Buffer, fcb->adsxattr.Length);
+    fcb->adshash = calc_crc32c(0xfffffffe, (uint8_t*)fcb->adsxattr.Buffer, fcb->adsxattr.Length);
     TRACE("adshash = %08x\n", fcb->adshash);
 
     searchkey.obj_id = parfileref->fcb->inode;
     searchkey.obj_type = TYPE_XATTR_ITEM;
     searchkey.offset = fcb->adshash;
 
-    Status = find_item(Vcb, parfileref->fcb->subvol, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, parfileref->fcb->subvol, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         reap_fcb(fcb);
@@ -2743,8 +2727,8 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
     } else
         fcb->adsmaxlen -= overhead + utf8len + sizeof(xapref) - 1;
 
-    fcb->created = TRUE;
-    fcb->deleted = TRUE;
+    fcb->created = true;
+    fcb->deleted = true;
 
     acquire_fcb_lock_exclusive(Vcb);
     InsertHeadList(&parfileref->fcb->list_entry, &fcb->list_entry); // insert in list after parent fcb
@@ -2799,7 +2783,7 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
 
     RtlCopyMemory(dc->name.Buffer, stream->Buffer, stream->Length);
 
-    Status = RtlUpcaseUnicodeString(&dc->name_uc, &dc->name, TRUE);
+    Status = RtlUpcaseUnicodeString(&dc->name_uc, &dc->name, true);
     if (!NT_SUCCESS(Status)) {
         ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
         ExFreePool(dc->utf8.Buffer);
@@ -2813,7 +2797,7 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
     KeQuerySystemTime(&time);
     win_time_to_unix(time, &now);
 
-    ExAcquireResourceExclusiveLite(&parfileref->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&parfileref->fcb->nonpaged->dir_children_lock, true);
 
 #ifndef __REACTOS__
     LIST_ENTRY* le = parfileref->fcb->dir_children_index.Flink;
@@ -2852,7 +2836,7 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
     dc->fileref = fileref;
     fileref->dc = dc;
     fileref->parent = (struct _file_ref*)parfileref;
-    fcb->deleted = FALSE;
+    fcb->deleted = false;
 
     InsertHeadList(&parfileref->fcb->dir_children_index, &dc->list_entry_index);
 
@@ -2865,7 +2849,7 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
     parfileref->fcb->inode_item.transid = Vcb->superblock.generation;
     parfileref->fcb->inode_item.sequence++;
     parfileref->fcb->inode_item.st_ctime = now;
-    parfileref->fcb->inode_item_changed = TRUE;
+    parfileref->fcb->inode_item_changed = true;
 
     mark_fcb_dirty(parfileref->fcb);
 
@@ -2883,19 +2867,7 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
 
 // LXSS programs can be distinguished by the fact they have a NULL PEB.
 #ifdef _AMD64_
-#ifdef __REACTOS__
-NTSYSAPI
-NTSTATUS
-NTAPI
-ZwQueryInformationProcess (
-    _In_ HANDLE ProcessHandle,
-    _In_ PROCESSINFOCLASS ProcessInformationClass,
-    _Out_ PVOID ProcessInformation,
-    _In_ ULONG ProcessInformationLength,
-    _Out_opt_ PULONG ReturnLength
-);
-#endif
-static __inline BOOL called_from_lxss() {
+static __inline bool called_from_lxss() {
     NTSTATUS Status;
     PROCESS_BASIC_INFORMATION pbi;
     ULONG retlen;
@@ -2904,17 +2876,17 @@ static __inline BOOL called_from_lxss() {
 
     if (!NT_SUCCESS(Status)) {
         ERR("ZwQueryInformationProcess returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
     return !pbi.PebBaseAddress;
 }
 #else
-#define called_from_lxss() FALSE
+#define called_from_lxss() false
 #endif
 
 static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension* Vcb,
-                            PFILE_OBJECT FileObject, file_ref* related, BOOL loaded_related, PUNICODE_STRING fnus, ULONG disposition, ULONG options,
+                            PFILE_OBJECT FileObject, file_ref* related, bool loaded_related, PUNICODE_STRING fnus, ULONG disposition, ULONG options,
                             file_ref** existing_fileref, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     file_ref *fileref, *parfileref = NULL;
@@ -2938,21 +2910,23 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R
     if (options & FILE_DELETE_ON_CLOSE && IrpSp->Parameters.Create.FileAttributes & FILE_ATTRIBUTE_READONLY)
         return STATUS_CANNOT_DELETE;
 
-    if (NT_SUCCESS(FsRtlGetEcpListFromIrp(Irp, &ecp_list)) && ecp_list) {
-        void* ctx = NULL;
-        GUID type;
-        ULONG ctxsize;
+    if (fFsRtlGetEcpListFromIrp && fFsRtlGetNextExtraCreateParameter) {
+        if (NT_SUCCESS(fFsRtlGetEcpListFromIrp(Irp, &ecp_list)) && ecp_list) {
+            void* ctx = NULL;
+            GUID type;
+            ULONG ctxsize;
 
-        do {
-            Status = FsRtlGetNextExtraCreateParameter(ecp_list, ctx, &type, &ctx, &ctxsize);
+            do {
+                Status = fFsRtlGetNextExtraCreateParameter(ecp_list, ctx, &type, &ctx, &ctxsize);
 
-            if (NT_SUCCESS(Status)) {
-                if (RtlCompareMemory(&type, &GUID_ECP_ATOMIC_CREATE, sizeof(GUID)) == sizeof(GUID) && ctxsize >= sizeof(ATOMIC_CREATE_ECP_CONTEXT)) {
-                    acec = ctx;
-                    break;
+                if (NT_SUCCESS(Status)) {
+                    if (RtlCompareMemory(&type, &GUID_ECP_ATOMIC_CREATE, sizeof(GUID)) == sizeof(GUID) && ctxsize >= sizeof(ATOMIC_CREATE_ECP_CONTEXT)) {
+                        acec = ctx;
+                        break;
+                    }
                 }
-            }
-        } while (NT_SUCCESS(Status));
+            } while (NT_SUCCESS(Status));
+        }
     }
 
     dsus.Buffer = (WCHAR*)datasuf;
@@ -2960,7 +2934,7 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R
     fpus.Buffer = NULL;
 
     if (!loaded_related) {
-        Status = open_fileref(Vcb, &parfileref, fnus, related, TRUE, NULL, NULL, pool_type, IrpSp->Flags & SL_CASE_SENSITIVE, Irp);
+        Status = open_fileref(Vcb, &parfileref, fnus, related, true, NULL, NULL, pool_type, IrpSp->Flags & SL_CASE_SENSITIVE, Irp);
 
         if (!NT_SUCCESS(Status))
             goto end;
@@ -3005,7 +2979,7 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R
 
         TRACE("lb = %.*S\n", lb.Length/sizeof(WCHAR), lb.Buffer);
 
-        if (FsRtlAreNamesEqual(&dsus, &lb, TRUE, NULL)) {
+        if (FsRtlAreNamesEqual(&dsus, &lb, true, NULL)) {
             TRACE("ignoring :$DATA suffix\n");
 
             fpus.Length -= lb.Length;
@@ -3041,7 +3015,7 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R
     } else {
         ACCESS_MASK granted_access;
 
-        if (!is_file_name_valid(&fpus, FALSE)) {
+        if (!is_file_name_valid(&fpus, false)) {
             Status = STATUS_OBJECT_NAME_INVALID;
             goto end;
         }
@@ -3049,7 +3023,7 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R
         SeLockSubjectContext(&IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext);
 
         if (!SeAccessCheck(parfileref->fcb->sd, &IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext,
-                           TRUE, options & FILE_DIRECTORY_FILE ? FILE_ADD_SUBDIRECTORY : FILE_ADD_FILE, 0, NULL,
+                           true, options & FILE_DIRECTORY_FILE ? FILE_ADD_SUBDIRECTORY : FILE_ADD_FILE, 0, NULL,
                            IoGetFileObjectGenericMapping(), IrpSp->Flags & SL_FORCE_ACCESS_CHECK ? UserMode : Irp->RequestorMode,
                            &granted_access, &Status)) {
             SeUnlockSubjectContext(&IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext);
@@ -3091,11 +3065,11 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R
     if (!ccb) {
         ERR("out of memory\n");
         Status = STATUS_INSUFFICIENT_RESOURCES;
-        fileref->deleted = TRUE;
-        fileref->fcb->deleted = TRUE;
+        fileref->deleted = true;
+        fileref->fcb->deleted = true;
 
         if (stream.Length == 0) {
-            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+            ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
             parfileref->fcb->inode_item.st_size -= fileref->dc->utf8.Length * 2;
             ExReleaseResourceLite(parfileref->fcb->Header.Resource);
         }
@@ -3114,11 +3088,11 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R
     ccb->options = options;
     ccb->query_dir_offset = 0;
     RtlInitUnicodeString(&ccb->query_string, NULL);
-    ccb->has_wildcard = FALSE;
-    ccb->specific_file = FALSE;
+    ccb->has_wildcard = false;
+    ccb->specific_file = false;
     ccb->access = IrpSp->Parameters.Create.SecurityContext->DesiredAccess;
     ccb->case_sensitive = IrpSp->Flags & SL_CASE_SENSITIVE;
-    ccb->reserving = FALSE;
+    ccb->reserving = false;
     ccb->lxss = called_from_lxss();
 
 #ifdef DEBUG_FCB_REFCOUNTS
@@ -3135,7 +3109,7 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R
 
     // FIXME - ATOMIC_CREATE_ECP_IN_FLAG_BEST_EFFORT
     if (acec && acec->InFlags & ATOMIC_CREATE_ECP_IN_FLAG_REPARSE_POINT_SPECIFIED) {
-        if (acec->ReparseBufferLength > sizeof(UINT32) && *(UINT32*)acec->ReparseBuffer == IO_REPARSE_TAG_SYMLINK) {
+        if (acec->ReparseBufferLength > sizeof(uint32_t) && *(uint32_t*)acec->ReparseBuffer == IO_REPARSE_TAG_SYMLINK) {
             fileref->fcb->inode_item.st_mode &= ~(__S_IFIFO | __S_IFCHR | __S_IFBLK | __S_IFSOCK);
             fileref->fcb->type = BTRFS_TYPE_FILE;
         }
@@ -3147,11 +3121,11 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R
             Status = set_reparse_point2(fileref->fcb, acec->ReparseBuffer, acec->ReparseBufferLength, NULL, NULL, Irp, rollback);
             if (!NT_SUCCESS(Status)) {
                 ERR("set_reparse_point2 returned %08x\n", Status);
-                fileref->deleted = TRUE;
-                fileref->fcb->deleted = TRUE;
+                fileref->deleted = true;
+                fileref->fcb->deleted = true;
 
                 if (stream.Length == 0) {
-                    ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE);
+                    ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, true);
                     parfileref->fcb->inode_item.st_size -= fileref->dc->utf8.Length * 2;
                     ExReleaseResourceLite(parfileref->fcb->Header.Resource);
                 }
@@ -3304,7 +3278,7 @@ static __inline void debug_create_options(ULONG RequestedOptions) {
     }
 }
 
-static NTSTATUS get_reparse_block(fcb* fcb, UINT8** data) {
+static NTSTATUS get_reparse_block(fcb* fcb, uint8_t** data) {
     NTSTATUS Status;
 
     if (fcb->type == BTRFS_TYPE_FILE || fcb->type == BTRFS_TYPE_SYMLINK) {
@@ -3336,12 +3310,12 @@ static NTSTATUS get_reparse_block(fcb* fcb, UINT8** data) {
 
         if (fcb->type == BTRFS_TYPE_SYMLINK) {
             ULONG stringlen, reqlen;
-            UINT16 subnamelen, printnamelen;
+            uint16_t subnamelen, printnamelen;
             REPARSE_DATA_BUFFER* rdb;
 
-            Status = RtlUTF8ToUnicodeN(NULL, 0, &stringlen, (char*)*data, bytes_read);
+            Status = utf8_to_utf16(NULL, 0, &stringlen, (char*)*data, bytes_read);
             if (!NT_SUCCESS(Status)) {
-                ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
+                ERR("utf8_to_utf16 1 returned %08x\n", Status);
                 ExFreePool(*data);
                 return Status;
             }
@@ -3368,11 +3342,11 @@ static NTSTATUS get_reparse_block(fcb* fcb, UINT8** data) {
             rdb->SymbolicLinkReparseBuffer.PrintNameLength = printnamelen;
             rdb->SymbolicLinkReparseBuffer.Flags = SYMLINK_FLAG_RELATIVE;
 
-            Status = RtlUTF8ToUnicodeN(&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
+            Status = utf8_to_utf16(&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
                                     stringlen, &stringlen, (char*)*data, size);
 
             if (!NT_SUCCESS(Status)) {
-                ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
+                ERR("utf8_to_utf16 2 returned %08x\n", Status);
                 ExFreePool(rdb);
                 ExFreePool(*data);
                 return Status;
@@ -3389,9 +3363,9 @@ static NTSTATUS get_reparse_block(fcb* fcb, UINT8** data) {
 
             ExFreePool(*data);
 
-            *data = (UINT8*)rdb;
+            *data = (uint8_t*)rdb;
         } else {
-            Status = FsRtlValidateReparsePointBuffer(bytes_read, (REPARSE_DATA_BUFFER*)*data);
+            Status = fFsRtlValidateReparsePointBuffer(bytes_read, (REPARSE_DATA_BUFFER*)*data);
             if (!NT_SUCCESS(Status)) {
                 ERR("FsRtlValidateReparsePointBuffer returned %08x\n", Status);
                 ExFreePool(*data);
@@ -3407,7 +3381,7 @@ static NTSTATUS get_reparse_block(fcb* fcb, UINT8** data) {
             return STATUS_INTERNAL_ERROR;
         }
 
-        Status = FsRtlValidateReparsePointBuffer(fcb->reparse_xattr.Length, (REPARSE_DATA_BUFFER*)fcb->reparse_xattr.Buffer);
+        Status = fFsRtlValidateReparsePointBuffer(fcb->reparse_xattr.Length, (REPARSE_DATA_BUFFER*)fcb->reparse_xattr.Buffer);
         if (!NT_SUCCESS(Status)) {
             ERR("FsRtlValidateReparsePointBuffer returned %08x\n", Status);
             return Status;
@@ -3442,11 +3416,11 @@ static void fcb_load_csums(_Requires_lock_held_(_Curr_->tree_lock) device_extens
 
         if (ext->extent_data.type == EXTENT_TYPE_REGULAR) {
             EXTENT_DATA2* ed2 = (EXTENT_DATA2*)&ext->extent_data.data[0];
-            UINT64 len;
+            uint64_t len;
 
             len = (ext->extent_data.compression == BTRFS_COMPRESSION_NONE ? ed2->num_bytes : ed2->size) / Vcb->superblock.sector_size;
 
-            ext->csum = ExAllocatePoolWithTag(NonPagedPool, (ULONG)(len * sizeof(UINT32)), ALLOC_TAG);
+            ext->csum = ExAllocatePoolWithTag(NonPagedPool, (ULONG)(len * sizeof(uint32_t)), ALLOC_TAG);
             if (!ext->csum) {
                 ERR("out of memory\n");
                 goto end;
@@ -3464,23 +3438,20 @@ static void fcb_load_csums(_Requires_lock_held_(_Curr_->tree_lock) device_extens
     }
 
 end:
-    fcb->csum_loaded = TRUE;
+    fcb->csum_loaded = true;
 }
 
 static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, POOL_TYPE pool_type, file_ref* fileref, ACCESS_MASK* granted_access,
                            PFILE_OBJECT FileObject, UNICODE_STRING* fn, ULONG options, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     file_ref* sf;
-    BOOL readonly;
+    bool readonly;
     ccb* ccb;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
     if (RequestedDisposition == FILE_SUPERSEDE || RequestedDisposition == FILE_OVERWRITE || RequestedDisposition == FILE_OVERWRITE_IF) {
         LARGE_INTEGER zero;
 
-#ifdef DEBUG_STATS
-        open_type = 1;
-#endif
         if (fileref->fcb->type == BTRFS_TYPE_DIRECTORY || is_subvol_readonly(fileref->fcb->subvol, Irp)) {
             free_fileref(fileref);
 
@@ -3506,7 +3477,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
 
         if (!SeAccessCheck((fileref->fcb->ads || fileref->fcb == Vcb->dummy_fcb) ? fileref->parent->fcb->sd : fileref->fcb->sd,
                             &IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext,
-                            TRUE, IrpSp->Parameters.Create.SecurityContext->DesiredAccess, 0, NULL,
+                            true, IrpSp->Parameters.Create.SecurityContext->DesiredAccess, 0, NULL,
                             IoGetFileObjectGenericMapping(), IrpSp->Flags & SL_FORCE_ACCESS_CHECK ? UserMode : Irp->RequestorMode,
                             granted_access, &Status)) {
             SeUnlockSubjectContext(&IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext);
@@ -3521,7 +3492,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
     } else
         *granted_access = 0;
 
-    TRACE("deleted = %s\n", fileref->deleted ? "TRUE" : "FALSE");
+    TRACE("deleted = %s\n", fileref->deleted ? "true" : "false");
 
     sf = fileref;
     while (sf) {
@@ -3585,7 +3556,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
             * a pointer to the reparse data buffer in Irp->Tail.Overlay.AuxiliaryBuffer,
             * IopSymlinkProcessReparse will do the translation for us. */
 
-        Status = get_reparse_block(fileref->fcb, (UINT8**)&data);
+        Status = get_reparse_block(fileref->fcb, (uint8_t**)&data);
         if (!NT_SUCCESS(Status)) {
             ERR("get_reparse_block returned %08x\n", Status);
             Status = STATUS_SUCCESS;
@@ -3618,7 +3589,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
     }
 
     if (fileref->open_count > 0) {
-        Status = IoCheckShareAccess(*granted_access, IrpSp->Parameters.Create.ShareAccess, FileObject, &fileref->fcb->share_access, FALSE);
+        Status = IoCheckShareAccess(*granted_access, IrpSp->Parameters.Create.ShareAccess, FileObject, &fileref->fcb->share_access, false);
 
         if (!NT_SUCCESS(Status)) {
             if (Status == STATUS_SHARING_VIOLATION)
@@ -3670,7 +3641,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
         }
 
         if (fileref->fcb->ads) {
-            Status = stream_set_end_of_file_information(Vcb, 0, fileref->fcb, fileref, FALSE);
+            Status = stream_set_end_of_file_information(Vcb, 0, fileref->fcb, fileref, false);
             if (!NT_SUCCESS(Status)) {
                 ERR("stream_set_end_of_file_information returned %08x\n", Status);
 
@@ -3694,7 +3665,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
         }
 
         if (Irp->Overlay.AllocationSize.QuadPart > 0) {
-            Status = extend_file(fileref->fcb, fileref, Irp->Overlay.AllocationSize.QuadPart, TRUE, NULL, rollback);
+            Status = extend_file(fileref->fcb, fileref, Irp->Overlay.AllocationSize.QuadPart, true, NULL, rollback);
 
             if (!NT_SUCCESS(Status)) {
                 ERR("extend_file returned %08x\n", Status);
@@ -3742,8 +3713,8 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
                     if (eainfo->NextEntryOffset == 0)
                         break;
 
-                    eainfo = (FILE_FULL_EA_INFORMATION*)(((UINT8*)eainfo) + eainfo->NextEntryOffset);
-                } while (TRUE);
+                    eainfo = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)eainfo) + eainfo->NextEntryOffset);
+                } while (true);
 
                 if (fileref->fcb->ea_xattr.Buffer)
                     ExFreePool(fileref->fcb->ea_xattr.Buffer);
@@ -3767,7 +3738,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
                     fileref->fcb->ea_xattr.Buffer = NULL;
                     fileref->fcb->ea_xattr.Length = fileref->fcb->ea_xattr.MaximumLength = 0;
 
-                    fileref->fcb->ea_changed = TRUE;
+                    fileref->fcb->ea_changed = true;
                     fileref->fcb->ealen = 0;
                 }
             }
@@ -3782,7 +3753,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
                     if (!dc->fileref) {
                         file_ref* fr2;
 
-                        Status = open_fileref_child(Vcb, fileref, &dc->name, TRUE, TRUE, TRUE, PagedPool, &fr2, NULL);
+                        Status = open_fileref_child(Vcb, fileref, &dc->name, true, true, true, PagedPool, &fr2, NULL);
                         if (!NT_SUCCESS(Status))
                             WARN("open_fileref_child returned %08x\n", Status);
                     }
@@ -3790,7 +3761,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
                     if (dc->fileref) {
                         send_notification_fcb(fileref, FILE_NOTIFY_CHANGE_STREAM_NAME, FILE_ACTION_REMOVED_STREAM, &dc->name);
 
-                        Status = delete_fileref(dc->fileref, NULL, FALSE, NULL, rollback);
+                        Status = delete_fileref(dc->fileref, NULL, false, NULL, rollback);
                         if (!NT_SUCCESS(Status)) {
                             ERR("delete_fileref returned %08x\n", Status);
 
@@ -3813,7 +3784,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
 
         if (fileref->fcb->ads) {
             fileref->parent->fcb->inode_item.st_mtime = now;
-            fileref->parent->fcb->inode_item_changed = TRUE;
+            fileref->parent->fcb->inode_item_changed = true;
             mark_fcb_dirty(fileref->parent->fcb);
 
             send_notification_fcb(fileref->parent, filter, FILE_ACTION_MODIFIED, &fileref->dc->name);
@@ -3823,7 +3794,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
             oldatts = fileref->fcb->atts;
 
             defda = get_file_attributes(Vcb, fileref->fcb->subvol, fileref->fcb->inode, fileref->fcb->type,
-                                        fileref->dc && fileref->dc->name.Length >= sizeof(WCHAR) && fileref->dc->name.Buffer[0] == '.', TRUE, Irp);
+                                        fileref->dc && fileref->dc->name.Length >= sizeof(WCHAR) && fileref->dc->name.Buffer[0] == '.', true, Irp);
 
             if (RequestedDisposition == FILE_SUPERSEDE)
                 fileref->fcb->atts = IrpSp->Parameters.Create.FileAttributes | FILE_ATTRIBUTE_ARCHIVE;
@@ -3831,7 +3802,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
                 fileref->fcb->atts |= IrpSp->Parameters.Create.FileAttributes | FILE_ATTRIBUTE_ARCHIVE;
 
             if (fileref->fcb->atts != oldatts) {
-                fileref->fcb->atts_changed = TRUE;
+                fileref->fcb->atts_changed = true;
                 fileref->fcb->atts_deleted = IrpSp->Parameters.Create.FileAttributes == defda;
                 filter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
             }
@@ -3840,7 +3811,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
             fileref->fcb->inode_item.sequence++;
             fileref->fcb->inode_item.st_ctime = now;
             fileref->fcb->inode_item.st_mtime = now;
-            fileref->fcb->inode_item_changed = TRUE;
+            fileref->fcb->inode_item_changed = true;
 
             send_notification_fcb(fileref, filter, FILE_ACTION_MODIFIED, NULL);
         }
@@ -3862,8 +3833,8 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
                 if (ffei->NextEntryOffset == 0)
                     break;
 
-                ffei = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ffei) + ffei->NextEntryOffset);
-            } while (TRUE);
+                ffei = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ffei) + ffei->NextEntryOffset);
+            } while (true);
         }
     }
 
@@ -3888,11 +3859,11 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
     ccb->options = options;
     ccb->query_dir_offset = 0;
     RtlInitUnicodeString(&ccb->query_string, NULL);
-    ccb->has_wildcard = FALSE;
-    ccb->specific_file = FALSE;
+    ccb->has_wildcard = false;
+    ccb->specific_file = false;
     ccb->access = *granted_access;
     ccb->case_sensitive = IrpSp->Flags & SL_CASE_SENSITIVE;
-    ccb->reserving = FALSE;
+    ccb->reserving = false;
     ccb->lxss = called_from_lxss();
 
     ccb->fileref = fileref;
@@ -3900,31 +3871,29 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
     FileObject->FsContext2 = ccb;
     FileObject->SectionObjectPointer = &fileref->fcb->nonpaged->segment_object;
 
-    if (NT_SUCCESS(Status)) {
-        switch (RequestedDisposition) {
-            case FILE_SUPERSEDE:
-                Irp->IoStatus.Information = FILE_SUPERSEDED;
-                break;
+    switch (RequestedDisposition) {
+        case FILE_SUPERSEDE:
+            Irp->IoStatus.Information = FILE_SUPERSEDED;
+            break;
 
-            case FILE_OPEN:
-            case FILE_OPEN_IF:
-                Irp->IoStatus.Information = FILE_OPENED;
-                break;
+        case FILE_OPEN:
+        case FILE_OPEN_IF:
+            Irp->IoStatus.Information = FILE_OPENED;
+            break;
 
-            case FILE_OVERWRITE:
-            case FILE_OVERWRITE_IF:
-                Irp->IoStatus.Information = FILE_OVERWRITTEN;
-                break;
-        }
+        case FILE_OVERWRITE:
+        case FILE_OVERWRITE_IF:
+            Irp->IoStatus.Information = FILE_OVERWRITTEN;
+            break;
     }
 
     // Make sure paging files don't have any extents marked as being prealloc,
     // as this would mean we'd have to lock exclusively when writing.
     if (IrpSp->Flags & SL_OPEN_PAGING_FILE) {
         LIST_ENTRY* le;
-        BOOL changed = FALSE;
+        bool changed = false;
 
-        ExAcquireResourceExclusiveLite(fileref->fcb->Header.Resource, TRUE);
+        ExAcquireResourceExclusiveLite(fileref->fcb->Header.Resource, true);
 
         le = fileref->fcb->extents.Flink;
 
@@ -3933,7 +3902,7 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
 
             if (ext->extent_data.type == EXTENT_TYPE_PREALLOC) {
                 ext->extent_data.type = EXTENT_TYPE_REGULAR;
-                changed = TRUE;
+                changed = true;
             }
 
             le = le->Flink;
@@ -3942,12 +3911,11 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
         ExReleaseResourceLite(fileref->fcb->Header.Resource);
 
         if (changed) {
-            fileref->fcb->extents_changed = TRUE;
+            fileref->fcb->extents_changed = true;
             mark_fcb_dirty(fileref->fcb);
         }
 
         fileref->fcb->Header.Flags2 |= FSRTL_FLAG2_IS_PAGING_FILE;
-        Vcb->disallow_dismount = TRUE;
     }
 
 #ifdef DEBUG_FCB_REFCOUNTS
@@ -3962,21 +3930,21 @@ static NTSTATUS open_file2(device_extension* Vcb, ULONG RequestedDisposition, PO
 }
 
 NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension* Vcb,
-                               root* subvol, UINT64 inode, file_ref** pfr, PIRP Irp) {
+                               root* subvol, uint64_t inode, file_ref** pfr, PIRP Irp) {
     NTSTATUS Status;
     fcb* fcb;
-    UINT64 parent = 0;
+    uint64_t parent = 0;
     UNICODE_STRING name;
-    BOOL hl_alloc = FALSE;
+    bool hl_alloc = false;
     file_ref *parfr, *fr;
 
-    Status = open_fcb(Vcb, subvol, inode, 0, NULL, TRUE, NULL, &fcb, PagedPool, Irp);
+    Status = open_fcb(Vcb, subvol, inode, 0, NULL, true, NULL, &fcb, PagedPool, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("open_fcb returned %08x\n", Status);
         return Status;
     }
 
-    ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
     if (fcb->inode_item.st_nlink == 0 || fcb->deleted) {
         ExReleaseResourceLite(fcb->Header.Resource);
@@ -3995,12 +3963,12 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
     if (IsListEmpty(&fcb->hardlinks)) {
         ExReleaseResourceLite(fcb->Header.Resource);
 
-        ExAcquireResourceSharedLite(&Vcb->dirty_filerefs_lock, TRUE);
+        ExAcquireResourceSharedLite(&Vcb->dirty_filerefs_lock, true);
 
         if (!IsListEmpty(&Vcb->dirty_filerefs)) {
             LIST_ENTRY* le = Vcb->dirty_filerefs.Flink;
             while (le != &Vcb->dirty_filerefs) {
-                file_ref* fr = CONTAINING_RECORD(le, file_ref, list_entry_dirty);
+                fr = CONTAINING_RECORD(le, file_ref, list_entry_dirty);
 
                 if (fr->fcb == fcb) {
                     ExReleaseResourceLite(&Vcb->dirty_filerefs_lock);
@@ -4024,7 +3992,7 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
             searchkey.obj_type = TYPE_INODE_REF;
             searchkey.offset = 0;
 
-            Status = find_item(Vcb, subvol, &tp, &searchkey, FALSE, Irp);
+            Status = find_item(Vcb, subvol, &tp, &searchkey, false, Irp);
             if (!NT_SUCCESS(Status)) {
                 ERR("find_item returned %08x\n", Status);
                 free_fcb(fcb);
@@ -4054,14 +4022,14 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
                         ULONG stringlen;
 #endif
 
-                        Status = RtlUTF8ToUnicodeN(NULL, 0, &stringlen, ir->name, ir->n);
+                        Status = utf8_to_utf16(NULL, 0, &stringlen, ir->name, ir->n);
                         if (!NT_SUCCESS(Status)) {
-                            ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
+                            ERR("utf8_to_utf16 1 returned %08x\n", Status);
                             free_fcb(fcb);
                             return Status;
                         }
 
-                        name.Length = name.MaximumLength = (UINT16)stringlen;
+                        name.Length = name.MaximumLength = (uint16_t)stringlen;
 
                         if (stringlen == 0)
                             name.Buffer = NULL;
@@ -4074,15 +4042,15 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
                                 return STATUS_INSUFFICIENT_RESOURCES;
                             }
 
-                            Status = RtlUTF8ToUnicodeN(name.Buffer, stringlen, &stringlen, ir->name, ir->n);
+                            Status = utf8_to_utf16(name.Buffer, stringlen, &stringlen, ir->name, ir->n);
                             if (!NT_SUCCESS(Status)) {
-                                ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
+                                ERR("utf8_to_utf16 2 returned %08x\n", Status);
                                 ExFreePool(name.Buffer);
                                 free_fcb(fcb);
                                 return Status;
                             }
 
-                            hl_alloc = TRUE;
+                            hl_alloc = true;
                         }
 
                         parent = tp.item->key.offset;
@@ -4104,14 +4072,14 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
                         ULONG stringlen;
 #endif
 
-                        Status = RtlUTF8ToUnicodeN(NULL, 0, &stringlen, ier->name, ier->n);
+                        Status = utf8_to_utf16(NULL, 0, &stringlen, ier->name, ier->n);
                         if (!NT_SUCCESS(Status)) {
-                            ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
+                            ERR("utf8_to_utf16 1 returned %08x\n", Status);
                             free_fcb(fcb);
                             return Status;
                         }
 
-                        name.Length = name.MaximumLength = (UINT16)stringlen;
+                        name.Length = name.MaximumLength = (uint16_t)stringlen;
 
                         if (stringlen == 0)
                             name.Buffer = NULL;
@@ -4124,15 +4092,15 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
                                 return STATUS_INSUFFICIENT_RESOURCES;
                             }
 
-                            Status = RtlUTF8ToUnicodeN(name.Buffer, stringlen, &stringlen, ier->name, ier->n);
+                            Status = utf8_to_utf16(name.Buffer, stringlen, &stringlen, ier->name, ier->n);
                             if (!NT_SUCCESS(Status)) {
-                                ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
+                                ERR("utf8_to_utf16 2 returned %08x\n", Status);
                                 ExFreePool(name.Buffer);
                                 free_fcb(fcb);
                                 return Status;
                             }
 
-                            hl_alloc = TRUE;
+                            hl_alloc = true;
                         }
 
                         parent = ier->dir;
@@ -4141,11 +4109,11 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
                     }
                 }
 
-                if (find_next_item(Vcb, &tp, &next_tp, FALSE, Irp))
+                if (find_next_item(Vcb, &tp, &next_tp, false, Irp))
                     tp = next_tp;
                 else
                     break;
-            } while (TRUE);
+            } while (true);
         }
 
         if (parent == 0) {
@@ -4170,7 +4138,7 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
         searchkey.obj_type = TYPE_ROOT_BACKREF;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
             free_fcb(fcb);
@@ -4184,13 +4152,13 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
             ULONG stringlen;
 
             if (tp.item->size < sizeof(ROOT_REF)) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(ROOT_REF));
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(ROOT_REF));
                 free_fcb(fcb);
                 return STATUS_INTERNAL_ERROR;
             }
 
             if (tp.item->size < offsetof(ROOT_REF, name[0]) + rr->n) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, offsetof(ROOT_REF, name[0]) + rr->n);
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, offsetof(ROOT_REF, name[0]) + rr->n);
                 free_fcb(fcb);
                 return STATUS_INTERNAL_ERROR;
             }
@@ -4208,7 +4176,7 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
             }
 
             if (!r) {
-                ERR("couldn't find subvol %llx\n", tp.item->key.offset);
+                ERR("couldn't find subvol %I64x\n", tp.item->key.offset);
                 free_fcb(fcb);
                 return STATUS_INTERNAL_ERROR;
             }
@@ -4220,14 +4188,14 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
                 return Status;
             }
 
-            Status = RtlUTF8ToUnicodeN(NULL, 0, &stringlen, rr->name, rr->n);
+            Status = utf8_to_utf16(NULL, 0, &stringlen, rr->name, rr->n);
             if (!NT_SUCCESS(Status)) {
-                ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
+                ERR("utf8_to_utf16 1 returned %08x\n", Status);
                 free_fcb(fcb);
                 return Status;
             }
 
-            name.Length = name.MaximumLength = (UINT16)stringlen;
+            name.Length = name.MaximumLength = (uint16_t)stringlen;
 
             if (stringlen == 0)
                 name.Buffer = NULL;
@@ -4243,18 +4211,18 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
                     return STATUS_INSUFFICIENT_RESOURCES;
                 }
 
-                Status = RtlUTF8ToUnicodeN(name.Buffer, stringlen, &stringlen, rr->name, rr->n);
+                Status = utf8_to_utf16(name.Buffer, stringlen, &stringlen, rr->name, rr->n);
                 if (!NT_SUCCESS(Status)) {
-                    ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
+                    ERR("utf8_to_utf16 2 returned %08x\n", Status);
                     ExFreePool(name.Buffer);
                     free_fcb(fcb);
                     return Status;
                 }
 
-                hl_alloc = TRUE;
+                hl_alloc = true;
             }
         } else {
-            ERR("couldn't find parent for subvol %llx\n", subvol->id);
+            ERR("couldn't find parent for subvol %I64x\n", subvol->id);
             free_fcb(fcb);
             return STATUS_INTERNAL_ERROR;
         }
@@ -4267,7 +4235,7 @@ NTSTATUS open_fileref_by_inode(_Requires_exclusive_lock_held_(_Curr_->fcb_lock)
         }
     }
 
-    Status = open_fileref_child(Vcb, parfr, &name, TRUE, TRUE, FALSE, PagedPool, &fr, Irp);
+    Status = open_fileref_child(Vcb, parfr, &name, true, true, false, PagedPool, &fr, Irp);
 
     if (hl_alloc)
         ExFreePool(name.Buffer);
@@ -4300,14 +4268,8 @@ static NTSTATUS open_file(PDEVICE_OBJECT DeviceObject, _Requires_lock_held_(_Cur
     file_ref *related, *fileref = NULL;
     POOL_TYPE pool_type = IrpSp->Flags & SL_OPEN_PAGING_FILE ? NonPagedPool : PagedPool;
     ACCESS_MASK granted_access;
-    BOOL loaded_related = FALSE;
+    bool loaded_related = false;
     UNICODE_STRING fn;
-#ifdef DEBUG_STATS
-    LARGE_INTEGER time1, time2;
-    UINT8 open_type = 0;
-
-    time1 = KeQueryPerformanceCounter(NULL);
-#endif
 
     Irp->IoStatus.Information = 0;
 
@@ -4383,8 +4345,8 @@ static NTSTATUS open_file(PDEVICE_OBJECT DeviceObject, _Requires_lock_held_(_Cur
             goto exit;
         }
 
-        if (fn.Length == sizeof(UINT64)) {
-            UINT64 inode;
+        if (fn.Length == sizeof(uint64_t)) {
+            uint64_t inode;
 
             if (!related) {
                 WARN("cannot open by short file ID unless related fileref also provided");
@@ -4392,7 +4354,7 @@ static NTSTATUS open_file(PDEVICE_OBJECT DeviceObject, _Requires_lock_held_(_Cur
                 goto exit;
             }
 
-            RtlCopyMemory(&inode, fn.Buffer, sizeof(UINT64));
+            RtlCopyMemory(&inode, fn.Buffer, sizeof(uint64_t));
 
             if (related->fcb == Vcb->root_fileref->fcb && inode == 0)
                 inode = Vcb->root_fileref->fcb->inode;
@@ -4406,11 +4368,11 @@ static NTSTATUS open_file(PDEVICE_OBJECT DeviceObject, _Requires_lock_held_(_Cur
 
             goto loaded;
         } else if (fn.Length == sizeof(FILE_ID_128)) {
-            UINT64 inode, subvol_id;
+            uint64_t inode, subvol_id;
             root* subvol = NULL;
 
-            RtlCopyMemory(&inode, fn.Buffer, sizeof(UINT64));
-            RtlCopyMemory(&subvol_id, (UINT8*)fn.Buffer + sizeof(UINT64), sizeof(UINT64));
+            RtlCopyMemory(&inode, fn.Buffer, sizeof(uint64_t));
+            RtlCopyMemory(&subvol_id, (uint8_t*)fn.Buffer + sizeof(uint64_t), sizeof(uint64_t));
 
             if (subvol_id == BTRFS_ROOT_FSTREE || (subvol_id >= 0x100 && subvol_id < 0x8000000000000000)) {
                 LIST_ENTRY* le = Vcb->roots.Flink;
@@ -4427,7 +4389,7 @@ static NTSTATUS open_file(PDEVICE_OBJECT DeviceObject, _Requires_lock_held_(_Cur
             }
 
             if (!subvol) {
-                WARN("subvol %llx not found\n", subvol_id);
+                WARN("subvol %I64x not found\n", subvol_id);
                 Status = STATUS_OBJECT_NAME_NOT_FOUND;
             } else
                 Status = open_fileref_by_inode(Vcb, subvol, inode, &fileref, Irp);
@@ -4448,7 +4410,7 @@ static NTSTATUS open_file(PDEVICE_OBJECT DeviceObject, _Requires_lock_held_(_Cur
     if (!related && RequestedDisposition != FILE_OPEN && !(IrpSp->Flags & SL_OPEN_TARGET_DIRECTORY)) {
         ULONG fnoff;
 
-        Status = open_fileref(Vcb, &related, &fn, NULL, TRUE, &parsed, &fnoff,
+        Status = open_fileref(Vcb, &related, &fn, NULL, true, &parsed, &fnoff,
                               pool_type, IrpSp->Flags & SL_CASE_SENSITIVE, Irp);
 
         if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
@@ -4470,7 +4432,7 @@ static NTSTATUS open_file(PDEVICE_OBJECT DeviceObject, _Requires_lock_held_(_Cur
                 Status = open_fileref(Vcb, &fileref, &fn, related, IrpSp->Flags & SL_OPEN_TARGET_DIRECTORY, &parsed, &fn_offset,
                                       pool_type, IrpSp->Flags & SL_CASE_SENSITIVE, Irp);
 
-                loaded_related = TRUE;
+                loaded_related = true;
             }
         }
     } else {
@@ -4482,8 +4444,8 @@ loaded:
     if (Status == STATUS_REPARSE) {
         REPARSE_DATA_BUFFER* data;
 
-        ExAcquireResourceSharedLite(fileref->fcb->Header.Resource, TRUE);
-        Status = get_reparse_block(fileref->fcb, (UINT8**)&data);
+        ExAcquireResourceSharedLite(fileref->fcb->Header.Resource, true);
+        Status = get_reparse_block(fileref->fcb, (uint8_t**)&data);
         ExReleaseResourceLite(fileref->fcb->Header.Resource);
 
         if (!NT_SUCCESS(Status)) {
@@ -4536,9 +4498,6 @@ loaded:
     } else {
         file_ref* existing_file;
 
-#ifdef DEBUG_STATS
-        open_type = 2;
-#endif
         Status = file_create(Irp, Vcb, FileObject, related, loaded_related, &fn, RequestedDisposition, options, &existing_file, rollback);
 
         if (Status == STATUS_OBJECT_NAME_COLLISION) { // already exists
@@ -4577,36 +4536,21 @@ exit:
             fcb2 = ccb2->fileref->parent->fcb;
         }
 
-        ExAcquireResourceExclusiveLite(fcb2->Header.Resource, TRUE);
+        ExAcquireResourceExclusiveLite(fcb2->Header.Resource, true);
         fcb_load_csums(Vcb, fcb2, Irp);
         ExReleaseResourceLite(fcb2->Header.Resource);
     } else if (Status != STATUS_REPARSE && Status != STATUS_OBJECT_NAME_NOT_FOUND && Status != STATUS_OBJECT_PATH_NOT_FOUND)
         TRACE("returning %08x\n", Status);
 
-#ifdef DEBUG_STATS
-    time2 = KeQueryPerformanceCounter(NULL);
-
-    if (open_type == 0) {
-        Vcb->stats.open_total_time += time2.QuadPart - time1.QuadPart;
-        Vcb->stats.num_opens++;
-    } else if (open_type == 1) {
-        Vcb->stats.overwrite_total_time += time2.QuadPart - time1.QuadPart;
-        Vcb->stats.num_overwrites++;
-    } else if (open_type == 2) {
-        Vcb->stats.create_total_time += time2.QuadPart - time1.QuadPart;
-        Vcb->stats.num_creates++;
-    }
-#endif
-
     return Status;
 }
 
 static NTSTATUS verify_vcb(device_extension* Vcb, PIRP Irp) {
     NTSTATUS Status;
     LIST_ENTRY* le;
-    BOOL need_verify = FALSE;
+    bool need_verify = false;
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
     le = Vcb->devices.Flink;
     while (le != &Vcb->devices) {
@@ -4616,11 +4560,11 @@ static NTSTATUS verify_vcb(device_extension* Vcb, PIRP Irp) {
             ULONG cc;
             IO_STATUS_BLOCK iosb;
 
-            Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, &cc, sizeof(ULONG), TRUE, &iosb);
+            Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, &cc, sizeof(ULONG), true, &iosb);
 
             if (IoIsErrorUserInduced(Status)) {
                 ERR("IOCTL_STORAGE_CHECK_VERIFY returned %08x (user-induced)\n", Status);
-                need_verify = TRUE;
+                need_verify = true;
             } else if (!NT_SUCCESS(Status)) {
                 ERR("IOCTL_STORAGE_CHECK_VERIFY returned %08x\n", Status);
                 goto end;
@@ -4629,7 +4573,7 @@ static NTSTATUS verify_vcb(device_extension* Vcb, PIRP Irp) {
                 Status = STATUS_INTERNAL_ERROR;
             } else if (cc != dev->change_count) {
                 dev->devobj->Flags |= DO_VERIFY_VOLUME;
-                need_verify = TRUE;
+                need_verify = true;
             }
         }
 
@@ -4655,7 +4599,7 @@ end:
         devobj = Vcb->Vpb ? Vcb->Vpb->RealDevice : NULL;
 
         if (devobj)
-            Status = IoVerifyVolume(devobj, FALSE);
+            Status = IoVerifyVolume(devobj, false);
         else
             Status = STATUS_VERIFY_REQUIRED;
     }
@@ -4663,7 +4607,7 @@ end:
     return Status;
 }
 
-static BOOL has_manage_volume_privilege(ACCESS_STATE* access_state, KPROCESSOR_MODE processor_mode) {
+static bool has_manage_volume_privilege(ACCESS_STATE* access_state, KPROCESSOR_MODE processor_mode) {
     PRIVILEGE_SET privset;
 
     privset.PrivilegeCount = 1;
@@ -4671,16 +4615,16 @@ static BOOL has_manage_volume_privilege(ACCESS_STATE* access_state, KPROCESSOR_M
     privset.Privilege[0].Luid = RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE);
     privset.Privilege[0].Attributes = 0;
 
-    return SePrivilegeCheck(&privset, &access_state->SubjectSecurityContext, processor_mode) ? TRUE : FALSE;
+    return SePrivilegeCheck(&privset, &access_state->SubjectSecurityContext, processor_mode) ? true : false;
 }
 
 _Dispatch_type_(IRP_MJ_CREATE)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
+NTSTATUS __stdcall drv_create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp;
     device_extension* Vcb = DeviceObject->DeviceExtension;
-    BOOL top_level, locked = FALSE;
+    bool top_level, locked = false;
 
     FsRtlEnterFileSystem();
 
@@ -4720,13 +4664,13 @@ NTSTATUS NTAPI drv_create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
         goto exit;
     }
 
-    ExAcquireResourceSharedLite(&Vcb->load_lock, TRUE);
-    locked = TRUE;
+    ExAcquireResourceSharedLite(&Vcb->load_lock, true);
+    locked = true;
 
     IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
     if (IrpSp->Flags != 0) {
-        UINT32 flags = IrpSp->Flags;
+        uint32_t flags = IrpSp->Flags;
 
         TRACE("flags:\n");
 
@@ -4814,7 +4758,7 @@ NTSTATUS NTAPI drv_create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
         ccb->access = IrpSp->Parameters.Create.SecurityContext->AccessState->PreviouslyGrantedAccess;
         ccb->manage_volume_privilege = has_manage_volume_privilege(IrpSp->Parameters.Create.SecurityContext->AccessState,
                                                                    IrpSp->Flags & SL_FORCE_ACCESS_CHECK ? UserMode : Irp->RequestorMode);
-        ccb->reserving = FALSE;
+        ccb->reserving = false;
         ccb->lxss = called_from_lxss();
 
 #ifdef DEBUG_FCB_REFCOUNTS
@@ -4837,7 +4781,7 @@ NTSTATUS NTAPI drv_create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
         Status = STATUS_SUCCESS;
     } else {
         LIST_ENTRY rollback;
-        BOOL skip_lock;
+        bool skip_lock;
 
         InitializeListHead(&rollback);
 
@@ -4850,9 +4794,9 @@ NTSTATUS NTAPI drv_create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
         skip_lock = ExIsResourceAcquiredExclusiveLite(&Vcb->tree_lock);
 
         if (!skip_lock)
-            ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-        ExAcquireResourceSharedLite(&Vcb->fileref_lock, TRUE);
+        ExAcquireResourceSharedLite(&Vcb->fileref_lock, true);
 
         Status = open_file(DeviceObject, Vcb, Irp, &rollback);
 
diff --git a/drivers/filesystems/btrfs/devctrl.c b/drivers/filesystems/btrfs/devctrl.c
index 1953360a06c..99c2e542d5e 100644
--- a/drivers/filesystems/btrfs/devctrl.c
+++ b/drivers/filesystems/btrfs/devctrl.c
@@ -52,7 +52,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
     btrfs_filesystem* bfs = NULL;
     ULONG itemsize;
 
-    ExAcquireResourceSharedLite(&global_loading_lock, TRUE);
+    ExAcquireResourceSharedLite(&global_loading_lock, true);
 
     if (IsListEmpty(&VcbList)) {
         if (length < sizeof(btrfs_filesystem)) {
@@ -73,7 +73,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
 
         if (bfs) {
             bfs->next_entry = itemsize;
-            bfs = (btrfs_filesystem*)((UINT8*)bfs + itemsize);
+            bfs = (btrfs_filesystem*)((uint8_t*)bfs + itemsize);
         } else
             bfs = data;
 
@@ -88,9 +88,9 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
         bfs->next_entry = 0;
         RtlCopyMemory(&bfs->uuid, &Vcb->superblock.uuid, sizeof(BTRFS_UUID));
 
-        ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+        ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-        bfs->num_devices = (UINT32)Vcb->superblock.num_devices;
+        bfs->num_devices = (uint32_t)Vcb->superblock.num_devices;
 
         bfd = NULL;
 
@@ -100,7 +100,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
             MOUNTDEV_NAME mdn;
 
             if (bfd)
-                bfd = (btrfs_filesystem_device*)((UINT8*)bfd + offsetof(btrfs_filesystem_device, name[0]) + bfd->name_length);
+                bfd = (btrfs_filesystem_device*)((uint8_t*)bfd + offsetof(btrfs_filesystem_device, name[0]) + bfd->name_length);
             else
                 bfd = &bfs->device;
 
@@ -116,7 +116,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
             RtlCopyMemory(&bfd->uuid, &dev->devitem.device_uuid, sizeof(BTRFS_UUID));
 
             if (dev->devobj) {
-                Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), TRUE, NULL);
+                Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), true, NULL);
                 if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
                     ExReleaseResourceLite(&Vcb->tree_lock);
                     ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
@@ -129,7 +129,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
                     goto end;
                 }
 
-                Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &bfd->name_length, (ULONG)offsetof(MOUNTDEV_NAME, Name[0]) + mdn.NameLength, TRUE, NULL);
+                Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &bfd->name_length, (ULONG)offsetof(MOUNTDEV_NAME, Name[0]) + mdn.NameLength, true, NULL);
                 if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
                     ExReleaseResourceLite(&Vcb->tree_lock);
                     ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
@@ -139,7 +139,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
                 itemsize += bfd->name_length;
                 length -= bfd->name_length;
             } else {
-                bfd->missing = TRUE;
+                bfd->missing = true;
                 bfd->name_length = 0;
             }
 
@@ -195,7 +195,7 @@ static NTSTATUS probe_volume(void* data, ULONG length, KPROCESSOR_MODE processor
     }
 
     if (RtlCompareMemory(guid, &GUID_DEVINTERFACE_DISK, sizeof(GUID)) == sizeof(GUID)) {
-        Status = dev_ioctl(DeviceObject, IOCTL_DISK_UPDATE_PROPERTIES, NULL, 0, NULL, 0, TRUE, NULL);
+        Status = dev_ioctl(DeviceObject, IOCTL_DISK_UPDATE_PROPERTIES, NULL, 0, NULL, 0, true, NULL);
         if (!NT_SUCCESS(Status))
             WARN("IOCTL_DISK_UPDATE_PROPERTIES returned %08x\n", Status);
     }
@@ -236,11 +236,11 @@ static NTSTATUS control_ioctl(PIRP Irp) {
 
 _Dispatch_type_(IRP_MJ_DEVICE_CONTROL)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_device_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
+NTSTATUS __stdcall drv_device_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     device_extension* Vcb = DeviceObject->DeviceExtension;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
diff --git a/drivers/filesystems/btrfs/dirctrl.c b/drivers/filesystems/btrfs/dirctrl.c
index d088de35f72..2e324e4f6d2 100644
--- a/drivers/filesystems/btrfs/dirctrl.c
+++ b/drivers/filesystems/btrfs/dirctrl.c
@@ -18,7 +18,7 @@
 #include "btrfs_drv.h"
 
 // not currently in mingw
-//#ifndef _MSC_VER
+#ifndef _MSC_VER
 #define FileIdExtdDirectoryInformation (enum _FILE_INFORMATION_CLASS)60
 #define FileIdExtdBothDirectoryInformation (enum _FILE_INFORMATION_CLASS)63
 
@@ -58,7 +58,7 @@ typedef struct _FILE_ID_EXTD_BOTH_DIR_INFORMATION {
     WCHAR FileName[1];
 } FILE_ID_EXTD_BOTH_DIR_INFORMATION, *PFILE_ID_EXTD_BOTH_DIR_INFORMATION;
 
-//#endif
+#endif
 
 enum DirEntryType {
     DirEntryType_File,
@@ -69,7 +69,7 @@ enum DirEntryType {
 typedef struct {
     KEY key;
     UNICODE_STRING name;
-    UINT8 type;
+    uint8_t type;
     enum DirEntryType dir_entry_type;
     dir_child* dc;
 } dir_entry;
@@ -88,7 +88,7 @@ ULONG get_reparse_tag_fcb(fcb* fcb) {
         NTSTATUS Status;
         ULONG br;
 
-        Status = read_file(fcb, (UINT8*)&tag, 0, sizeof(ULONG), &br, NULL);
+        Status = read_file(fcb, (uint8_t*)&tag, 0, sizeof(ULONG), &br, NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("read_file returned %08x\n", Status);
             return 0;
@@ -98,7 +98,7 @@ ULONG get_reparse_tag_fcb(fcb* fcb) {
     return tag;
 }
 
-ULONG get_reparse_tag(device_extension* Vcb, root* subvol, UINT64 inode, UINT8 type, ULONG atts, BOOL lxss, PIRP Irp) {
+ULONG get_reparse_tag(device_extension* Vcb, root* subvol, uint64_t inode, uint8_t type, ULONG atts, bool lxss, PIRP Irp) {
     fcb* fcb;
     ULONG tag = 0;
     NTSTATUS Status;
@@ -122,13 +122,13 @@ ULONG get_reparse_tag(device_extension* Vcb, root* subvol, UINT64 inode, UINT8 t
     if (!(atts & FILE_ATTRIBUTE_REPARSE_POINT))
         return 0;
 
-    Status = open_fcb(Vcb, subvol, inode, type, NULL, FALSE, NULL, &fcb, PagedPool, Irp);
+    Status = open_fcb(Vcb, subvol, inode, type, NULL, false, NULL, &fcb, PagedPool, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("open_fcb returned %08x\n", Status);
         return 0;
     }
 
-    ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
     tag = get_reparse_tag_fcb(fcb);
 
@@ -139,9 +139,9 @@ ULONG get_reparse_tag(device_extension* Vcb, root* subvol, UINT64 inode, UINT8 t
     return tag;
 }
 
-static ULONG get_ea_len(device_extension* Vcb, root* subvol, UINT64 inode, PIRP Irp) {
-    UINT8* eadata;
-    UINT16 len;
+static ULONG get_ea_len(device_extension* Vcb, root* subvol, uint64_t inode, PIRP Irp) {
+    uint8_t* eadata;
+    uint16_t len;
 
     if (get_xattr(Vcb, subvol, inode, EA_EA, EA_EA_HASH, &eadata, &len, Irp)) {
         ULONG offset;
@@ -165,8 +165,8 @@ static ULONG get_ea_len(device_extension* Vcb, root* subvol, UINT64 inode, PIRP
                 if (eainfo->NextEntryOffset == 0)
                     break;
 
-                eainfo = (FILE_FULL_EA_INFORMATION*)(((UINT8*)eainfo) + eainfo->NextEntryOffset);
-            } while (TRUE);
+                eainfo = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)eainfo) + eainfo->NextEntryOffset);
+            } while (true);
 
             ExFreePool(eadata);
 
@@ -179,7 +179,7 @@ static ULONG get_ea_len(device_extension* Vcb, root* subvol, UINT64 inode, PIRP
 static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Irp, dir_entry* de, root* r) {
     PIO_STACK_LOCATION IrpSp;
     LONG needed;
-    UINT64 inode;
+    uint64_t inode;
     INODE_ITEM ii;
     NTSTATUS Status;
     ULONG atts = 0, ealen = 0;
@@ -227,13 +227,13 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
                     win_time_to_unix(time, &ii.otime);
                     ii.st_atime = ii.st_mtime = ii.st_ctime = ii.otime;
                 } else {
-                    BOOL found = FALSE;
+                    bool found = false;
 
                     if (de->dc && de->dc->fileref && de->dc->fileref->fcb) {
                         ii = de->dc->fileref->fcb->inode_item;
                         atts = de->dc->fileref->fcb->atts;
                         ealen = de->dc->fileref->fcb->ealen;
-                        found = TRUE;
+                        found = true;
                     }
 
                     if (!found) {
@@ -244,14 +244,14 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
                         searchkey.obj_type = TYPE_INODE_ITEM;
                         searchkey.offset = 0xffffffffffffffff;
 
-                        Status = find_item(fcb->Vcb, r, &tp, &searchkey, FALSE, Irp);
+                        Status = find_item(fcb->Vcb, r, &tp, &searchkey, false, Irp);
                         if (!NT_SUCCESS(Status)) {
                             ERR("error - find_item returned %08x\n", Status);
                             return Status;
                         }
 
                         if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-                            ERR("could not find inode item for inode %llx in root %llx\n", inode, r->id);
+                            ERR("could not find inode item for inode %I64x in root %I64x\n", inode, r->id);
                             return STATUS_INTERNAL_ERROR;
                         }
 
@@ -268,9 +268,9 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
                             IrpSp->Parameters.QueryDirectory.FileInformationClass == FileIdExtdDirectoryInformation ||
                             IrpSp->Parameters.QueryDirectory.FileInformationClass == FileIdExtdBothDirectoryInformation) {
 
-                            BOOL dotfile = de->name.Length > sizeof(WCHAR) && de->name.Buffer[0] == '.';
+                            bool dotfile = de->name.Length > sizeof(WCHAR) && de->name.Buffer[0] == '.';
 
-                            atts = get_file_attributes(fcb->Vcb, r, inode, de->type, dotfile, FALSE, Irp);
+                            atts = get_file_attributes(fcb->Vcb, r, inode, de->type, dotfile, false, Irp);
                         }
 
                         if (IrpSp->Parameters.QueryDirectory.FileInformationClass == FileBothDirectoryInformation ||
@@ -549,8 +549,8 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
             fiedi->EaSize = ealen;
             fiedi->ReparsePointTag = get_reparse_tag(fcb->Vcb, r, inode, de->type, atts, ccb->lxss, Irp);
 
-            RtlCopyMemory(&fiedi->FileId.Identifier[0], &fcb->inode, sizeof(UINT64));
-            RtlCopyMemory(&fiedi->FileId.Identifier[sizeof(UINT64)], &fcb->subvol->id, sizeof(UINT64));
+            RtlCopyMemory(&fiedi->FileId.Identifier[0], &fcb->inode, sizeof(uint64_t));
+            RtlCopyMemory(&fiedi->FileId.Identifier[sizeof(uint64_t)], &fcb->subvol->id, sizeof(uint64_t));
 
             RtlCopyMemory(fiedi->FileName, de->name.Buffer, de->name.Length);
 
@@ -592,8 +592,8 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
             fiebdi->EaSize = ealen;
             fiebdi->ReparsePointTag = get_reparse_tag(fcb->Vcb, r, inode, de->type, atts, ccb->lxss, Irp);
 
-            RtlCopyMemory(&fiebdi->FileId.Identifier[0], &fcb->inode, sizeof(UINT64));
-            RtlCopyMemory(&fiebdi->FileId.Identifier[sizeof(UINT64)], &fcb->subvol->id, sizeof(UINT64));
+            RtlCopyMemory(&fiebdi->FileId.Identifier[0], &fcb->inode, sizeof(uint64_t));
+            RtlCopyMemory(&fiebdi->FileId.Identifier[sizeof(uint64_t)], &fcb->subvol->id, sizeof(uint64_t));
 
             fiebdi->ShortNameLength = 0;
 
@@ -652,7 +652,7 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
     return STATUS_NO_MORE_FILES;
 }
 
-static NTSTATUS next_dir_entry(file_ref* fileref, UINT64* offset, dir_entry* de, dir_child** pdc) {
+static NTSTATUS next_dir_entry(file_ref* fileref, uint64_t* offset, dir_entry* de, dir_child** pdc) {
     LIST_ENTRY* le;
     dir_child* dc;
 
@@ -739,12 +739,12 @@ static NTSTATUS query_directory(PIRP Irp) {
     file_ref* fileref;
     device_extension* Vcb;
     void* buf;
-    UINT8 *curitem, *lastitem;
+    uint8_t *curitem, *lastitem;
     LONG length;
     ULONG count;
-    BOOL has_wildcard = FALSE, specific_file = FALSE, initial;
+    bool has_wildcard = false, specific_file = false, initial;
     dir_entry de;
-    UINT64 newoffset;
+    uint64_t newoffset;
     dir_child* dc = NULL;
 
     TRACE("query directory\n");
@@ -816,8 +816,8 @@ static NTSTATUS query_directory(PIRP Irp) {
             ccb->query_string.Buffer = NULL;
         }
 
-        ccb->has_wildcard = FALSE;
-        ccb->specific_file = FALSE;
+        ccb->has_wildcard = false;
+        ccb->specific_file = false;
     }
 
     initial = !ccb->query_string.Buffer;
@@ -826,11 +826,11 @@ static NTSTATUS query_directory(PIRP Irp) {
         TRACE("QD filename: %.*S\n", IrpSp->Parameters.QueryDirectory.FileName->Length / sizeof(WCHAR), IrpSp->Parameters.QueryDirectory.FileName->Buffer);
 
         if (IrpSp->Parameters.QueryDirectory.FileName->Length > sizeof(WCHAR) || IrpSp->Parameters.QueryDirectory.FileName->Buffer[0] != L'*') {
-            specific_file = TRUE;
+            specific_file = true;
 
             if (FsRtlDoesNameContainWildCards(IrpSp->Parameters.QueryDirectory.FileName)) {
-                has_wildcard = TRUE;
-                specific_file = FALSE;
+                has_wildcard = true;
+                specific_file = false;
             }
         }
 
@@ -838,7 +838,7 @@ static NTSTATUS query_directory(PIRP Irp) {
             RtlFreeUnicodeString(&ccb->query_string);
 
         if (has_wildcard)
-            RtlUpcaseUnicodeString(&ccb->query_string, IrpSp->Parameters.QueryDirectory.FileName, TRUE);
+            RtlUpcaseUnicodeString(&ccb->query_string, IrpSp->Parameters.QueryDirectory.FileName, true);
         else {
             ccb->query_string.Buffer = ExAllocatePoolWithTag(PagedPool, IrpSp->Parameters.QueryDirectory.FileName->Length, ALLOC_TAG);
             if (!ccb->query_string.Buffer) {
@@ -857,7 +857,7 @@ static NTSTATUS query_directory(PIRP Irp) {
         specific_file = ccb->specific_file;
 
         if (!(IrpSp->Flags & SL_RESTART_SCAN)) {
-            initial = FALSE;
+            initial = false;
 
             if (specific_file)
                 return STATUS_NO_MORE_FILES;
@@ -870,9 +870,9 @@ static NTSTATUS query_directory(PIRP Irp) {
 
     newoffset = ccb->query_dir_offset;
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-    ExAcquireResourceSharedLite(&fileref->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceSharedLite(&fileref->fcb->nonpaged->dir_children_lock, true);
 
     Status = next_dir_entry(fileref, &newoffset, &de, &dc);
 
@@ -895,24 +895,24 @@ static NTSTATUS query_directory(PIRP Irp) {
     length = IrpSp->Parameters.QueryDirectory.Length;
 
     if (specific_file) {
-        BOOL found = FALSE;
+        bool found = false;
         UNICODE_STRING us;
         LIST_ENTRY* le;
-        UINT32 hash;
-        UINT8 c;
+        uint32_t hash;
+        uint8_t c;
 
         us.Buffer = NULL;
 
         if (!ccb->case_sensitive) {
-            Status = RtlUpcaseUnicodeString(&us, &ccb->query_string, TRUE);
+            Status = RtlUpcaseUnicodeString(&us, &ccb->query_string, true);
             if (!NT_SUCCESS(Status)) {
                 ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
                 goto end;
             }
 
-            hash = calc_crc32c(0xffffffff, (UINT8*)us.Buffer, us.Length);
+            hash = calc_crc32c(0xffffffff, (uint8_t*)us.Buffer, us.Length);
         } else
-            hash = calc_crc32c(0xffffffff, (UINT8*)ccb->query_string.Buffer, ccb->query_string.Length);
+            hash = calc_crc32c(0xffffffff, (uint8_t*)ccb->query_string.Buffer, ccb->query_string.Length);
 
         c = hash >> 24;
 
@@ -924,7 +924,7 @@ static NTSTATUS query_directory(PIRP Irp) {
 
                     if (dc2->hash == hash) {
                         if (dc2->name.Length == ccb->query_string.Length && RtlCompareMemory(dc2->name.Buffer, ccb->query_string.Buffer, ccb->query_string.Length) == ccb->query_string.Length) {
-                            found = TRUE;
+                            found = true;
 
                             de.key = dc2->key;
                             de.name = dc2->name;
@@ -948,7 +948,7 @@ static NTSTATUS query_directory(PIRP Irp) {
 
                     if (dc2->hash_uc == hash) {
                         if (dc2->name_uc.Length == us.Length && RtlCompareMemory(dc2->name_uc.Buffer, us.Buffer, us.Length) == us.Length) {
-                            found = TRUE;
+                            found = true;
 
                             de.key = dc2->key;
                             de.name = dc2->name;
@@ -996,7 +996,7 @@ static NTSTATUS query_directory(PIRP Irp) {
 
     count = 0;
     if (NT_SUCCESS(Status) && !(IrpSp->Flags & SL_RETURN_SINGLE_ENTRY) && !specific_file) {
-        lastitem = (UINT8*)buf;
+        lastitem = (uint8_t*)buf;
 
         while (length > 0) {
             switch (IrpSp->Parameters.QueryDirectory.FileInformationClass) {
@@ -1031,10 +1031,10 @@ static NTSTATUS query_directory(PIRP Irp) {
                 Status = next_dir_entry(fileref, &newoffset, &de, &dc);
                 if (NT_SUCCESS(Status)) {
                     if (!has_wildcard || FsRtlIsNameInExpression(&ccb->query_string, &de.name, !ccb->case_sensitive, NULL)) {
-                        curitem = (UINT8*)buf + IrpSp->Parameters.QueryDirectory.Length - length;
+                        curitem = (uint8_t*)buf + IrpSp->Parameters.QueryDirectory.Length - length;
                         count++;
 
-                        TRACE("file(%u) %u = %.*S\n", count, curitem - (UINT8*)buf, de.name.Length / sizeof(WCHAR), de.name.Buffer);
+                        TRACE("file(%u) %u = %.*S\n", count, curitem - (uint8_t*)buf, de.name.Length / sizeof(WCHAR), de.name.Buffer);
                         TRACE("offset = %u\n", ccb->query_dir_offset - 1);
 
                         status2 = query_dir_item(fcb, ccb, curitem, &length, Irp, &de, fcb->subvol);
@@ -1098,8 +1098,8 @@ static NTSTATUS notify_change_directory(device_extension* Vcb, PIRP Irp) {
         return STATUS_ACCESS_DENIED;
     }
 
-    ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (fcb->type != BTRFS_TYPE_DIRECTORY) {
         Status = STATUS_INVALID_PARAMETER;
@@ -1124,7 +1124,7 @@ static NTSTATUS notify_change_directory(device_extension* Vcb, PIRP Irp) {
                 goto end;
             }
 
-            ccb->filename.MaximumLength = (UINT16)reqlen;
+            ccb->filename.MaximumLength = (uint16_t)reqlen;
 
             Status = fileref_get_filename(fileref, &ccb->filename, NULL, &reqlen);
             if (!NT_SUCCESS(Status)) {
@@ -1138,7 +1138,7 @@ static NTSTATUS notify_change_directory(device_extension* Vcb, PIRP Irp) {
     }
 
     FsRtlNotifyFilterChangeDirectory(Vcb->NotifySync, &Vcb->DirNotifyList, FileObject->FsContext2, (PSTRING)&ccb->filename,
-                                     IrpSp->Flags & SL_WATCH_TREE, FALSE, IrpSp->Parameters.NotifyDirectory.CompletionFilter, Irp,
+                                     IrpSp->Flags & SL_WATCH_TREE, false, IrpSp->Parameters.NotifyDirectory.CompletionFilter, Irp,
                                      NULL, NULL, NULL);
 
     Status = STATUS_PENDING;
@@ -1152,11 +1152,11 @@ end:
 
 _Dispatch_type_(IRP_MJ_DIRECTORY_CONTROL)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_directory_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
+NTSTATUS __stdcall drv_directory_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     PIO_STACK_LOCATION IrpSp;
     NTSTATUS Status;
     ULONG func;
-    BOOL top_level;
+    bool top_level;
     device_extension* Vcb = DeviceObject->DeviceExtension;
 
     FsRtlEnterFileSystem();
diff --git a/drivers/filesystems/btrfs/extent-tree.c b/drivers/filesystems/btrfs/extent-tree.c
index 8cd7000cece..0c804caef67 100644
--- a/drivers/filesystems/btrfs/extent-tree.c
+++ b/drivers/filesystems/btrfs/extent-tree.c
@@ -18,7 +18,7 @@
 #include "btrfs_drv.h"
 
 typedef struct {
-    UINT8 type;
+    uint8_t type;
 
     union {
         EXTENT_DATA_REF edr;
@@ -27,25 +27,25 @@ typedef struct {
         SHARED_BLOCK_REF sbr;
     };
 
-    UINT64 hash;
+    uint64_t hash;
     LIST_ENTRY list_entry;
 } extent_ref;
 
-UINT64 get_extent_data_ref_hash2(UINT64 root, UINT64 objid, UINT64 offset) {
-    UINT32 high_crc = 0xffffffff, low_crc = 0xffffffff;
+uint64_t get_extent_data_ref_hash2(uint64_t root, uint64_t objid, uint64_t offset) {
+    uint32_t high_crc = 0xffffffff, low_crc = 0xffffffff;
 
-    high_crc = calc_crc32c(high_crc, (UINT8*)&root, sizeof(UINT64));
-    low_crc = calc_crc32c(low_crc, (UINT8*)&objid, sizeof(UINT64));
-    low_crc = calc_crc32c(low_crc, (UINT8*)&offset, sizeof(UINT64));
+    high_crc = calc_crc32c(high_crc, (uint8_t*)&root, sizeof(uint64_t));
+    low_crc = calc_crc32c(low_crc, (uint8_t*)&objid, sizeof(uint64_t));
+    low_crc = calc_crc32c(low_crc, (uint8_t*)&offset, sizeof(uint64_t));
 
-    return ((UINT64)high_crc << 31) ^ (UINT64)low_crc;
+    return ((uint64_t)high_crc << 31) ^ (uint64_t)low_crc;
 }
 
-static __inline UINT64 get_extent_data_ref_hash(EXTENT_DATA_REF* edr) {
+static __inline uint64_t get_extent_data_ref_hash(EXTENT_DATA_REF* edr) {
     return get_extent_data_ref_hash2(edr->root, edr->objid, edr->offset);
 }
 
-static UINT64 get_extent_hash(UINT8 type, void* data) {
+static uint64_t get_extent_hash(uint8_t type, void* data) {
     if (type == TYPE_EXTENT_DATA_REF) {
         return get_extent_data_ref_hash((EXTENT_DATA_REF*)data);
     } else if (type == TYPE_SHARED_BLOCK_REF) {
@@ -72,7 +72,7 @@ static void free_extent_refs(LIST_ENTRY* extent_refs) {
     }
 }
 
-static NTSTATUS add_shared_data_extent_ref(LIST_ENTRY* extent_refs, UINT64 parent, UINT32 count) {
+static NTSTATUS add_shared_data_extent_ref(LIST_ENTRY* extent_refs, uint64_t parent, uint32_t count) {
     extent_ref* er2;
     LIST_ENTRY* le;
 
@@ -106,7 +106,7 @@ static NTSTATUS add_shared_data_extent_ref(LIST_ENTRY* extent_refs, UINT64 paren
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS add_shared_block_extent_ref(LIST_ENTRY* extent_refs, UINT64 parent) {
+static NTSTATUS add_shared_block_extent_ref(LIST_ENTRY* extent_refs, uint64_t parent) {
     extent_ref* er2;
     LIST_ENTRY* le;
 
@@ -137,7 +137,7 @@ static NTSTATUS add_shared_block_extent_ref(LIST_ENTRY* extent_refs, UINT64 pare
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS add_tree_block_extent_ref(LIST_ENTRY* extent_refs, UINT64 root) {
+static NTSTATUS add_tree_block_extent_ref(LIST_ENTRY* extent_refs, uint64_t root) {
     extent_ref* er2;
     LIST_ENTRY* le;
 
@@ -181,7 +181,7 @@ static void sort_extent_refs(LIST_ENTRY* extent_refs) {
     while (!IsListEmpty(extent_refs)) {
         extent_ref* er = CONTAINING_RECORD(RemoveHeadList(extent_refs), extent_ref, list_entry);
         LIST_ENTRY* le;
-        BOOL inserted = FALSE;
+        bool inserted = false;
 
         le = newlist.Flink;
         while (le != &newlist) {
@@ -189,7 +189,7 @@ static void sort_extent_refs(LIST_ENTRY* extent_refs) {
 
             if (er->type < er2->type || (er->type == er2->type && er->hash > er2->hash)) {
                 InsertHeadList(le->Blink, &er->list_entry);
-                inserted = TRUE;
+                inserted = true;
                 break;
             }
 
@@ -206,16 +206,16 @@ static void sort_extent_refs(LIST_ENTRY* extent_refs) {
     extent_refs->Blink = newlist.Blink;
 }
 
-static NTSTATUS construct_extent_item(device_extension* Vcb, UINT64 address, UINT64 size, UINT64 flags, LIST_ENTRY* extent_refs,
-                                      KEY* firstitem, UINT8 level, PIRP Irp) {
+static NTSTATUS construct_extent_item(device_extension* Vcb, uint64_t address, uint64_t size, uint64_t flags, LIST_ENTRY* extent_refs,
+                                      KEY* firstitem, uint8_t level, PIRP Irp) {
     NTSTATUS Status;
     LIST_ENTRY *le, *next_le;
-    UINT64 refcount;
-    UINT16 inline_len;
-    BOOL all_inline = TRUE;
+    uint64_t refcount;
+    uint16_t inline_len;
+    bool all_inline = true;
     extent_ref* first_noninline = NULL;
     EXTENT_ITEM* ei;
-    UINT8* siptr;
+    uint8_t* siptr;
 
     // FIXME - write skinny extents if is tree and incompat flag set
 
@@ -233,7 +233,7 @@ static NTSTATUS construct_extent_item(device_extension* Vcb, UINT64 address, UIN
     le = extent_refs->Flink;
     while (le != extent_refs) {
         extent_ref* er = CONTAINING_RECORD(le, extent_ref, list_entry);
-        UINT64 rc;
+        uint64_t rc;
 
         next_le = le->Flink;
 
@@ -244,15 +244,15 @@ static NTSTATUS construct_extent_item(device_extension* Vcb, UINT64 address, UIN
 
             ExFreePool(er);
         } else {
-            UINT16 extlen = get_extent_data_len(er->type);
+            uint16_t extlen = get_extent_data_len(er->type);
 
             refcount += rc;
 
             er->hash = get_extent_hash(er->type, &er->edr);
 
             if (all_inline) {
-                if ((UINT16)(inline_len + 1 + extlen) > Vcb->superblock.node_size >> 2) {
-                    all_inline = FALSE;
+                if ((uint16_t)(inline_len + 1 + extlen) > Vcb->superblock.node_size >> 2) {
+                    all_inline = false;
                     first_noninline = er;
                 } else
                     inline_len += extlen + 1;
@@ -287,9 +287,9 @@ static NTSTATUS construct_extent_item(device_extension* Vcb, UINT64 address, UIN
 
         ei2->level = level;
 
-        siptr = (UINT8*)&ei2[1];
+        siptr = (uint8_t*)&ei2[1];
     } else
-        siptr = (UINT8*)&ei[1];
+        siptr = (uint8_t*)&ei[1];
 
     sort_extent_refs(extent_refs);
 
@@ -324,8 +324,8 @@ static NTSTATUS construct_extent_item(device_extension* Vcb, UINT64 address, UIN
 
         while (le != extent_refs) {
             extent_ref* er = CONTAINING_RECORD(le, extent_ref, list_entry);
-            UINT16 len;
-            UINT8* data;
+            uint16_t len;
+            uint8_t* data;
 
             if (er->type == TYPE_EXTENT_DATA_REF) {
                 len = sizeof(EXTENT_DATA_REF);
@@ -339,7 +339,7 @@ static NTSTATUS construct_extent_item(device_extension* Vcb, UINT64 address, UIN
 
                 RtlCopyMemory(data, &er->edr, len);
             } else if (er->type == TYPE_SHARED_DATA_REF) {
-                len = sizeof(UINT32);
+                len = sizeof(uint32_t);
 
                 data = ExAllocatePoolWithTag(PagedPool, len, ALLOC_TAG);
 
@@ -348,7 +348,7 @@ static NTSTATUS construct_extent_item(device_extension* Vcb, UINT64 address, UIN
                     return STATUS_INSUFFICIENT_RESOURCES;
                 }
 
-                *((UINT32*)data) = er->sdr.count;
+                *((uint32_t*)data) = er->sdr.count;
             } else {
                 len = 0;
                 data = NULL;
@@ -368,12 +368,12 @@ static NTSTATUS construct_extent_item(device_extension* Vcb, UINT64 address, UIN
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS convert_old_extent(device_extension* Vcb, UINT64 address, BOOL tree, KEY* firstitem, UINT8 level, PIRP Irp) {
+static NTSTATUS convert_old_extent(device_extension* Vcb, uint64_t address, bool tree, KEY* firstitem, uint8_t level, PIRP Irp) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp, next_tp;
     LIST_ENTRY extent_refs;
-    UINT64 size;
+    uint64_t size;
 
     InitializeListHead(&extent_refs);
 
@@ -381,14 +381,14 @@ static NTSTATUS convert_old_extent(device_extension* Vcb, UINT64 address, BOOL t
     searchkey.obj_type = TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
     }
 
     if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-        ERR("old-style extent %llx not found\n", address);
+        ERR("old-style extent %I64x not found\n", address);
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -400,7 +400,7 @@ static NTSTATUS convert_old_extent(device_extension* Vcb, UINT64 address, BOOL t
         return Status;
     }
 
-    while (find_next_item(Vcb, &tp, &next_tp, FALSE, Irp)) {
+    while (find_next_item(Vcb, &tp, &next_tp, false, Irp)) {
         tp = next_tp;
 
         if (tp.item->key.obj_id == address && tp.item->key.obj_type == TYPE_EXTENT_REF_V0 && tp.item->size >= sizeof(EXTENT_REF_V0)) {
@@ -450,19 +450,19 @@ end:
     return Status;
 }
 
-NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64 size, UINT8 type, void* data, KEY* firstitem, UINT8 level, PIRP Irp) {
+NTSTATUS increase_extent_refcount(device_extension* Vcb, uint64_t address, uint64_t size, uint8_t type, void* data, KEY* firstitem, uint8_t level, PIRP Irp) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
     ULONG len, max_extent_item_size;
-    UINT16 datalen = get_extent_data_len(type);
+    uint16_t datalen = get_extent_data_len(type);
     EXTENT_ITEM* ei;
-    UINT8* ptr;
-    UINT64 inline_rc, offset;
-    UINT8* data2;
+    uint8_t* ptr;
+    uint64_t inline_rc, offset;
+    uint8_t* data2;
     EXTENT_ITEM* newei;
-    BOOL skinny;
-    BOOL is_tree = type == TYPE_TREE_BLOCK_REF || type == TYPE_SHARED_BLOCK_REF;
+    bool skinny;
+    bool is_tree = type == TYPE_TREE_BLOCK_REF || type == TYPE_SHARED_BLOCK_REF;
 
     if (datalen == 0) {
         ERR("unrecognized extent type %x\n", type);
@@ -473,7 +473,7 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     searchkey.obj_type = Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA ? TYPE_METADATA_ITEM : TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
@@ -482,11 +482,11 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     // If entry doesn't exist yet, create new inline extent item
 
     if (tp.item->key.obj_id != searchkey.obj_id || (tp.item->key.obj_type != TYPE_EXTENT_ITEM && tp.item->key.obj_type != TYPE_METADATA_ITEM)) {
-        UINT16 eisize;
+        uint16_t eisize;
 
         eisize = sizeof(EXTENT_ITEM);
         if (is_tree && !(Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA)) eisize += sizeof(EXTENT_ITEM2);
-        eisize += sizeof(UINT8);
+        eisize += sizeof(uint8_t);
         eisize += datalen;
 
         ei = ExAllocatePoolWithTag(PagedPool, eisize, ALLOC_TAG);
@@ -498,13 +498,13 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
         ei->refcount = get_extent_data_refcount(type, data);
         ei->generation = Vcb->superblock.generation;
         ei->flags = is_tree ? EXTENT_ITEM_TREE_BLOCK : EXTENT_ITEM_DATA;
-        ptr = (UINT8*)&ei[1];
+        ptr = (uint8_t*)&ei[1];
 
         if (is_tree && !(Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA)) {
             EXTENT_ITEM2* ei2 = (EXTENT_ITEM2*)ptr;
             ei2->firstitem = *firstitem;
             ei2->level = level;
-            ptr = (UINT8*)&ei2[1];
+            ptr = (uint8_t*)&ei2[1];
         }
 
         *ptr = type;
@@ -522,7 +522,7 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
 
         return STATUS_SUCCESS;
     } else if (tp.item->key.obj_id == address && tp.item->key.obj_type == TYPE_EXTENT_ITEM && tp.item->key.offset != size) {
-        ERR("extent %llx exists, but with size %llx rather than %llx expected\n", tp.item->key.obj_id, tp.item->key.offset, size);
+        ERR("extent %I64x exists, but with size %I64x rather than %I64x expected\n", tp.item->key.obj_id, tp.item->key.offset, size);
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -540,18 +540,18 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     }
 
     if (tp.item->size < sizeof(EXTENT_ITEM)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
         return STATUS_INTERNAL_ERROR;
     }
 
     ei = (EXTENT_ITEM*)tp.item->data;
 
     len = tp.item->size - sizeof(EXTENT_ITEM);
-    ptr = (UINT8*)&ei[1];
+    ptr = (uint8_t*)&ei[1];
 
     if (ei->flags & EXTENT_ITEM_TREE_BLOCK && !skinny) {
         if (tp.item->size < sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2));
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2));
             return STATUS_INTERNAL_ERROR;
         }
 
@@ -564,19 +564,19 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     // Loop through existing inline extent entries
 
     while (len > 0) {
-        UINT8 secttype = *ptr;
+        uint8_t secttype = *ptr;
         ULONG sectlen = get_extent_data_len(secttype);
-        UINT64 sectcount = get_extent_data_refcount(secttype, ptr + sizeof(UINT8));
+        uint64_t sectcount = get_extent_data_refcount(secttype, ptr + sizeof(uint8_t));
 
         len--;
 
         if (sectlen > len) {
-            ERR("(%llx,%x,%llx): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
+            ERR("(%I64x,%x,%I64x): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (sectlen == 0) {
-            ERR("(%llx,%x,%llx): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
+            ERR("(%I64x,%x,%I64x): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
             return STATUS_INTERNAL_ERROR;
         }
 
@@ -584,11 +584,11 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
 
         if (secttype == type) {
             if (type == TYPE_EXTENT_DATA_REF) {
-                EXTENT_DATA_REF* sectedr = (EXTENT_DATA_REF*)(ptr + sizeof(UINT8));
+                EXTENT_DATA_REF* sectedr = (EXTENT_DATA_REF*)(ptr + sizeof(uint8_t));
                 EXTENT_DATA_REF* edr = (EXTENT_DATA_REF*)data;
 
                 if (sectedr->root == edr->root && sectedr->objid == edr->objid && sectedr->offset == edr->offset) {
-                    UINT32 rc = get_extent_data_refcount(type, data);
+                    uint32_t rc = get_extent_data_refcount(type, data);
                     EXTENT_DATA_REF* sectedr2;
 
                     newei = ExAllocatePoolWithTag(PagedPool, tp.item->size, ALLOC_TAG);
@@ -601,7 +601,7 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
 
                     newei->refcount += rc;
 
-                    sectedr2 = (EXTENT_DATA_REF*)((UINT8*)newei + ((UINT8*)sectedr - tp.item->data));
+                    sectedr2 = (EXTENT_DATA_REF*)((uint8_t*)newei + ((uint8_t*)sectedr - tp.item->data));
                     sectedr2->count += rc;
 
                     Status = delete_tree_item(Vcb, &tp);
@@ -619,7 +619,7 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     return STATUS_SUCCESS;
                 }
             } else if (type == TYPE_TREE_BLOCK_REF) {
-                TREE_BLOCK_REF* secttbr = (TREE_BLOCK_REF*)(ptr + sizeof(UINT8));
+                TREE_BLOCK_REF* secttbr = (TREE_BLOCK_REF*)(ptr + sizeof(uint8_t));
                 TREE_BLOCK_REF* tbr = (TREE_BLOCK_REF*)data;
 
                 if (secttbr->offset == tbr->offset) {
@@ -627,17 +627,17 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     return STATUS_SUCCESS;
                 }
             } else if (type == TYPE_SHARED_BLOCK_REF) {
-                SHARED_BLOCK_REF* sectsbr = (SHARED_BLOCK_REF*)(ptr + sizeof(UINT8));
+                SHARED_BLOCK_REF* sectsbr = (SHARED_BLOCK_REF*)(ptr + sizeof(uint8_t));
                 SHARED_BLOCK_REF* sbr = (SHARED_BLOCK_REF*)data;
 
                 if (sectsbr->offset == sbr->offset)
                     return STATUS_SUCCESS;
             } else if (type == TYPE_SHARED_DATA_REF) {
-                SHARED_DATA_REF* sectsdr = (SHARED_DATA_REF*)(ptr + sizeof(UINT8));
+                SHARED_DATA_REF* sectsdr = (SHARED_DATA_REF*)(ptr + sizeof(uint8_t));
                 SHARED_DATA_REF* sdr = (SHARED_DATA_REF*)data;
 
                 if (sectsdr->offset == sdr->offset) {
-                    UINT32 rc = get_extent_data_refcount(type, data);
+                    uint32_t rc = get_extent_data_refcount(type, data);
                     SHARED_DATA_REF* sectsdr2;
 
                     newei = ExAllocatePoolWithTag(PagedPool, tp.item->size, ALLOC_TAG);
@@ -650,7 +650,7 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
 
                     newei->refcount += rc;
 
-                    sectsdr2 = (SHARED_DATA_REF*)((UINT8*)newei + ((UINT8*)sectsdr - tp.item->data));
+                    sectsdr2 = (SHARED_DATA_REF*)((uint8_t*)newei + ((uint8_t*)sectsdr - tp.item->data));
                     sectsdr2->count += rc;
 
                     Status = delete_tree_item(Vcb, &tp);
@@ -674,7 +674,7 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
         }
 
         len -= sectlen;
-        ptr += sizeof(UINT8) + sectlen;
+        ptr += sizeof(uint8_t) + sectlen;
         inline_rc += sectcount;
     }
 
@@ -684,9 +684,9 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
 
     // If we can, add entry as inline extent item
 
-    if (inline_rc == ei->refcount && tp.item->size + sizeof(UINT8) + datalen < max_extent_item_size) {
+    if (inline_rc == ei->refcount && tp.item->size + sizeof(uint8_t) + datalen < max_extent_item_size) {
         len = tp.item->size - sizeof(EXTENT_ITEM);
-        ptr = (UINT8*)&ei[1];
+        ptr = (uint8_t*)&ei[1];
 
         if (ei->flags & EXTENT_ITEM_TREE_BLOCK && !skinny) {
             len -= sizeof(EXTENT_ITEM2);
@@ -697,32 +697,32 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
         // SHARED_DATA_REFs), but then backwards by hash...
 
         while (len > 0) {
-            UINT8 secttype = *ptr;
+            uint8_t secttype = *ptr;
             ULONG sectlen = get_extent_data_len(secttype);
 
             if (secttype > type)
                 break;
 
             if (secttype == type) {
-                UINT64 sectoff = get_extent_hash(secttype, ptr + 1);
+                uint64_t sectoff = get_extent_hash(secttype, ptr + 1);
 
                 if (sectoff < offset)
                     break;
             }
 
-            len -= sectlen + sizeof(UINT8);
-            ptr += sizeof(UINT8) + sectlen;
+            len -= sectlen + sizeof(uint8_t);
+            ptr += sizeof(uint8_t) + sectlen;
         }
 
-        newei = ExAllocatePoolWithTag(PagedPool, tp.item->size + sizeof(UINT8) + datalen, ALLOC_TAG);
+        newei = ExAllocatePoolWithTag(PagedPool, tp.item->size + sizeof(uint8_t) + datalen, ALLOC_TAG);
         RtlCopyMemory(newei, tp.item->data, ptr - tp.item->data);
 
         newei->refcount += get_extent_data_refcount(type, data);
 
         if (len > 0)
-            RtlCopyMemory((UINT8*)newei + (ptr - tp.item->data) + sizeof(UINT8) + datalen, ptr, len);
+            RtlCopyMemory((uint8_t*)newei + (ptr - tp.item->data) + sizeof(uint8_t) + datalen, ptr, len);
 
-        ptr = (ptr - tp.item->data) + (UINT8*)newei;
+        ptr = (ptr - tp.item->data) + (uint8_t*)newei;
 
         *ptr = type;
         RtlCopyMemory(ptr + 1, data, datalen);
@@ -733,7 +733,7 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
             return Status;
         }
 
-        Status = insert_tree_item(Vcb, Vcb->extent_root, tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, newei, tp.item->size + sizeof(UINT8) + datalen, NULL, Irp);
+        Status = insert_tree_item(Vcb, Vcb->extent_root, tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, newei, tp.item->size + sizeof(uint8_t) + datalen, NULL, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("insert_tree_item returned %08x\n", Status);
             return Status;
@@ -751,18 +751,18 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
         searchkey.obj_type = type;
         searchkey.offset = offset;
 
-        Status = find_item(Vcb, Vcb->extent_root, &tp2, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->extent_root, &tp2, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
         }
 
         if (!keycmp(tp2.item->key, searchkey)) {
-            if (type == TYPE_SHARED_DATA_REF && tp2.item->size < sizeof(UINT32)) {
-                ERR("(%llx,%x,%llx) was %x bytes, expecting %x\n", tp2.item->key.obj_id, tp2.item->key.obj_type, tp2.item->key.offset, tp2.item->size, sizeof(UINT32));
+            if (type == TYPE_SHARED_DATA_REF && tp2.item->size < sizeof(uint32_t)) {
+                ERR("(%I64x,%x,%I64x) was %x bytes, expecting %x\n", tp2.item->key.obj_id, tp2.item->key.obj_type, tp2.item->key.offset, tp2.item->size, sizeof(uint32_t));
                 return STATUS_INTERNAL_ERROR;
             } else if (type != TYPE_SHARED_DATA_REF && tp2.item->size < datalen) {
-                ERR("(%llx,%x,%llx) was %x bytes, expecting %x\n", tp2.item->key.obj_id, tp2.item->key.obj_type, tp2.item->key.offset, tp2.item->size, datalen);
+                ERR("(%I64x,%x,%I64x) was %x bytes, expecting %x\n", tp2.item->key.obj_id, tp2.item->key.obj_type, tp2.item->key.offset, tp2.item->size, datalen);
                 return STATUS_INTERNAL_ERROR;
             }
 
@@ -784,7 +784,7 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
             } else if (type == TYPE_SHARED_BLOCK_REF)
                 return STATUS_SUCCESS;
             else if (type == TYPE_SHARED_DATA_REF) {
-                UINT32* sdr = (UINT32*)data2;
+                uint32_t* sdr = (uint32_t*)data2;
 
                 *sdr += get_extent_data_refcount(type, data);
             } else {
@@ -835,15 +835,15 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     if (type == TYPE_SHARED_DATA_REF) {
         SHARED_DATA_REF* sdr = (SHARED_DATA_REF*)data;
 
-        data2 = ExAllocatePoolWithTag(PagedPool, sizeof(UINT32), ALLOC_TAG);
+        data2 = ExAllocatePoolWithTag(PagedPool, sizeof(uint32_t), ALLOC_TAG);
         if (!data2) {
             ERR("out of memory\n");
             return STATUS_INSUFFICIENT_RESOURCES;
         }
 
-        datalen = sizeof(UINT32);
+        datalen = sizeof(uint32_t);
 
-        *((UINT32*)data2) = sdr->count;
+        *((uint32_t*)data2) = sdr->count;
     } else if (type == TYPE_TREE_BLOCK_REF || type == TYPE_SHARED_BLOCK_REF) {
         data2 = NULL;
         datalen = 0;
@@ -888,7 +888,7 @@ NTSTATUS increase_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     return STATUS_SUCCESS;
 }
 
-NTSTATUS increase_extent_refcount_data(device_extension* Vcb, UINT64 address, UINT64 size, UINT64 root, UINT64 inode, UINT64 offset, UINT32 refcount, PIRP Irp) {
+NTSTATUS increase_extent_refcount_data(device_extension* Vcb, uint64_t address, uint64_t size, uint64_t root, uint64_t inode, uint64_t offset, uint32_t refcount, PIRP Irp) {
     EXTENT_DATA_REF edr;
 
     edr.root = root;
@@ -899,32 +899,32 @@ NTSTATUS increase_extent_refcount_data(device_extension* Vcb, UINT64 address, UI
     return increase_extent_refcount(Vcb, address, size, TYPE_EXTENT_DATA_REF, &edr, NULL, 0, Irp);
 }
 
-NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64 size, UINT8 type, void* data, KEY* firstitem,
-                                  UINT8 level, UINT64 parent, BOOL superseded, PIRP Irp) {
+NTSTATUS decrease_extent_refcount(device_extension* Vcb, uint64_t address, uint64_t size, uint8_t type, void* data, KEY* firstitem,
+                                  uint8_t level, uint64_t parent, bool superseded, PIRP Irp) {
     KEY searchkey;
     NTSTATUS Status;
     traverse_ptr tp, tp2;
     EXTENT_ITEM* ei;
     ULONG len;
-    UINT64 inline_rc;
-    UINT8* ptr;
-    UINT32 rc = data ? get_extent_data_refcount(type, data) : 1;
+    uint64_t inline_rc;
+    uint8_t* ptr;
+    uint32_t rc = data ? get_extent_data_refcount(type, data) : 1;
     ULONG datalen = get_extent_data_len(type);
-    BOOL is_tree = (type == TYPE_TREE_BLOCK_REF || type == TYPE_SHARED_BLOCK_REF), skinny = FALSE;
+    bool is_tree = (type == TYPE_TREE_BLOCK_REF || type == TYPE_SHARED_BLOCK_REF), skinny = false;
 
     if (is_tree && Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA) {
         searchkey.obj_id = address;
         searchkey.obj_type = TYPE_METADATA_ITEM;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
         }
 
         if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type)
-            skinny = TRUE;
+            skinny = true;
     }
 
     if (!skinny) {
@@ -932,19 +932,19 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
         searchkey.obj_type = TYPE_EXTENT_ITEM;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
         }
 
         if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-            ERR("could not find EXTENT_ITEM for address %llx\n", address);
+            ERR("could not find EXTENT_ITEM for address %I64x\n", address);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (tp.item->key.offset != size) {
-            ERR("extent %llx had length %llx, not %llx as expected\n", address, tp.item->key.offset, size);
+            ERR("extent %I64x had length %I64x, not %I64x as expected\n", address, tp.item->key.offset, size);
             return STATUS_INTERNAL_ERROR;
         }
 
@@ -961,18 +961,18 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     }
 
     if (tp.item->size < sizeof(EXTENT_ITEM)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
         return STATUS_INTERNAL_ERROR;
     }
 
     ei = (EXTENT_ITEM*)tp.item->data;
 
     len = tp.item->size - sizeof(EXTENT_ITEM);
-    ptr = (UINT8*)&ei[1];
+    ptr = (uint8_t*)&ei[1];
 
     if (ei->flags & EXTENT_ITEM_TREE_BLOCK && !skinny) {
         if (tp.item->size < sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2));
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2));
             return STATUS_INTERNAL_ERROR;
         }
 
@@ -981,7 +981,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     }
 
     if (ei->refcount < rc) {
-        ERR("error - extent has refcount %llx, trying to reduce by %x\n", ei->refcount, rc);
+        ERR("error - extent has refcount %I64x, trying to reduce by %x\n", ei->refcount, rc);
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -990,29 +990,29 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     // Loop through inline extent entries
 
     while (len > 0) {
-        UINT8 secttype = *ptr;
-        UINT16 sectlen = get_extent_data_len(secttype);
-        UINT64 sectcount = get_extent_data_refcount(secttype, ptr + sizeof(UINT8));
+        uint8_t secttype = *ptr;
+        uint16_t sectlen = get_extent_data_len(secttype);
+        uint64_t sectcount = get_extent_data_refcount(secttype, ptr + sizeof(uint8_t));
 
         len--;
 
         if (sectlen > len) {
-            ERR("(%llx,%x,%llx): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
+            ERR("(%I64x,%x,%I64x): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (sectlen == 0) {
-            ERR("(%llx,%x,%llx): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
+            ERR("(%I64x,%x,%I64x): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (secttype == type) {
             if (type == TYPE_EXTENT_DATA_REF) {
-                EXTENT_DATA_REF* sectedr = (EXTENT_DATA_REF*)(ptr + sizeof(UINT8));
+                EXTENT_DATA_REF* sectedr = (EXTENT_DATA_REF*)(ptr + sizeof(uint8_t));
                 EXTENT_DATA_REF* edr = (EXTENT_DATA_REF*)data;
 
                 if (sectedr->root == edr->root && sectedr->objid == edr->objid && sectedr->offset == edr->offset) {
-                    UINT16 neweilen;
+                    uint16_t neweilen;
                     EXTENT_ITEM* newei;
 
                     if (ei->refcount == edr->count) {
@@ -1036,7 +1036,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     if (sectedr->count > edr->count)    // reduce section refcount
                         neweilen = tp.item->size;
                     else                                // remove section entirely
-                        neweilen = tp.item->size - sizeof(UINT8) - sectlen;
+                        neweilen = tp.item->size - sizeof(uint8_t) - sectlen;
 
                     newei = ExAllocatePoolWithTag(PagedPool, neweilen, ALLOC_TAG);
                     if (!newei) {
@@ -1045,7 +1045,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     }
 
                     if (sectedr->count > edr->count) {
-                        EXTENT_DATA_REF* newedr = (EXTENT_DATA_REF*)((UINT8*)newei + ((UINT8*)sectedr - tp.item->data));
+                        EXTENT_DATA_REF* newedr = (EXTENT_DATA_REF*)((uint8_t*)newei + ((uint8_t*)sectedr - tp.item->data));
 
                         RtlCopyMemory(newei, ei, neweilen);
 
@@ -1054,7 +1054,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                         RtlCopyMemory(newei, ei, ptr - tp.item->data);
 
                         if (len > sectlen)
-                            RtlCopyMemory((UINT8*)newei + (ptr - tp.item->data), ptr + sectlen + sizeof(UINT8), len - sectlen);
+                            RtlCopyMemory((uint8_t*)newei + (ptr - tp.item->data), ptr + sectlen + sizeof(uint8_t), len - sectlen);
                     }
 
                     newei->refcount -= rc;
@@ -1074,12 +1074,12 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     return STATUS_SUCCESS;
                 }
             } else if (type == TYPE_SHARED_DATA_REF) {
-                SHARED_DATA_REF* sectsdr = (SHARED_DATA_REF*)(ptr + sizeof(UINT8));
+                SHARED_DATA_REF* sectsdr = (SHARED_DATA_REF*)(ptr + sizeof(uint8_t));
                 SHARED_DATA_REF* sdr = (SHARED_DATA_REF*)data;
 
                 if (sectsdr->offset == sdr->offset) {
                     EXTENT_ITEM* newei;
-                    UINT16 neweilen;
+                    uint16_t neweilen;
 
                     if (ei->refcount == sectsdr->count) {
                         Status = delete_tree_item(Vcb, &tp);
@@ -1102,7 +1102,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     if (sectsdr->count > sdr->count)    // reduce section refcount
                         neweilen = tp.item->size;
                     else                                // remove section entirely
-                        neweilen = tp.item->size - sizeof(UINT8) - sectlen;
+                        neweilen = tp.item->size - sizeof(uint8_t) - sectlen;
 
                     newei = ExAllocatePoolWithTag(PagedPool, neweilen, ALLOC_TAG);
                     if (!newei) {
@@ -1111,7 +1111,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     }
 
                     if (sectsdr->count > sdr->count) {
-                        SHARED_DATA_REF* newsdr = (SHARED_DATA_REF*)((UINT8*)newei + ((UINT8*)sectsdr - tp.item->data));
+                        SHARED_DATA_REF* newsdr = (SHARED_DATA_REF*)((uint8_t*)newei + ((uint8_t*)sectsdr - tp.item->data));
 
                         RtlCopyMemory(newei, ei, neweilen);
 
@@ -1120,7 +1120,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                         RtlCopyMemory(newei, ei, ptr - tp.item->data);
 
                         if (len > sectlen)
-                            RtlCopyMemory((UINT8*)newei + (ptr - tp.item->data), ptr + sectlen + sizeof(UINT8), len - sectlen);
+                            RtlCopyMemory((uint8_t*)newei + (ptr - tp.item->data), ptr + sectlen + sizeof(uint8_t), len - sectlen);
                     }
 
                     newei->refcount -= rc;
@@ -1140,12 +1140,12 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     return STATUS_SUCCESS;
                 }
             } else if (type == TYPE_TREE_BLOCK_REF) {
-                TREE_BLOCK_REF* secttbr = (TREE_BLOCK_REF*)(ptr + sizeof(UINT8));
+                TREE_BLOCK_REF* secttbr = (TREE_BLOCK_REF*)(ptr + sizeof(uint8_t));
                 TREE_BLOCK_REF* tbr = (TREE_BLOCK_REF*)data;
 
                 if (secttbr->offset == tbr->offset) {
                     EXTENT_ITEM* newei;
-                    UINT16 neweilen;
+                    uint16_t neweilen;
 
                     if (ei->refcount == 1) {
                         Status = delete_tree_item(Vcb, &tp);
@@ -1157,7 +1157,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                         return STATUS_SUCCESS;
                     }
 
-                    neweilen = tp.item->size - sizeof(UINT8) - sectlen;
+                    neweilen = tp.item->size - sizeof(uint8_t) - sectlen;
 
                     newei = ExAllocatePoolWithTag(PagedPool, neweilen, ALLOC_TAG);
                     if (!newei) {
@@ -1168,7 +1168,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     RtlCopyMemory(newei, ei, ptr - tp.item->data);
 
                     if (len > sectlen)
-                        RtlCopyMemory((UINT8*)newei + (ptr - tp.item->data), ptr + sectlen + sizeof(UINT8), len - sectlen);
+                        RtlCopyMemory((uint8_t*)newei + (ptr - tp.item->data), ptr + sectlen + sizeof(uint8_t), len - sectlen);
 
                     newei->refcount--;
 
@@ -1187,12 +1187,12 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     return STATUS_SUCCESS;
                 }
             } else if (type == TYPE_SHARED_BLOCK_REF) {
-                SHARED_BLOCK_REF* sectsbr = (SHARED_BLOCK_REF*)(ptr + sizeof(UINT8));
+                SHARED_BLOCK_REF* sectsbr = (SHARED_BLOCK_REF*)(ptr + sizeof(uint8_t));
                 SHARED_BLOCK_REF* sbr = (SHARED_BLOCK_REF*)data;
 
                 if (sectsbr->offset == sbr->offset) {
                     EXTENT_ITEM* newei;
-                    UINT16 neweilen;
+                    uint16_t neweilen;
 
                     if (ei->refcount == 1) {
                         Status = delete_tree_item(Vcb, &tp);
@@ -1204,7 +1204,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                         return STATUS_SUCCESS;
                     }
 
-                    neweilen = tp.item->size - sizeof(UINT8) - sectlen;
+                    neweilen = tp.item->size - sizeof(uint8_t) - sectlen;
 
                     newei = ExAllocatePoolWithTag(PagedPool, neweilen, ALLOC_TAG);
                     if (!newei) {
@@ -1215,7 +1215,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
                     RtlCopyMemory(newei, ei, ptr - tp.item->data);
 
                     if (len > sectlen)
-                        RtlCopyMemory((UINT8*)newei + (ptr - tp.item->data), ptr + sectlen + sizeof(UINT8), len - sectlen);
+                        RtlCopyMemory((uint8_t*)newei + (ptr - tp.item->data), ptr + sectlen + sizeof(uint8_t), len - sectlen);
 
                     newei->refcount--;
 
@@ -1240,17 +1240,17 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
         }
 
         len -= sectlen;
-        ptr += sizeof(UINT8) + sectlen;
+        ptr += sizeof(uint8_t) + sectlen;
         inline_rc += sectcount;
     }
 
     if (inline_rc == ei->refcount) {
-        ERR("entry not found in inline extent item for address %llx\n", address);
+        ERR("entry not found in inline extent item for address %I64x\n", address);
         return STATUS_INTERNAL_ERROR;
     }
 
     if (type == TYPE_SHARED_DATA_REF)
-        datalen = sizeof(UINT32);
+        datalen = sizeof(uint32_t);
     else if (type == TYPE_TREE_BLOCK_REF || type == TYPE_SHARED_BLOCK_REF)
         datalen = 0;
 
@@ -1258,19 +1258,19 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     searchkey.obj_type = type;
     searchkey.offset = (type == TYPE_SHARED_DATA_REF || type == TYPE_EXTENT_REF_V0) ? parent : get_extent_hash(type, data);
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp2, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp2, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
     }
 
     if (keycmp(tp2.item->key, searchkey)) {
-        ERR("(%llx,%x,%llx) not found\n", tp2.item->key.obj_id, tp2.item->key.obj_type, tp2.item->key.offset);
+        ERR("(%I64x,%x,%I64x) not found\n", tp2.item->key.obj_id, tp2.item->key.obj_type, tp2.item->key.offset);
         return STATUS_INTERNAL_ERROR;
     }
 
     if (tp2.item->size < datalen) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp2.item->key.obj_id, tp2.item->key.obj_type, tp2.item->key.offset, tp2.item->size, datalen);
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp2.item->key.obj_id, tp2.item->key.obj_type, tp2.item->key.offset, tp2.item->size, datalen);
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -1361,7 +1361,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
         SHARED_DATA_REF* sdr = (SHARED_DATA_REF*)data;
 
         if (tp2.item->key.offset == sdr->offset) {
-            UINT32* sectsdrcount = (UINT32*)tp2.item->data;
+            uint32_t* sectsdrcount = (uint32_t*)tp2.item->data;
             EXTENT_ITEM* newei;
 
             if (ei->refcount == sdr->count) {
@@ -1395,7 +1395,7 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
             }
 
             if (*sectsdrcount > sdr->count) {
-                UINT32* newsdr = ExAllocatePoolWithTag(PagedPool, tp2.item->size, ALLOC_TAG);
+                uint32_t* newsdr = ExAllocatePoolWithTag(PagedPool, tp2.item->size, ALLOC_TAG);
 
                 if (!newsdr) {
                     ERR("out of memory\n");
@@ -1544,8 +1544,8 @@ NTSTATUS decrease_extent_refcount(device_extension* Vcb, UINT64 address, UINT64
     }
 }
 
-NTSTATUS decrease_extent_refcount_data(device_extension* Vcb, UINT64 address, UINT64 size, UINT64 root, UINT64 inode,
-                                       UINT64 offset, UINT32 refcount, BOOL superseded, PIRP Irp) {
+NTSTATUS decrease_extent_refcount_data(device_extension* Vcb, uint64_t address, uint64_t size, uint64_t root, uint64_t inode,
+                                       uint64_t offset, uint32_t refcount, bool superseded, PIRP Irp) {
     EXTENT_DATA_REF edr;
 
     edr.root = root;
@@ -1556,16 +1556,16 @@ NTSTATUS decrease_extent_refcount_data(device_extension* Vcb, UINT64 address, UI
     return decrease_extent_refcount(Vcb, address, size, TYPE_EXTENT_DATA_REF, &edr, NULL, 0, 0, superseded, Irp);
 }
 
-NTSTATUS decrease_extent_refcount_tree(device_extension* Vcb, UINT64 address, UINT64 size, UINT64 root,
-                                       UINT8 level, PIRP Irp) {
+NTSTATUS decrease_extent_refcount_tree(device_extension* Vcb, uint64_t address, uint64_t size, uint64_t root,
+                                       uint8_t level, PIRP Irp) {
     TREE_BLOCK_REF tbr;
 
     tbr.offset = root;
 
-    return decrease_extent_refcount(Vcb, address, size, TYPE_TREE_BLOCK_REF, &tbr, NULL/*FIXME*/, level, 0, FALSE, Irp);
+    return decrease_extent_refcount(Vcb, address, size, TYPE_TREE_BLOCK_REF, &tbr, NULL/*FIXME*/, level, 0, false, Irp);
 }
 
-static UINT32 find_extent_data_refcount(device_extension* Vcb, UINT64 address, UINT64 size, UINT64 root, UINT64 objid, UINT64 offset, PIRP Irp) {
+static uint32_t find_extent_data_refcount(device_extension* Vcb, uint64_t address, uint64_t size, uint64_t root, uint64_t objid, uint64_t offset, PIRP Irp) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
@@ -1574,53 +1574,53 @@ static UINT32 find_extent_data_refcount(device_extension* Vcb, UINT64 address, U
     searchkey.obj_type = TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return 0;
     }
 
     if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-        TRACE("could not find address %llx in extent tree\n", address);
+        TRACE("could not find address %I64x in extent tree\n", address);
         return 0;
     }
 
     if (tp.item->key.offset != size) {
-        ERR("extent %llx had size %llx, not %llx as expected\n", address, tp.item->key.offset, size);
+        ERR("extent %I64x had size %I64x, not %I64x as expected\n", address, tp.item->key.offset, size);
         return 0;
     }
 
     if (tp.item->size >= sizeof(EXTENT_ITEM)) {
         EXTENT_ITEM* ei = (EXTENT_ITEM*)tp.item->data;
-        UINT32 len = tp.item->size - sizeof(EXTENT_ITEM);
-        UINT8* ptr = (UINT8*)&ei[1];
+        uint32_t len = tp.item->size - sizeof(EXTENT_ITEM);
+        uint8_t* ptr = (uint8_t*)&ei[1];
 
         while (len > 0) {
-            UINT8 secttype = *ptr;
+            uint8_t secttype = *ptr;
             ULONG sectlen = get_extent_data_len(secttype);
-            UINT32 sectcount = get_extent_data_refcount(secttype, ptr + sizeof(UINT8));
+            uint32_t sectcount = get_extent_data_refcount(secttype, ptr + sizeof(uint8_t));
 
             len--;
 
             if (sectlen > len) {
-                ERR("(%llx,%x,%llx): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
+                ERR("(%I64x,%x,%I64x): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
                 return 0;
             }
 
             if (sectlen == 0) {
-                ERR("(%llx,%x,%llx): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
+                ERR("(%I64x,%x,%I64x): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
                 return 0;
             }
 
             if (secttype == TYPE_EXTENT_DATA_REF) {
-                EXTENT_DATA_REF* sectedr = (EXTENT_DATA_REF*)(ptr + sizeof(UINT8));
+                EXTENT_DATA_REF* sectedr = (EXTENT_DATA_REF*)(ptr + sizeof(uint8_t));
 
                 if (sectedr->root == root && sectedr->objid == objid && sectedr->offset == offset)
                     return sectcount;
             }
 
             len -= sectlen;
-            ptr += sizeof(UINT8) + sectlen;
+            ptr += sizeof(uint8_t) + sectlen;
         }
     }
 
@@ -1628,7 +1628,7 @@ static UINT32 find_extent_data_refcount(device_extension* Vcb, UINT64 address, U
     searchkey.obj_type = TYPE_EXTENT_DATA_REF;
     searchkey.offset = get_extent_data_ref_hash2(root, objid, offset);
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return 0;
@@ -1636,7 +1636,7 @@ static UINT32 find_extent_data_refcount(device_extension* Vcb, UINT64 address, U
 
     if (!keycmp(searchkey, tp.item->key)) {
         if (tp.item->size < sizeof(EXTENT_DATA_REF))
-            ERR("(%llx,%x,%llx) has size %u, not %u as expected\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_DATA_REF));
+            ERR("(%I64x,%x,%I64x) has size %u, not %u as expected\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_DATA_REF));
         else {
             EXTENT_DATA_REF* edr = (EXTENT_DATA_REF*)tp.item->data;
 
@@ -1647,7 +1647,7 @@ static UINT32 find_extent_data_refcount(device_extension* Vcb, UINT64 address, U
     return 0;
 }
 
-UINT64 get_extent_refcount(device_extension* Vcb, UINT64 address, UINT64 size, PIRP Irp) {
+uint64_t get_extent_refcount(device_extension* Vcb, uint64_t address, uint64_t size, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
@@ -1657,7 +1657,7 @@ UINT64 get_extent_refcount(device_extension* Vcb, UINT64 address, UINT64 size, P
     searchkey.obj_type = Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA ? TYPE_METADATA_ITEM : TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return 0;
@@ -1671,10 +1671,10 @@ UINT64 get_extent_refcount(device_extension* Vcb, UINT64 address, UINT64 size, P
     }
 
     if (tp.item->key.obj_id != address || tp.item->key.obj_type != TYPE_EXTENT_ITEM) {
-        ERR("couldn't find (%llx,%x,%llx) in extent tree\n", address, TYPE_EXTENT_ITEM, size);
+        ERR("couldn't find (%I64x,%x,%I64x) in extent tree\n", address, TYPE_EXTENT_ITEM, size);
         return 0;
     } else if (tp.item->key.offset != size) {
-        ERR("extent %llx had size %llx, not %llx as expected\n", address, tp.item->key.offset, size);
+        ERR("extent %I64x had size %I64x, not %I64x as expected\n", address, tp.item->key.offset, size);
         return 0;
     }
 
@@ -1683,7 +1683,7 @@ UINT64 get_extent_refcount(device_extension* Vcb, UINT64 address, UINT64 size, P
 
         return eiv0->refcount;
     } else if (tp.item->size < sizeof(EXTENT_ITEM)) {
-        ERR("(%llx,%x,%llx) was %x bytes, expected at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type,
+        ERR("(%I64x,%x,%I64x) was %x bytes, expected at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type,
                                                                        tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
         return 0;
     }
@@ -1693,56 +1693,56 @@ UINT64 get_extent_refcount(device_extension* Vcb, UINT64 address, UINT64 size, P
     return ei->refcount;
 }
 
-BOOL is_extent_unique(device_extension* Vcb, UINT64 address, UINT64 size, PIRP Irp) {
+bool is_extent_unique(device_extension* Vcb, uint64_t address, uint64_t size, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp, next_tp;
     NTSTATUS Status;
-    UINT64 rc, rcrun, root = 0, inode = 0, offset = 0;
-    UINT32 len;
+    uint64_t rc, rcrun, root = 0, inode = 0, offset = 0;
+    uint32_t len;
     EXTENT_ITEM* ei;
-    UINT8* ptr;
-    BOOL b;
+    uint8_t* ptr;
+    bool b;
 
     rc = get_extent_refcount(Vcb, address, size, Irp);
 
     if (rc == 1)
-        return TRUE;
+        return true;
 
     if (rc == 0)
-        return FALSE;
+        return false;
 
     searchkey.obj_id = address;
     searchkey.obj_type = TYPE_EXTENT_ITEM;
     searchkey.offset = size;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         WARN("error - find_item returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
     if (keycmp(tp.item->key, searchkey)) {
-        WARN("could not find (%llx,%x,%llx)\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
-        return FALSE;
+        WARN("could not find (%I64x,%x,%I64x)\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+        return false;
     }
 
     if (tp.item->size == sizeof(EXTENT_ITEM_V0))
-        return FALSE;
+        return false;
 
     if (tp.item->size < sizeof(EXTENT_ITEM)) {
-        WARN("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
-        return FALSE;
+        WARN("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
+        return false;
     }
 
     ei = (EXTENT_ITEM*)tp.item->data;
 
     len = tp.item->size - sizeof(EXTENT_ITEM);
-    ptr = (UINT8*)&ei[1];
+    ptr = (uint8_t*)&ei[1];
 
     if (ei->flags & EXTENT_ITEM_TREE_BLOCK) {
         if (tp.item->size < sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2)) {
-            WARN("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2));
-            return FALSE;
+            WARN("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2));
+            return false;
         }
 
         len -= sizeof(EXTENT_ITEM2);
@@ -1754,54 +1754,54 @@ BOOL is_extent_unique(device_extension* Vcb, UINT64 address, UINT64 size, PIRP I
     // Loop through inline extent entries
 
     while (len > 0) {
-        UINT8 secttype = *ptr;
+        uint8_t secttype = *ptr;
         ULONG sectlen = get_extent_data_len(secttype);
-        UINT64 sectcount = get_extent_data_refcount(secttype, ptr + sizeof(UINT8));
+        uint64_t sectcount = get_extent_data_refcount(secttype, ptr + sizeof(uint8_t));
 
         len--;
 
         if (sectlen > len) {
-            WARN("(%llx,%x,%llx): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
-            return FALSE;
+            WARN("(%I64x,%x,%I64x): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
+            return false;
         }
 
         if (sectlen == 0) {
-            WARN("(%llx,%x,%llx): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
-            return FALSE;
+            WARN("(%I64x,%x,%I64x): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
+            return false;
         }
 
         if (secttype == TYPE_EXTENT_DATA_REF) {
-            EXTENT_DATA_REF* sectedr = (EXTENT_DATA_REF*)(ptr + sizeof(UINT8));
+            EXTENT_DATA_REF* sectedr = (EXTENT_DATA_REF*)(ptr + sizeof(uint8_t));
 
             if (root == 0 && inode == 0) {
                 root = sectedr->root;
                 inode = sectedr->objid;
                 offset = sectedr->offset;
             } else if (root != sectedr->root || inode != sectedr->objid || offset != sectedr->offset)
-                return FALSE;
+                return false;
         } else
-            return FALSE;
+            return false;
 
         len -= sectlen;
-        ptr += sizeof(UINT8) + sectlen;
+        ptr += sizeof(uint8_t) + sectlen;
         rcrun += sectcount;
     }
 
     if (rcrun == rc)
-        return TRUE;
+        return true;
 
     // Loop through non-inlines if some refs still unaccounted for
 
     do {
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, Irp);
+        b = find_next_item(Vcb, &tp, &next_tp, false, Irp);
 
         if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == TYPE_EXTENT_DATA_REF) {
             EXTENT_DATA_REF* edr = (EXTENT_DATA_REF*)tp.item->data;
 
             if (tp.item->size < sizeof(EXTENT_DATA_REF)) {
-                WARN("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+                WARN("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                      tp.item->size, sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2));
-                return FALSE;
+                return false;
             }
 
             if (root == 0 && inode == 0) {
@@ -1809,13 +1809,13 @@ BOOL is_extent_unique(device_extension* Vcb, UINT64 address, UINT64 size, PIRP I
                 inode = edr->objid;
                 offset = edr->offset;
             } else if (root != edr->root || inode != edr->objid || offset != edr->offset)
-                return FALSE;
+                return false;
 
             rcrun += edr->count;
         }
 
         if (rcrun == rc)
-            return TRUE;
+            return true;
 
         if (b) {
             tp = next_tp;
@@ -1826,12 +1826,12 @@ BOOL is_extent_unique(device_extension* Vcb, UINT64 address, UINT64 size, PIRP I
     } while (b);
 
     // If we reach this point, there's still some refs unaccounted for somewhere.
-    // Return FALSE in case we mess things up elsewhere.
+    // Return false in case we mess things up elsewhere.
 
-    return FALSE;
+    return false;
 }
 
-UINT64 get_extent_flags(device_extension* Vcb, UINT64 address, PIRP Irp) {
+uint64_t get_extent_flags(device_extension* Vcb, uint64_t address, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
@@ -1841,7 +1841,7 @@ UINT64 get_extent_flags(device_extension* Vcb, UINT64 address, PIRP Irp) {
     searchkey.obj_type = Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA ? TYPE_METADATA_ITEM : TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return 0;
@@ -1855,14 +1855,14 @@ UINT64 get_extent_flags(device_extension* Vcb, UINT64 address, PIRP Irp) {
     }
 
     if (tp.item->key.obj_id != address || tp.item->key.obj_type != TYPE_EXTENT_ITEM) {
-        ERR("couldn't find %llx in extent tree\n", address);
+        ERR("couldn't find %I64x in extent tree\n", address);
         return 0;
     }
 
     if (tp.item->size == sizeof(EXTENT_ITEM_V0))
         return 0;
     else if (tp.item->size < sizeof(EXTENT_ITEM)) {
-        ERR("(%llx,%x,%llx) was %x bytes, expected at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type,
+        ERR("(%I64x,%x,%I64x) was %x bytes, expected at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type,
                                                                    tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
         return 0;
     }
@@ -1872,7 +1872,7 @@ UINT64 get_extent_flags(device_extension* Vcb, UINT64 address, PIRP Irp) {
     return ei->flags;
 }
 
-void update_extent_flags(device_extension* Vcb, UINT64 address, UINT64 flags, PIRP Irp) {
+void update_extent_flags(device_extension* Vcb, uint64_t address, uint64_t flags, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
@@ -1882,7 +1882,7 @@ void update_extent_flags(device_extension* Vcb, UINT64 address, UINT64 flags, PI
     searchkey.obj_type = Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA ? TYPE_METADATA_ITEM : TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return;
@@ -1896,14 +1896,14 @@ void update_extent_flags(device_extension* Vcb, UINT64 address, UINT64 flags, PI
     }
 
     if (tp.item->key.obj_id != address || tp.item->key.obj_type != TYPE_EXTENT_ITEM) {
-        ERR("couldn't find %llx in extent tree\n", address);
+        ERR("couldn't find %I64x in extent tree\n", address);
         return;
     }
 
     if (tp.item->size == sizeof(EXTENT_ITEM_V0))
         return;
     else if (tp.item->size < sizeof(EXTENT_ITEM)) {
-        ERR("(%llx,%x,%llx) was %x bytes, expected at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type,
+        ERR("(%I64x,%x,%I64x) was %x bytes, expected at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type,
                                                                    tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
         return;
     }
@@ -1912,7 +1912,7 @@ void update_extent_flags(device_extension* Vcb, UINT64 address, UINT64 flags, PI
     ei->flags = flags;
 }
 
-static changed_extent* get_changed_extent_item(chunk* c, UINT64 address, UINT64 size, BOOL no_csum) {
+static changed_extent* get_changed_extent_item(chunk* c, uint64_t address, uint64_t size, bool no_csum) {
     LIST_ENTRY* le;
     changed_extent* ce;
 
@@ -1938,7 +1938,7 @@ static changed_extent* get_changed_extent_item(chunk* c, UINT64 address, UINT64
     ce->count = 0;
     ce->old_count = 0;
     ce->no_csum = no_csum;
-    ce->superseded = FALSE;
+    ce->superseded = false;
     InitializeListHead(&ce->refs);
     InitializeListHead(&ce->old_refs);
 
@@ -1947,17 +1947,17 @@ static changed_extent* get_changed_extent_item(chunk* c, UINT64 address, UINT64
     return ce;
 }
 
-NTSTATUS update_changed_extent_ref(device_extension* Vcb, chunk* c, UINT64 address, UINT64 size, UINT64 root, UINT64 objid, UINT64 offset, INT32 count,
-                                   BOOL no_csum, BOOL superseded, PIRP Irp) {
+NTSTATUS update_changed_extent_ref(device_extension* Vcb, chunk* c, uint64_t address, uint64_t size, uint64_t root, uint64_t objid, uint64_t offset, int32_t count,
+                                   bool no_csum, bool superseded, PIRP Irp) {
     LIST_ENTRY* le;
     changed_extent* ce;
     changed_extent_ref* cer;
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
-    UINT32 old_count;
+    uint32_t old_count;
 
-    ExAcquireResourceExclusiveLite(&c->changed_extents_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&c->changed_extents_lock, true);
 
     ce = get_changed_extent_item(c, address, size, no_csum);
 
@@ -1972,20 +1972,20 @@ NTSTATUS update_changed_extent_ref(device_extension* Vcb, chunk* c, UINT64 addre
         searchkey.obj_type = TYPE_EXTENT_ITEM;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             goto end;
         }
 
         if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-            ERR("could not find address %llx in extent tree\n", address);
+            ERR("could not find address %I64x in extent tree\n", address);
             Status = STATUS_INTERNAL_ERROR;
             goto end;
         }
 
         if (tp.item->key.offset != size) {
-            ERR("extent %llx had size %llx, not %llx as expected\n", address, tp.item->key.offset, size);
+            ERR("extent %I64x had size %I64x, not %I64x as expected\n", address, tp.item->key.offset, size);
             Status = STATUS_INTERNAL_ERROR;
             goto end;
         }
@@ -1999,7 +1999,7 @@ NTSTATUS update_changed_extent_ref(device_extension* Vcb, chunk* c, UINT64 addre
 
             ce->count = ce->old_count = ei->refcount;
         } else {
-            ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
             Status = STATUS_INTERNAL_ERROR;
             goto end;
         }
@@ -2015,7 +2015,7 @@ NTSTATUS update_changed_extent_ref(device_extension* Vcb, chunk* c, UINT64 addre
             Status = STATUS_SUCCESS;
 
             if (superseded)
-                ce->superseded = TRUE;
+                ce->superseded = true;
 
             goto end;
         }
@@ -2062,7 +2062,7 @@ NTSTATUS update_changed_extent_ref(device_extension* Vcb, chunk* c, UINT64 addre
     ce->count += count;
 
     if (superseded)
-        ce->superseded = TRUE;
+        ce->superseded = true;
 
     Status = STATUS_SUCCESS;
 
@@ -2072,7 +2072,7 @@ end:
     return Status;
 }
 
-void add_changed_extent_ref(chunk* c, UINT64 address, UINT64 size, UINT64 root, UINT64 objid, UINT64 offset, UINT32 count, BOOL no_csum) {
+void add_changed_extent_ref(chunk* c, uint64_t address, uint64_t size, uint64_t root, uint64_t objid, uint64_t offset, uint32_t count, bool no_csum) {
     changed_extent* ce;
     changed_extent_ref* cer;
     LIST_ENTRY* le;
@@ -2115,37 +2115,37 @@ void add_changed_extent_ref(chunk* c, UINT64 address, UINT64 size, UINT64 root,
     ce->count += count;
 }
 
-UINT64 find_extent_shared_tree_refcount(device_extension* Vcb, UINT64 address, UINT64 parent, PIRP Irp) {
+uint64_t find_extent_shared_tree_refcount(device_extension* Vcb, uint64_t address, uint64_t parent, PIRP Irp) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
-    UINT64 inline_rc;
+    uint64_t inline_rc;
     EXTENT_ITEM* ei;
-    UINT32 len;
-    UINT8* ptr;
+    uint32_t len;
+    uint8_t* ptr;
 
     searchkey.obj_id = address;
     searchkey.obj_type = Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA ? TYPE_METADATA_ITEM : TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return 0;
     }
 
     if (tp.item->key.obj_id != searchkey.obj_id || (tp.item->key.obj_type != TYPE_EXTENT_ITEM && tp.item->key.obj_type != TYPE_METADATA_ITEM)) {
-        TRACE("could not find address %llx in extent tree\n", address);
+        TRACE("could not find address %I64x in extent tree\n", address);
         return 0;
     }
 
     if (tp.item->key.obj_type == TYPE_EXTENT_ITEM && tp.item->key.offset != Vcb->superblock.node_size) {
-        ERR("extent %llx had size %llx, not %llx as expected\n", address, tp.item->key.offset, Vcb->superblock.node_size);
+        ERR("extent %I64x had size %I64x, not %I64x as expected\n", address, tp.item->key.offset, Vcb->superblock.node_size);
         return 0;
     }
 
     if (tp.item->size < sizeof(EXTENT_ITEM)) {
-        ERR("(%llx,%x,%llx): size was %u, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
+        ERR("(%I64x,%x,%I64x): size was %u, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
         return 0;
     }
 
@@ -2153,11 +2153,11 @@ UINT64 find_extent_shared_tree_refcount(device_extension* Vcb, UINT64 address, U
     inline_rc = 0;
 
     len = tp.item->size - sizeof(EXTENT_ITEM);
-    ptr = (UINT8*)&ei[1];
+    ptr = (uint8_t*)&ei[1];
 
     if (searchkey.obj_type == TYPE_EXTENT_ITEM && ei->flags & EXTENT_ITEM_TREE_BLOCK) {
         if (tp.item->size < sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2)) {
-            ERR("(%llx,%x,%llx): size was %u, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+            ERR("(%I64x,%x,%I64x): size was %u, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                                                                        tp.item->size, sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2));
             return 0;
         }
@@ -2167,31 +2167,31 @@ UINT64 find_extent_shared_tree_refcount(device_extension* Vcb, UINT64 address, U
     }
 
     while (len > 0) {
-        UINT8 secttype = *ptr;
+        uint8_t secttype = *ptr;
         ULONG sectlen = get_extent_data_len(secttype);
-        UINT64 sectcount = get_extent_data_refcount(secttype, ptr + sizeof(UINT8));
+        uint64_t sectcount = get_extent_data_refcount(secttype, ptr + sizeof(uint8_t));
 
         len--;
 
         if (sectlen > len) {
-            ERR("(%llx,%x,%llx): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
+            ERR("(%I64x,%x,%I64x): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
             return 0;
         }
 
         if (sectlen == 0) {
-            ERR("(%llx,%x,%llx): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
+            ERR("(%I64x,%x,%I64x): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
             return 0;
         }
 
         if (secttype == TYPE_SHARED_BLOCK_REF) {
-            SHARED_BLOCK_REF* sectsbr = (SHARED_BLOCK_REF*)(ptr + sizeof(UINT8));
+            SHARED_BLOCK_REF* sectsbr = (SHARED_BLOCK_REF*)(ptr + sizeof(uint8_t));
 
             if (sectsbr->offset == parent)
                 return 1;
         }
 
         len -= sectlen;
-        ptr += sizeof(UINT8) + sectlen;
+        ptr += sizeof(uint8_t) + sectlen;
         inline_rc += sectcount;
     }
 
@@ -2204,7 +2204,7 @@ UINT64 find_extent_shared_tree_refcount(device_extension* Vcb, UINT64 address, U
     searchkey.obj_type = TYPE_SHARED_BLOCK_REF;
     searchkey.offset = parent;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return 0;
@@ -2216,32 +2216,32 @@ UINT64 find_extent_shared_tree_refcount(device_extension* Vcb, UINT64 address, U
     return 0;
 }
 
-UINT32 find_extent_shared_data_refcount(device_extension* Vcb, UINT64 address, UINT64 parent, PIRP Irp) {
+uint32_t find_extent_shared_data_refcount(device_extension* Vcb, uint64_t address, uint64_t parent, PIRP Irp) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
-    UINT64 inline_rc;
+    uint64_t inline_rc;
     EXTENT_ITEM* ei;
-    UINT32 len;
-    UINT8* ptr;
+    uint32_t len;
+    uint8_t* ptr;
 
     searchkey.obj_id = address;
     searchkey.obj_type = Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA ? TYPE_METADATA_ITEM : TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return 0;
     }
 
     if (tp.item->key.obj_id != searchkey.obj_id || (tp.item->key.obj_type != TYPE_EXTENT_ITEM && tp.item->key.obj_type != TYPE_METADATA_ITEM)) {
-        TRACE("could not find address %llx in extent tree\n", address);
+        TRACE("could not find address %I64x in extent tree\n", address);
         return 0;
     }
 
     if (tp.item->size < sizeof(EXTENT_ITEM)) {
-        ERR("(%llx,%x,%llx): size was %u, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
+        ERR("(%I64x,%x,%I64x): size was %u, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
         return 0;
     }
 
@@ -2249,34 +2249,34 @@ UINT32 find_extent_shared_data_refcount(device_extension* Vcb, UINT64 address, U
     inline_rc = 0;
 
     len = tp.item->size - sizeof(EXTENT_ITEM);
-    ptr = (UINT8*)&ei[1];
+    ptr = (uint8_t*)&ei[1];
 
     while (len > 0) {
-        UINT8 secttype = *ptr;
+        uint8_t secttype = *ptr;
         ULONG sectlen = get_extent_data_len(secttype);
-        UINT64 sectcount = get_extent_data_refcount(secttype, ptr + sizeof(UINT8));
+        uint64_t sectcount = get_extent_data_refcount(secttype, ptr + sizeof(uint8_t));
 
         len--;
 
         if (sectlen > len) {
-            ERR("(%llx,%x,%llx): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
+            ERR("(%I64x,%x,%I64x): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
             return 0;
         }
 
         if (sectlen == 0) {
-            ERR("(%llx,%x,%llx): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
+            ERR("(%I64x,%x,%I64x): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
             return 0;
         }
 
         if (secttype == TYPE_SHARED_DATA_REF) {
-            SHARED_DATA_REF* sectsdr = (SHARED_DATA_REF*)(ptr + sizeof(UINT8));
+            SHARED_DATA_REF* sectsdr = (SHARED_DATA_REF*)(ptr + sizeof(uint8_t));
 
             if (sectsdr->offset == parent)
                 return sectsdr->count;
         }
 
         len -= sectlen;
-        ptr += sizeof(UINT8) + sectlen;
+        ptr += sizeof(uint8_t) + sectlen;
         inline_rc += sectcount;
     }
 
@@ -2289,17 +2289,17 @@ UINT32 find_extent_shared_data_refcount(device_extension* Vcb, UINT64 address, U
     searchkey.obj_type = TYPE_SHARED_DATA_REF;
     searchkey.offset = parent;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return 0;
     }
 
     if (!keycmp(searchkey, tp.item->key)) {
-        if (tp.item->size < sizeof(UINT32))
-            ERR("(%llx,%x,%llx) has size %u, not %u as expected\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(UINT32));
+        if (tp.item->size < sizeof(uint32_t))
+            ERR("(%I64x,%x,%I64x) has size %u, not %u as expected\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(uint32_t));
         else {
-            UINT32* count = (UINT32*)tp.item->data;
+            uint32_t* count = (uint32_t*)tp.item->data;
             return *count;
         }
     }
diff --git a/drivers/filesystems/btrfs/fastio.c b/drivers/filesystems/btrfs/fastio.c
index 9ee282d04c1..79604b469ad 100644
--- a/drivers/filesystems/btrfs/fastio.c
+++ b/drivers/filesystems/btrfs/fastio.c
@@ -20,13 +20,8 @@
 FAST_IO_DISPATCH FastIoDispatch;
 
 _Function_class_(FAST_IO_QUERY_BASIC_INFO)
-#ifdef __REACTOS__
-static BOOLEAN NTAPI fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_BASIC_INFORMATION fbi,
-                                           PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
-#else
-static BOOLEAN fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_BASIC_INFORMATION fbi,
-                                     PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
-#endif
+static BOOLEAN __stdcall fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_BASIC_INFORMATION fbi,
+                                               PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
     fcb* fcb;
     ccb* ccb;
 
@@ -36,32 +31,32 @@ static BOOLEAN fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFIL
 
     if (!FileObject) {
         FsRtlExitFileSystem();
-        return FALSE;
+        return false;
     }
 
     fcb = FileObject->FsContext;
 
     if (!fcb) {
         FsRtlExitFileSystem();
-        return FALSE;
+        return false;
     }
 
     ccb = FileObject->FsContext2;
 
     if (!ccb) {
         FsRtlExitFileSystem();
-        return FALSE;
+        return false;
     }
 
     if (!(ccb->access & (FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES))) {
         FsRtlExitFileSystem();
-        return FALSE;
+        return false;
     }
 
     if (fcb->ads) {
         if (!ccb->fileref || !ccb->fileref->parent || !ccb->fileref->parent->fcb) {
             FsRtlExitFileSystem();
-            return FALSE;
+            return false;
         }
 
         fcb = ccb->fileref->parent->fcb;
@@ -69,7 +64,7 @@ static BOOLEAN fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFIL
 
     if (!ExAcquireResourceSharedLite(fcb->Header.Resource, wait)) {
         FsRtlExitFileSystem();
-        return FALSE;
+        return false;
     }
 
     if (fcb == fcb->Vcb->dummy_fcb) {
@@ -93,20 +88,15 @@ static BOOLEAN fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFIL
 
     FsRtlExitFileSystem();
 
-    return TRUE;
+    return true;
 }
 
 _Function_class_(FAST_IO_QUERY_STANDARD_INFO)
-#ifdef __REACTOS__
-static BOOLEAN NTAPI fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_STANDARD_INFORMATION fsi,
-                                              PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
-#else
-static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_STANDARD_INFORMATION fsi,
-                                        PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
-#endif
+static BOOLEAN __stdcall fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_STANDARD_INFORMATION fsi,
+                                                  PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
     fcb* fcb;
     ccb* ccb;
-    BOOL ads;
+    bool ads;
     ULONG adssize;
 
     FsRtlEnterFileSystem();
@@ -115,7 +105,7 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
 
     if (!FileObject) {
         FsRtlExitFileSystem();
-        return FALSE;
+        return false;
     }
 
     fcb = FileObject->FsContext;
@@ -123,12 +113,12 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
 
     if (!fcb) {
         FsRtlExitFileSystem();
-        return FALSE;
+        return false;
     }
 
     if (!ExAcquireResourceSharedLite(fcb->Header.Resource, wait)) {
         FsRtlExitFileSystem();
-        return FALSE;
+        return false;
     }
 
     ads = fcb->ads;
@@ -139,7 +129,7 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
         if (!ccb || !ccb->fileref || !ccb->fileref->parent || !ccb->fileref->parent->fcb) {
             ExReleaseResourceLite(fcb->Header.Resource);
             FsRtlExitFileSystem();
-            return FALSE;
+            return false;
         }
 
         adssize = fcb->adsdata.Length;
@@ -152,12 +142,12 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
 
         if (!ExAcquireResourceSharedLite(fcb->Header.Resource, wait)) {
             FsRtlExitFileSystem();
-            return FALSE;
+            return false;
         }
 
         fsi->AllocationSize.QuadPart = fsi->EndOfFile.QuadPart = adssize;
         fsi->NumberOfLinks = fcb->inode_item.st_nlink;
-        fsi->Directory = FALSE;
+        fsi->Directory = false;
     } else {
         fsi->AllocationSize.QuadPart = fcb_alloc_size(fcb);
         fsi->EndOfFile.QuadPart = S_ISDIR(fcb->inode_item.st_mode) ? 0 : fcb->inode_item.st_size;
@@ -165,7 +155,7 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
         fsi->Directory = S_ISDIR(fcb->inode_item.st_mode);
     }
 
-    fsi->DeletePending = ccb->fileref ? ccb->fileref->delete_on_close : FALSE;
+    fsi->DeletePending = ccb->fileref ? ccb->fileref->delete_on_close : false;
 
     IoStatus->Status = STATUS_SUCCESS;
     IoStatus->Information = sizeof(FILE_STANDARD_INFORMATION);
@@ -174,19 +164,13 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
 
     FsRtlExitFileSystem();
 
-    return TRUE;
+    return true;
 }
 
 _Function_class_(FAST_IO_CHECK_IF_POSSIBLE)
-#ifdef __REACTOS__
-static BOOLEAN NTAPI fast_io_check_if_possible(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait,
-                                               ULONG LockKey, BOOLEAN CheckForReadOperation, PIO_STATUS_BLOCK IoStatus,
-                                               PDEVICE_OBJECT DeviceObject) {
-#else
-static BOOLEAN fast_io_check_if_possible(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait,
-                                         ULONG LockKey, BOOLEAN CheckForReadOperation, PIO_STATUS_BLOCK IoStatus,
-                                         PDEVICE_OBJECT DeviceObject) {
-#endif
+static BOOLEAN __stdcall fast_io_check_if_possible(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait,
+                                                   ULONG LockKey, BOOLEAN CheckForReadOperation, PIO_STATUS_BLOCK IoStatus,
+                                                   PDEVICE_OBJECT DeviceObject) {
     fcb* fcb = FileObject->FsContext;
     LARGE_INTEGER len2;
 
@@ -198,23 +182,18 @@ static BOOLEAN fast_io_check_if_possible(PFILE_OBJECT FileObject, PLARGE_INTEGER
 
     if (CheckForReadOperation) {
         if (FsRtlFastCheckLockForRead(&fcb->lock, FileOffset, &len2, LockKey, FileObject, PsGetCurrentProcess()))
-            return TRUE;
+            return true;
     } else {
         if (!fcb->Vcb->readonly && !is_subvol_readonly(fcb->subvol, NULL) && FsRtlFastCheckLockForWrite(&fcb->lock, FileOffset, &len2, LockKey, FileObject, PsGetCurrentProcess()))
-            return TRUE;
+            return true;
     }
 
-    return FALSE;
+    return false;
 }
 
 _Function_class_(FAST_IO_QUERY_NETWORK_OPEN_INFO)
-#ifdef __REACTOS__
-static BOOLEAN NTAPI fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN Wait, FILE_NETWORK_OPEN_INFORMATION* fnoi,
-                                                     PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
-#else
-static BOOLEAN fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN Wait, FILE_NETWORK_OPEN_INFORMATION* fnoi,
-                                               PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
-#endif
+static BOOLEAN __stdcall fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN Wait, FILE_NETWORK_OPEN_INFORMATION* fnoi,
+                                                         PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
     fcb* fcb;
     ccb* ccb;
     file_ref* fileref;
@@ -229,14 +208,14 @@ static BOOLEAN fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN
 
     if (!fcb || fcb == fcb->Vcb->volume_fcb) {
         FsRtlExitFileSystem();
-        return FALSE;
+        return false;
     }
 
     ccb = FileObject->FsContext2;
 
     if (!ccb) {
         FsRtlExitFileSystem();
-        return FALSE;
+        return false;
     }
 
     fileref = ccb->fileref;
@@ -253,7 +232,7 @@ static BOOLEAN fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN
             if (!fileref || !fileref->parent) {
                 ERR("no fileref for stream\n");
                 FsRtlExitFileSystem();
-                return FALSE;
+                return false;
             }
 
             ii = &fileref->parent->fcb->inode_item;
@@ -277,17 +256,16 @@ static BOOLEAN fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN
 
     FsRtlExitFileSystem();
 
-    return TRUE;
+    return true;
 }
 
 _Function_class_(FAST_IO_ACQUIRE_FOR_MOD_WRITE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI fast_io_acquire_for_mod_write(PFILE_OBJECT FileObject, PLARGE_INTEGER EndingOffset, struct _ERESOURCE **ResourceToRelease, PDEVICE_OBJECT DeviceObject) {
-#else
-static NTSTATUS fast_io_acquire_for_mod_write(PFILE_OBJECT FileObject, PLARGE_INTEGER EndingOffset, struct _ERESOURCE **ResourceToRelease, PDEVICE_OBJECT DeviceObject) {
-#endif
+static NTSTATUS __stdcall fast_io_acquire_for_mod_write(PFILE_OBJECT FileObject, PLARGE_INTEGER EndingOffset,
+                                                        struct _ERESOURCE **ResourceToRelease, PDEVICE_OBJECT DeviceObject) {
     fcb* fcb;
 
+    TRACE("(%p, %I64x, %p, %p)\n", FileObject, EndingOffset ? EndingOffset->QuadPart : 0, ResourceToRelease, DeviceObject);
+
     UNUSED(EndingOffset);
     UNUSED(DeviceObject);
 
@@ -298,30 +276,32 @@ static NTSTATUS fast_io_acquire_for_mod_write(PFILE_OBJECT FileObject, PLARGE_IN
 
     // Make sure we don't get interrupted by the flush thread, which can cause a deadlock
 
-    if (!ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, FALSE))
+    if (!ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, false))
         return STATUS_CANT_WAIT;
 
+    if (!ExAcquireResourceExclusiveLite(fcb->Header.Resource, false)) {
+        ExReleaseResourceLite(&fcb->Vcb->tree_lock);
+        TRACE("returning STATUS_CANT_WAIT\n");
+        return STATUS_CANT_WAIT;
+    }
+
     // Ideally this would be PagingIoResource, but that doesn't play well with copy-on-write,
     // as we can't guarantee that we won't need to do any reallocations.
 
     *ResourceToRelease = fcb->Header.Resource;
 
-    if (!ExAcquireResourceExclusiveLite(*ResourceToRelease, FALSE)) {
-        ExReleaseResourceLite(&fcb->Vcb->tree_lock);
-        return STATUS_CANT_WAIT;
-    }
+    TRACE("returning STATUS_SUCCESS\n");
 
     return STATUS_SUCCESS;
 }
 
 _Function_class_(FAST_IO_RELEASE_FOR_MOD_WRITE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI fast_io_release_for_mod_write(PFILE_OBJECT FileObject, struct _ERESOURCE *ResourceToRelease, PDEVICE_OBJECT DeviceObject) {
-#else
-static NTSTATUS fast_io_release_for_mod_write(PFILE_OBJECT FileObject, struct _ERESOURCE *ResourceToRelease, PDEVICE_OBJECT DeviceObject) {
-#endif
+static NTSTATUS __stdcall fast_io_release_for_mod_write(PFILE_OBJECT FileObject, struct _ERESOURCE *ResourceToRelease,
+                                                        PDEVICE_OBJECT DeviceObject) {
     fcb* fcb;
 
+    TRACE("(%p, %p, %p)\n", FileObject, ResourceToRelease, DeviceObject);
+
     UNUSED(DeviceObject);
 
     fcb = FileObject->FsContext;
@@ -334,11 +314,7 @@ static NTSTATUS fast_io_release_for_mod_write(PFILE_OBJECT FileObject, struct _E
 }
 
 _Function_class_(FAST_IO_ACQUIRE_FOR_CCFLUSH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI fast_io_acquire_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
-#else
-static NTSTATUS fast_io_acquire_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
-#endif
+static NTSTATUS __stdcall fast_io_acquire_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
     UNUSED(FileObject);
     UNUSED(DeviceObject);
 
@@ -348,11 +324,7 @@ static NTSTATUS fast_io_acquire_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJ
 }
 
 _Function_class_(FAST_IO_RELEASE_FOR_CCFLUSH)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI fast_io_release_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
-#else
-static NTSTATUS fast_io_release_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
-#endif
+static NTSTATUS __stdcall fast_io_release_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
     UNUSED(FileObject);
     UNUSED(DeviceObject);
 
@@ -363,20 +335,134 @@ static NTSTATUS fast_io_release_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJ
 }
 
 _Function_class_(FAST_IO_WRITE)
-#ifdef __REACTOS__
-static BOOLEAN NTAPI fast_io_write(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
-#else
-static BOOLEAN fast_io_write(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
-#endif
+static BOOLEAN __stdcall fast_io_write(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
     if (FsRtlCopyWrite(FileObject, FileOffset, Length, Wait, LockKey, Buffer, IoStatus, DeviceObject)) {
         fcb* fcb = FileObject->FsContext;
 
         fcb->inode_item.st_size = fcb->Header.FileSize.QuadPart;
 
-        return TRUE;
+        return true;
+    }
+
+    return false;
+}
+
+_Function_class_(FAST_IO_LOCK)
+static BOOLEAN __stdcall fast_io_lock(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PLARGE_INTEGER Length, PEPROCESS ProcessId,
+                                      ULONG Key, BOOLEAN FailImmediately, BOOLEAN ExclusiveLock, PIO_STATUS_BLOCK IoStatus,
+                                      PDEVICE_OBJECT DeviceObject) {
+    BOOLEAN ret;
+    fcb* fcb = FileObject->FsContext;
+
+    TRACE("(%p, %I64x, %I64x, %p, %x, %u, %u, %p, %p)\n", FileObject, FileOffset ? FileOffset->QuadPart : 0, Length ? Length->QuadPart : 0,
+          ProcessId, Key, FailImmediately, ExclusiveLock, IoStatus, DeviceObject);
+
+    if (fcb->type != BTRFS_TYPE_FILE) {
+        WARN("can only lock files\n");
+        IoStatus->Status = STATUS_INVALID_PARAMETER;
+        IoStatus->Information = 0;
+        return true;
+    }
+
+    FsRtlEnterFileSystem();
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
+
+    ret = FsRtlFastLock(&fcb->lock, FileObject, FileOffset, Length, ProcessId, Key, FailImmediately,
+                        ExclusiveLock, IoStatus, NULL, false);
+
+    if (ret)
+        fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
+
+    ExReleaseResourceLite(fcb->Header.Resource);
+    FsRtlExitFileSystem();
+
+    return ret;
+}
+
+_Function_class_(FAST_IO_UNLOCK_SINGLE)
+static BOOLEAN __stdcall fast_io_unlock_single(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PLARGE_INTEGER Length, PEPROCESS ProcessId,
+                                               ULONG Key, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
+    fcb* fcb = FileObject->FsContext;
+
+    TRACE("(%p, %I64x, %I64x, %p, %x, %p, %p)\n", FileObject, FileOffset ? FileOffset->QuadPart : 0, Length ? Length->QuadPart : 0,
+          ProcessId, Key, IoStatus, DeviceObject);
+
+    IoStatus->Information = 0;
+
+    if (fcb->type != BTRFS_TYPE_FILE) {
+        WARN("can only lock files\n");
+        IoStatus->Status = STATUS_INVALID_PARAMETER;
+        return true;
     }
 
-    return FALSE;
+    FsRtlEnterFileSystem();
+
+    IoStatus->Status = FsRtlFastUnlockSingle(&fcb->lock, FileObject, FileOffset, Length, ProcessId, Key, NULL, false);
+
+    fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
+
+    FsRtlExitFileSystem();
+
+    return true;
+}
+
+_Function_class_(FAST_IO_UNLOCK_ALL)
+static BOOLEAN __stdcall fast_io_unlock_all(PFILE_OBJECT FileObject, PEPROCESS ProcessId, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
+    fcb* fcb = FileObject->FsContext;
+
+    TRACE("(%p, %p, %p, %p)\n", FileObject, ProcessId, IoStatus, DeviceObject);
+
+    IoStatus->Information = 0;
+
+    if (fcb->type != BTRFS_TYPE_FILE) {
+        WARN("can only lock files\n");
+        IoStatus->Status = STATUS_INVALID_PARAMETER;
+        return true;
+    }
+
+    FsRtlEnterFileSystem();
+
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
+
+    IoStatus->Status = FsRtlFastUnlockAll(&fcb->lock, FileObject, ProcessId, NULL);
+
+    fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
+
+    ExReleaseResourceLite(fcb->Header.Resource);
+
+    FsRtlExitFileSystem();
+
+    return true;
+}
+
+_Function_class_(FAST_IO_UNLOCK_ALL_BY_KEY)
+static BOOLEAN __stdcall fast_io_unlock_all_by_key(PFILE_OBJECT FileObject, PVOID ProcessId, ULONG Key,
+                                                   PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
+    fcb* fcb = FileObject->FsContext;
+
+    TRACE("(%p, %p, %x, %p, %p)\n", FileObject, ProcessId, Key, IoStatus, DeviceObject);
+
+    IoStatus->Information = 0;
+
+    if (fcb->type != BTRFS_TYPE_FILE) {
+        WARN("can only lock files\n");
+        IoStatus->Status = STATUS_INVALID_PARAMETER;
+        return true;
+    }
+
+    FsRtlEnterFileSystem();
+
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
+
+    IoStatus->Status = FsRtlFastUnlockAllByKey(&fcb->lock, FileObject, ProcessId, Key, NULL);
+
+    fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
+
+    ExReleaseResourceLite(fcb->Header.Resource);
+
+    FsRtlExitFileSystem();
+
+    return true;
 }
 
 void init_fast_io_dispatch(FAST_IO_DISPATCH** fiod) {
@@ -385,19 +471,23 @@ void init_fast_io_dispatch(FAST_IO_DISPATCH** fiod) {
     FastIoDispatch.SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
 
     FastIoDispatch.FastIoCheckIfPossible = fast_io_check_if_possible;
+    FastIoDispatch.FastIoRead = FsRtlCopyRead;
+    FastIoDispatch.FastIoWrite = fast_io_write;
     FastIoDispatch.FastIoQueryBasicInfo = fast_query_basic_info;
     FastIoDispatch.FastIoQueryStandardInfo = fast_query_standard_info;
+    FastIoDispatch.FastIoLock = fast_io_lock;
+    FastIoDispatch.FastIoUnlockSingle = fast_io_unlock_single;
+    FastIoDispatch.FastIoUnlockAll = fast_io_unlock_all;
+    FastIoDispatch.FastIoUnlockAllByKey = fast_io_unlock_all_by_key;
     FastIoDispatch.FastIoQueryNetworkOpenInfo = fast_io_query_network_open_info;
     FastIoDispatch.AcquireForModWrite = fast_io_acquire_for_mod_write;
-    FastIoDispatch.ReleaseForModWrite = fast_io_release_for_mod_write;
-    FastIoDispatch.AcquireForCcFlush = fast_io_acquire_for_ccflush;
-    FastIoDispatch.ReleaseForCcFlush = fast_io_release_for_ccflush;
-    FastIoDispatch.FastIoWrite = fast_io_write;
-    FastIoDispatch.FastIoRead = FsRtlCopyRead;
     FastIoDispatch.MdlRead = FsRtlMdlReadDev;
     FastIoDispatch.MdlReadComplete = FsRtlMdlReadCompleteDev;
     FastIoDispatch.PrepareMdlWrite = FsRtlPrepareMdlWriteDev;
     FastIoDispatch.MdlWriteComplete = FsRtlMdlWriteCompleteDev;
+    FastIoDispatch.ReleaseForModWrite = fast_io_release_for_mod_write;
+    FastIoDispatch.AcquireForCcFlush = fast_io_acquire_for_ccflush;
+    FastIoDispatch.ReleaseForCcFlush = fast_io_release_for_ccflush;
 
     *fiod = &FastIoDispatch;
 }
diff --git a/drivers/filesystems/btrfs/fileinfo.c b/drivers/filesystems/btrfs/fileinfo.c
index 06ae42ac65c..6defcb1e512 100644
--- a/drivers/filesystems/btrfs/fileinfo.c
+++ b/drivers/filesystems/btrfs/fileinfo.c
@@ -17,7 +17,6 @@
 
 #include "btrfs_drv.h"
 
-#if (NTDDI_VERSION >= NTDDI_WIN10)
 // not currently in mingw - introduced with Windows 10
 #ifndef _MSC_VER
 #define FileIdInformation (enum _FILE_INFORMATION_CLASS)59
@@ -146,45 +145,6 @@ typedef struct _FILE_LINKS_FULL_ID_INFORMATION {
 #define FILE_RENAME_INFORMATION_EX FILE_RENAME_INFORMATION
 #define FILE_LINK_INFORMATION_EX FILE_LINK_INFORMATION
 
-#endif
-#endif
-
-#ifdef __REACTOS__
-typedef struct _FILE_RENAME_INFORMATION_EX {
-    union {
-        BOOLEAN ReplaceIfExists;
-        ULONG Flags;
-    };
-    HANDLE RootDirectory;
-    ULONG FileNameLength;
-    WCHAR FileName[1];
-} FILE_RENAME_INFORMATION_EX, *PFILE_RENAME_INFORMATION_EX;
-
-typedef struct _FILE_DISPOSITION_INFORMATION_EX {
-    ULONG Flags;
-} FILE_DISPOSITION_INFORMATION_EX, *PFILE_DISPOSITION_INFORMATION_EX;
-
-typedef struct _FILE_LINK_INFORMATION_EX {
-    union {
-        BOOLEAN ReplaceIfExists;
-        ULONG Flags;
-    };
-    HANDLE RootDirectory;
-    ULONG FileNameLength;
-    WCHAR FileName[1];
-} FILE_LINK_INFORMATION_EX, *PFILE_LINK_INFORMATION_EX;
-
-#define FILE_RENAME_REPLACE_IF_EXISTS                       0x001
-#define FILE_RENAME_POSIX_SEMANTICS                         0x002
-#define FILE_RENAME_IGNORE_READONLY_ATTRIBUTE               0x040
-
-#define FILE_DISPOSITION_DELETE                         0x1
-#define FILE_DISPOSITION_POSIX_SEMANTICS                0x2
-#define FILE_DISPOSITION_FORCE_IMAGE_SECTION_CHECK      0x4
-
-#define FILE_LINK_REPLACE_IF_EXISTS                       0x001
-#define FILE_LINK_POSIX_SEMANTICS                         0x002
-#define FILE_LINK_IGNORE_READONLY_ATTRIBUTE               0x040
 #endif
 
 static NTSTATUS set_basic_information(device_extension* Vcb, PIRP Irp, PFILE_OBJECT FileObject) {
@@ -193,7 +153,7 @@ static NTSTATUS set_basic_information(device_extension* Vcb, PIRP Irp, PFILE_OBJ
     ccb* ccb = FileObject->FsContext2;
     file_ref* fileref = ccb ? ccb->fileref : NULL;
     ULONG defda, filter = 0;
-    BOOL inode_item_changed = FALSE;
+    bool inode_item_changed = false;
     NTSTATUS Status;
 
     if (fcb->ads) {
@@ -212,7 +172,7 @@ static NTSTATUS set_basic_information(device_extension* Vcb, PIRP Irp, PFILE_OBJ
 
     TRACE("file = %S, attributes = %x\n", file_desc(FileObject), fbi->FileAttributes);
 
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (fbi->FileAttributes & FILE_ATTRIBUTE_DIRECTORY && fcb->type != BTRFS_TYPE_DIRECTORY) {
         WARN("attempted to set FILE_ATTRIBUTE_DIRECTORY on non-directory\n");
@@ -248,43 +208,43 @@ static NTSTATUS set_basic_information(device_extension* Vcb, PIRP Irp, PFILE_OBJ
         fbi->ChangeTime.QuadPart = 0;
 
     if (fbi->CreationTime.QuadPart == -1)
-        ccb->user_set_creation_time = TRUE;
+        ccb->user_set_creation_time = true;
     else if (fbi->CreationTime.QuadPart != 0) {
         win_time_to_unix(fbi->CreationTime, &fcb->inode_item.otime);
-        inode_item_changed = TRUE;
+        inode_item_changed = true;
         filter |= FILE_NOTIFY_CHANGE_CREATION;
 
-        ccb->user_set_creation_time = TRUE;
+        ccb->user_set_creation_time = true;
     }
 
     if (fbi->LastAccessTime.QuadPart == -1)
-        ccb->user_set_access_time = TRUE;
+        ccb->user_set_access_time = true;
     else if (fbi->LastAccessTime.QuadPart != 0) {
         win_time_to_unix(fbi->LastAccessTime, &fcb->inode_item.st_atime);
-        inode_item_changed = TRUE;
+        inode_item_changed = true;
         filter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
 
-        ccb->user_set_access_time = TRUE;
+        ccb->user_set_access_time = true;
     }
 
     if (fbi->LastWriteTime.QuadPart == -1)
-        ccb->user_set_write_time = TRUE;
+        ccb->user_set_write_time = true;
     else if (fbi->LastWriteTime.QuadPart != 0) {
         win_time_to_unix(fbi->LastWriteTime, &fcb->inode_item.st_mtime);
-        inode_item_changed = TRUE;
+        inode_item_changed = true;
         filter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
 
-        ccb->user_set_write_time = TRUE;
+        ccb->user_set_write_time = true;
     }
 
     if (fbi->ChangeTime.QuadPart == -1)
-        ccb->user_set_change_time = TRUE;
+        ccb->user_set_change_time = true;
     else if (fbi->ChangeTime.QuadPart != 0) {
         win_time_to_unix(fbi->ChangeTime, &fcb->inode_item.st_ctime);
-        inode_item_changed = TRUE;
+        inode_item_changed = true;
         // no filter for this
 
-        ccb->user_set_change_time = TRUE;
+        ccb->user_set_change_time = true;
     }
 
     // FileAttributes == 0 means don't set - undocumented, but seen in fastfat
@@ -295,22 +255,22 @@ static NTSTATUS set_basic_information(device_extension* Vcb, PIRP Irp, PFILE_OBJ
         fbi->FileAttributes &= ~FILE_ATTRIBUTE_NORMAL;
 
         defda = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type, fileref && fileref->dc && fileref->dc->name.Length >= sizeof(WCHAR) && fileref->dc->name.Buffer[0] == '.',
-                                    TRUE, Irp);
+                                    true, Irp);
 
         if (fcb->type == BTRFS_TYPE_DIRECTORY)
             fbi->FileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
         else if (fcb->type == BTRFS_TYPE_SYMLINK)
             fbi->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
 
-        fcb->atts_changed = TRUE;
+        fcb->atts_changed = true;
 
         if (fcb->atts & FILE_ATTRIBUTE_REPARSE_POINT)
             fbi->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
 
         if (defda == fbi->FileAttributes)
-            fcb->atts_deleted = TRUE;
+            fcb->atts_deleted = true;
         else if (fcb->inode == SUBVOL_ROOT_INODE && (defda | FILE_ATTRIBUTE_READONLY) == (fbi->FileAttributes | FILE_ATTRIBUTE_READONLY))
-            fcb->atts_deleted = TRUE;
+            fcb->atts_deleted = true;
 
         fcb->atts = fbi->FileAttributes;
 
@@ -330,7 +290,7 @@ static NTSTATUS set_basic_information(device_extension* Vcb, PIRP Irp, PFILE_OBJ
                 fcb->subvol->root_item.flags &= ~BTRFS_SUBVOL_READONLY;
         }
 
-        inode_item_changed = TRUE;
+        inode_item_changed = true;
 
         filter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
     }
@@ -338,7 +298,7 @@ static NTSTATUS set_basic_information(device_extension* Vcb, PIRP Irp, PFILE_OBJ
     if (inode_item_changed) {
         fcb->inode_item.transid = Vcb->superblock.generation;
         fcb->inode_item.sequence++;
-        fcb->inode_item_changed = TRUE;
+        fcb->inode_item_changed = true;
 
         mark_fcb_dirty(fcb);
     }
@@ -354,7 +314,7 @@ end:
     return Status;
 }
 
-static NTSTATUS set_disposition_information(device_extension* Vcb, PIRP Irp, PFILE_OBJECT FileObject, BOOL ex) {
+static NTSTATUS set_disposition_information(device_extension* Vcb, PIRP Irp, PFILE_OBJECT FileObject, bool ex) {
     fcb* fcb = FileObject->FsContext;
     ccb* ccb = FileObject->FsContext2;
     file_ref* fileref = ccb ? ccb->fileref : NULL;
@@ -374,9 +334,9 @@ static NTSTATUS set_disposition_information(device_extension* Vcb, PIRP Irp, PFI
         flags = fdi->DeleteFile ? FILE_DISPOSITION_DELETE : 0;
     }
 
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
-    TRACE("changing delete_on_close to %s for %S (fcb %p)\n", flags & FILE_DISPOSITION_DELETE ? "TRUE" : "FALSE", file_desc(FileObject), fcb);
+    TRACE("changing delete_on_close to %s for %S (fcb %p)\n", flags & FILE_DISPOSITION_DELETE ? "true" : "false", file_desc(FileObject), fcb);
 
     if (fcb->ads) {
         if (fileref->parent)
@@ -417,7 +377,7 @@ static NTSTATUS set_disposition_information(device_extension* Vcb, PIRP Irp, PFI
     FileObject->DeletePending = flags & FILE_DISPOSITION_DELETE;
 
     if (flags & FILE_DISPOSITION_DELETE && flags & FILE_DISPOSITION_POSIX_SEMANTICS)
-        ccb->fileref->posix_delete = TRUE;
+        ccb->fileref->posix_delete = true;
 
     Status = STATUS_SUCCESS;
 
@@ -427,31 +387,31 @@ end:
     // send notification that directory is about to be deleted
     if (NT_SUCCESS(Status) && flags & FILE_DISPOSITION_DELETE && fcb->type == BTRFS_TYPE_DIRECTORY) {
         FsRtlNotifyFullChangeDirectory(Vcb->NotifySync, &Vcb->DirNotifyList, FileObject->FsContext,
-                                       NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
+                                       NULL, false, false, 0, NULL, NULL, NULL);
     }
 
     return Status;
 }
 
-BOOL has_open_children(file_ref* fileref) {
+bool has_open_children(file_ref* fileref) {
     LIST_ENTRY* le = fileref->children.Flink;
 
     if (IsListEmpty(&fileref->children))
-        return FALSE;
+        return false;
 
     while (le != &fileref->children) {
         file_ref* c = CONTAINING_RECORD(le, file_ref, list_entry);
 
         if (c->open_count > 0)
-            return TRUE;
+            return true;
 
         if (has_open_children(c))
-            return TRUE;
+            return true;
 
         le = le->Flink;
     }
 
-    return FALSE;
+    return false;
 }
 
 static NTSTATUS duplicate_fcb(fcb* oldfcb, fcb** pfcb) {
@@ -477,7 +437,7 @@ static NTSTATUS duplicate_fcb(fcb* oldfcb, fcb** pfcb) {
     fcb->type = oldfcb->type;
 
     if (oldfcb->ads) {
-        fcb->ads = TRUE;
+        fcb->ads = true;
         fcb->adshash = oldfcb->adshash;
         fcb->adsmaxlen = oldfcb->adsmaxlen;
 
@@ -513,7 +473,7 @@ static NTSTATUS duplicate_fcb(fcb* oldfcb, fcb** pfcb) {
     }
 
     RtlCopyMemory(&fcb->inode_item, &oldfcb->inode_item, sizeof(INODE_ITEM));
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
 
     if (oldfcb->sd && RtlLengthSecurityDescriptor(oldfcb->sd) > 0) {
         fcb->sd = ExAllocatePoolWithTag(PagedPool, RtlLengthSecurityDescriptor(oldfcb->sd), ALLOC_TAG);
@@ -547,9 +507,9 @@ static NTSTATUS duplicate_fcb(fcb* oldfcb, fcb** pfcb) {
             if (ext2->datalen > 0)
                 RtlCopyMemory(&ext2->extent_data, &ext->extent_data, ext2->datalen);
 
-            ext2->unique = FALSE;
-            ext2->ignore = FALSE;
-            ext2->inserted = TRUE;
+            ext2->unique = false;
+            ext2->ignore = false;
+            ext2->inserted = true;
 
             if (ext->csum) {
                 ULONG len;
@@ -560,7 +520,7 @@ static NTSTATUS duplicate_fcb(fcb* oldfcb, fcb** pfcb) {
                 else
                     len = (ULONG)ed2->size;
 
-                len = len * sizeof(UINT32) / Vcb->superblock.sector_size;
+                len = len * sizeof(uint32_t) / Vcb->superblock.sector_size;
 
                 ext2->csum = ExAllocatePoolWithTag(PagedPool, len, ALLOC_TAG);
                 if (!ext2->csum) {
@@ -696,7 +656,7 @@ static NTSTATUS add_children_to_move_list(device_extension* Vcb, move_entry* me,
     NTSTATUS Status;
     LIST_ENTRY* le;
 
-    ExAcquireResourceSharedLite(&me->fileref->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceSharedLite(&me->fileref->fcb->nonpaged->dir_children_lock, true);
 
     le = me->fileref->fcb->dir_children_index.Flink;
 
@@ -705,7 +665,7 @@ static NTSTATUS add_children_to_move_list(device_extension* Vcb, move_entry* me,
         file_ref* fr;
         move_entry* me2;
 
-        Status = open_fileref_child(Vcb, me->fileref, &dc->name, TRUE, TRUE, dc->index == 0 ? TRUE : FALSE, PagedPool, &fr, Irp);
+        Status = open_fileref_child(Vcb, me->fileref, &dc->name, true, true, dc->index == 0 ? true : false, PagedPool, &fr, Irp);
 
         if (!NT_SUCCESS(Status)) {
             ERR("open_fileref_child returned %08x\n", Status);
@@ -736,7 +696,7 @@ static NTSTATUS add_children_to_move_list(device_extension* Vcb, move_entry* me,
 }
 
 void remove_dir_child_from_hash_lists(fcb* fcb, dir_child* dc) {
-    UINT8 c;
+    uint8_t c;
 
     c = dc->hash >> 24;
 
@@ -800,15 +760,15 @@ static NTSTATUS create_directory_fcb(device_extension* Vcb, root* r, fcb* parfcb
     fcb->inode_item.generation = Vcb->superblock.generation;
     fcb->inode_item.transid = Vcb->superblock.generation;
     fcb->inode_item.st_nlink = 1;
-    fcb->inode_item.st_mode = __S_IFDIR | inherit_mode(parfcb, TRUE);
+    fcb->inode_item.st_mode = __S_IFDIR | inherit_mode(parfcb, true);
     fcb->inode_item.st_atime = fcb->inode_item.st_ctime = fcb->inode_item.st_mtime = fcb->inode_item.otime = now;
     fcb->inode_item.st_gid = GID_NOBODY;
 
-    fcb->atts = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type, FALSE, TRUE, NULL);
+    fcb->atts = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type, false, true, NULL);
 
     SeCaptureSubjectContext(&subjcont);
 
-    Status = SeAssignSecurity(parfcb->sd, NULL, (void**)&fcb->sd, TRUE, &subjcont, IoGetFileObjectGenericMapping(), PagedPool);
+    Status = SeAssignSecurity(parfcb->sd, NULL, (void**)&fcb->sd, true, &subjcont, IoGetFileObjectGenericMapping(), PagedPool);
 
     if (!NT_SUCCESS(Status)) {
         reap_fcb(fcb);
@@ -826,7 +786,7 @@ static NTSTATUS create_directory_fcb(device_extension* Vcb, root* r, fcb* parfcb
     if (!NT_SUCCESS(Status)) {
         ERR("RtlGetOwnerSecurityDescriptor returned %08x\n", Status);
         fcb->inode_item.st_uid = UID_NOBODY;
-        fcb->sd_dirty = TRUE;
+        fcb->sd_dirty = true;
     } else {
         fcb->inode_item.st_uid = sid_to_uid(owner);
         fcb->sd_dirty = fcb->inode_item.st_uid == UID_NOBODY;
@@ -834,14 +794,14 @@ static NTSTATUS create_directory_fcb(device_extension* Vcb, root* r, fcb* parfcb
 
     find_gid(fcb, parfcb, &subjcont);
 
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
 
     fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
     fcb->Header.AllocationSize.QuadPart = 0;
     fcb->Header.FileSize.QuadPart = 0;
     fcb->Header.ValidDataLength.QuadPart = 0;
 
-    fcb->created = TRUE;
+    fcb->created = true;
 
     if (parfcb->inode_item.flags & BTRFS_INODE_COMPRESS)
         fcb->inode_item.flags |= BTRFS_INODE_COMPRESS;
@@ -917,7 +877,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
     while (le != &move_list) {
         me = CONTAINING_RECORD(le, move_entry, list_entry);
 
-        ExAcquireResourceSharedLite(me->fileref->fcb->Header.Resource, TRUE);
+        ExAcquireResourceSharedLite(me->fileref->fcb->Header.Resource, true);
 
         if (!me->fileref->fcb->ads && me->fileref->fcb->subvol == origparent->fcb->subvol) {
             Status = add_children_to_move_list(fileref->fcb->Vcb, me, Irp);
@@ -944,10 +904,10 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
         if (me->fileref->fcb->inode != SUBVOL_ROOT_INODE && me->fileref->fcb != fileref->fcb->Vcb->dummy_fcb) {
             if (!me->dummyfcb) {
                 ULONG defda;
-                BOOL inserted = FALSE;
+                bool inserted = false;
                 LIST_ENTRY* le3;
 
-                ExAcquireResourceExclusiveLite(me->fileref->fcb->Header.Resource, TRUE);
+                ExAcquireResourceExclusiveLite(me->fileref->fcb->Header.Resource, true);
 
                 Status = duplicate_fcb(me->fileref->fcb, &me->dummyfcb);
                 if (!NT_SUCCESS(Status)) {
@@ -981,7 +941,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
 
                     defda = get_file_attributes(me->fileref->fcb->Vcb, me->fileref->fcb->subvol, me->fileref->fcb->inode,
                                                 me->fileref->fcb->type, me->fileref->dc && me->fileref->dc->name.Length >= sizeof(WCHAR) && me->fileref->dc->name.Buffer[0] == '.',
-                                                TRUE, Irp);
+                                                true, Irp);
 
                     me->fileref->fcb->sd_dirty = !!me->fileref->fcb->sd;
                     me->fileref->fcb->atts_changed = defda != me->fileref->fcb->atts;
@@ -989,13 +949,13 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
                     me->fileref->fcb->reparse_xattr_changed = !!me->fileref->fcb->reparse_xattr.Buffer;
                     me->fileref->fcb->ea_changed = !!me->fileref->fcb->ea_xattr.Buffer;
                     me->fileref->fcb->xattrs_changed = !IsListEmpty(&me->fileref->fcb->xattrs);
-                    me->fileref->fcb->inode_item_changed = TRUE;
+                    me->fileref->fcb->inode_item_changed = true;
 
                     le2 = me->fileref->fcb->xattrs.Flink;
                     while (le2 != &me->fileref->fcb->xattrs) {
                         xattr* xa = CONTAINING_RECORD(le2, xattr, list_entry);
 
-                        xa->dirty = TRUE;
+                        xa->dirty = true;
 
                         le2 = le2->Flink;
                     }
@@ -1019,10 +979,10 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
                                 chunk* c = get_chunk_from_address(me->fileref->fcb->Vcb, ed2->address);
 
                                 if (!c) {
-                                    ERR("get_chunk_from_address(%llx) failed\n", ed2->address);
+                                    ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
                                 } else {
                                     Status = update_changed_extent_ref(me->fileref->fcb->Vcb, c, ed2->address, ed2->size, me->fileref->fcb->subvol->id, me->fileref->fcb->inode,
-                                                                       ext->offset - ed2->offset, 1, me->fileref->fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, Irp);
+                                                                       ext->offset - ed2->offset, 1, me->fileref->fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
 
                                     if (!NT_SUCCESS(Status)) {
                                         ERR("update_changed_extent_ref returned %08x\n", Status);
@@ -1041,7 +1001,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
                     me->fileref->fcb->inode = me->parent->fileref->fcb->inode;
                 }
 
-                me->fileref->fcb->created = TRUE;
+                me->fileref->fcb->created = true;
 
                 InsertHeadList(&me->fileref->fcb->list_entry, &me->dummyfcb->list_entry);
                 RemoveEntryList(&me->fileref->fcb->list_entry);
@@ -1052,7 +1012,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
 
                     if (fcb->inode > me->fileref->fcb->inode) {
                         InsertHeadList(le3->Blink, &me->fileref->fcb->list_entry);
-                        inserted = TRUE;
+                        inserted = true;
                         break;
                     }
 
@@ -1076,7 +1036,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
                     ExFreePool(hl);
                 }
 
-                me->fileref->fcb->inode_item_changed = TRUE;
+                me->fileref->fcb->inode_item_changed = true;
                 mark_fcb_dirty(me->fileref->fcb);
 
                 if ((!me->dummyfcb->ads && me->dummyfcb->inode_item.st_nlink > 1) || (me->dummyfcb->ads && me->parent->dummyfcb->inode_item.st_nlink > 1)) {
@@ -1096,9 +1056,9 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
 
                 ExReleaseResourceLite(me->fileref->fcb->Header.Resource);
             } else {
-                ExAcquireResourceExclusiveLite(me->fileref->fcb->Header.Resource, TRUE);
+                ExAcquireResourceExclusiveLite(me->fileref->fcb->Header.Resource, true);
                 me->fileref->fcb->inode_item.st_nlink++;
-                me->fileref->fcb->inode_item_changed = TRUE;
+                me->fileref->fcb->inode_item_changed = true;
                 ExReleaseResourceLite(me->fileref->fcb->Header.Resource);
             }
         }
@@ -1114,7 +1074,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
     le = move_list.Flink;
     while (le != &move_list) {
         hardlink* hl;
-        BOOL name_changed = FALSE;
+        bool name_changed = false;
 
         me = CONTAINING_RECORD(le, move_entry, list_entry);
 
@@ -1151,7 +1111,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
         me->dummyfileref->oldindex = me->fileref->dc->index;
 
         if (le == move_list.Flink && (me->fileref->dc->utf8.Length != utf8->Length || RtlCompareMemory(me->fileref->dc->utf8.Buffer, utf8->Buffer, utf8->Length) != utf8->Length))
-            name_changed = TRUE;
+            name_changed = true;
 
         if ((le == move_list.Flink || me->fileref->fcb->inode == SUBVOL_ROOT_INODE) && !me->dummyfileref->oldutf8.Buffer) {
             me->dummyfileref->oldutf8.Buffer = ExAllocatePoolWithTag(PagedPool, me->fileref->dc->utf8.Length, ALLOC_TAG);
@@ -1170,12 +1130,12 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
         me->dummyfileref->deleted = me->fileref->deleted;
 
         me->dummyfileref->created = me->fileref->created;
-        me->fileref->created = TRUE;
+        me->fileref->created = true;
 
         me->dummyfileref->parent = me->parent ? me->parent->dummyfileref : origparent;
         increase_fileref_refcount(me->dummyfileref->parent);
 
-        ExAcquireResourceExclusiveLite(&me->dummyfileref->parent->fcb->nonpaged->dir_children_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&me->dummyfileref->parent->fcb->nonpaged->dir_children_lock, true);
         InsertTailList(&me->dummyfileref->parent->children, &me->dummyfileref->list_entry);
         ExReleaseResourceLite(&me->dummyfileref->parent->fcb->nonpaged->dir_children_lock);
 
@@ -1191,7 +1151,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
 
             if (me->fileref->dc) {
                 // remove from old parent
-                ExAcquireResourceExclusiveLite(&me->fileref->parent->fcb->nonpaged->dir_children_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&me->fileref->parent->fcb->nonpaged->dir_children_lock, true);
                 RemoveEntryList(&me->fileref->dc->list_entry_index);
                 remove_dir_child_from_hash_lists(me->fileref->parent->fcb, me->fileref->dc);
                 ExReleaseResourceLite(&me->fileref->parent->fcb->nonpaged->dir_children_lock);
@@ -1201,7 +1161,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
                 me->fileref->parent->fcb->inode_item.sequence++;
                 me->fileref->parent->fcb->inode_item.st_ctime = now;
                 me->fileref->parent->fcb->inode_item.st_mtime = now;
-                me->fileref->parent->fcb->inode_item_changed = TRUE;
+                me->fileref->parent->fcb->inode_item_changed = true;
                 mark_fcb_dirty(me->fileref->parent->fcb);
 
                 if (name_changed) {
@@ -1229,14 +1189,14 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
                     me->fileref->dc->name.Length = me->fileref->dc->name.MaximumLength = fnus->Length;
                     RtlCopyMemory(me->fileref->dc->name.Buffer, fnus->Buffer, fnus->Length);
 
-                    Status = RtlUpcaseUnicodeString(&fileref->dc->name_uc, &fileref->dc->name, TRUE);
+                    Status = RtlUpcaseUnicodeString(&fileref->dc->name_uc, &fileref->dc->name, true);
                     if (!NT_SUCCESS(Status)) {
                         ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
                         goto end;
                     }
 
-                    me->fileref->dc->hash = calc_crc32c(0xffffffff, (UINT8*)me->fileref->dc->name.Buffer, me->fileref->dc->name.Length);
-                    me->fileref->dc->hash_uc = calc_crc32c(0xffffffff, (UINT8*)me->fileref->dc->name_uc.Buffer, me->fileref->dc->name_uc.Length);
+                    me->fileref->dc->hash = calc_crc32c(0xffffffff, (uint8_t*)me->fileref->dc->name.Buffer, me->fileref->dc->name.Length);
+                    me->fileref->dc->hash_uc = calc_crc32c(0xffffffff, (uint8_t*)me->fileref->dc->name_uc.Buffer, me->fileref->dc->name_uc.Length);
                 }
 
                 if (me->fileref->dc->key.obj_type == TYPE_INODE_ITEM)
@@ -1244,7 +1204,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
 
                 // add to new parent
 
-                ExAcquireResourceExclusiveLite(&destdir->fcb->nonpaged->dir_children_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&destdir->fcb->nonpaged->dir_children_lock, true);
 
                 if (IsListEmpty(&destdir->fcb->dir_children_index))
                     me->fileref->dc->index = 2;
@@ -1262,22 +1222,22 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
             free_fileref(me->fileref->parent);
             me->fileref->parent = destdir;
 
-            ExAcquireResourceExclusiveLite(&me->fileref->parent->fcb->nonpaged->dir_children_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&me->fileref->parent->fcb->nonpaged->dir_children_lock, true);
             InsertTailList(&me->fileref->parent->children, &me->fileref->list_entry);
             ExReleaseResourceLite(&me->fileref->parent->fcb->nonpaged->dir_children_lock);
 
-            TRACE("me->fileref->parent->fcb->inode_item.st_size (inode %llx) was %llx\n", me->fileref->parent->fcb->inode, me->fileref->parent->fcb->inode_item.st_size);
+            TRACE("me->fileref->parent->fcb->inode_item.st_size (inode %I64x) was %I64x\n", me->fileref->parent->fcb->inode, me->fileref->parent->fcb->inode_item.st_size);
             me->fileref->parent->fcb->inode_item.st_size += me->fileref->dc->utf8.Length * 2;
-            TRACE("me->fileref->parent->fcb->inode_item.st_size (inode %llx) now %llx\n", me->fileref->parent->fcb->inode, me->fileref->parent->fcb->inode_item.st_size);
+            TRACE("me->fileref->parent->fcb->inode_item.st_size (inode %I64x) now %I64x\n", me->fileref->parent->fcb->inode, me->fileref->parent->fcb->inode_item.st_size);
             me->fileref->parent->fcb->inode_item.transid = me->fileref->fcb->Vcb->superblock.generation;
             me->fileref->parent->fcb->inode_item.sequence++;
             me->fileref->parent->fcb->inode_item.st_ctime = now;
             me->fileref->parent->fcb->inode_item.st_mtime = now;
-            me->fileref->parent->fcb->inode_item_changed = TRUE;
+            me->fileref->parent->fcb->inode_item_changed = true;
             mark_fcb_dirty(me->fileref->parent->fcb);
         } else {
             if (me->fileref->dc) {
-                ExAcquireResourceExclusiveLite(&me->fileref->parent->fcb->nonpaged->dir_children_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&me->fileref->parent->fcb->nonpaged->dir_children_lock, true);
                 RemoveEntryList(&me->fileref->dc->list_entry_index);
 
                 if (!me->fileref->fcb->ads)
@@ -1285,7 +1245,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
 
                 ExReleaseResourceLite(&me->fileref->parent->fcb->nonpaged->dir_children_lock);
 
-                ExAcquireResourceExclusiveLite(&me->parent->fileref->fcb->nonpaged->dir_children_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&me->parent->fileref->fcb->nonpaged->dir_children_lock, true);
 
                 if (me->fileref->fcb->ads)
                     InsertHeadList(&me->parent->fileref->fcb->dir_children_index, &me->fileref->dc->list_entry_index);
@@ -1310,7 +1270,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
         }
 
         if (!me->dummyfileref->fcb->ads) {
-            Status = delete_fileref(me->dummyfileref, NULL, FALSE, Irp, rollback);
+            Status = delete_fileref(me->dummyfileref, NULL, false, Irp, rollback);
             if (!NT_SUCCESS(Status)) {
                 ERR("delete_fileref returned %08x\n", Status);
                 goto end;
@@ -1366,7 +1326,7 @@ static NTSTATUS move_across_subvols(file_ref* fileref, ccb* ccb, file_ref* destd
         me = CONTAINING_RECORD(le, move_entry, list_entry);
 
         if (me->dummyfileref->fcb->ads && me->parent->dummyfileref->fcb->deleted) {
-            Status = delete_fileref(me->dummyfileref, NULL, FALSE, Irp, rollback);
+            Status = delete_fileref(me->dummyfileref, NULL, false, Irp, rollback);
             if (!NT_SUCCESS(Status)) {
                 ERR("delete_fileref returned %08x\n", Status);
                 goto end;
@@ -1411,13 +1371,13 @@ end:
 }
 
 void insert_dir_child_into_hash_lists(fcb* fcb, dir_child* dc) {
-    BOOL inserted;
+    bool inserted;
     LIST_ENTRY* le;
-    UINT8 c, d;
+    uint8_t c, d;
 
     c = dc->hash >> 24;
 
-    inserted = FALSE;
+    inserted = false;
 
     d = c;
     do {
@@ -1437,7 +1397,7 @@ void insert_dir_child_into_hash_lists(fcb* fcb, dir_child* dc) {
 
         if (dc2->hash > dc->hash) {
             InsertHeadList(le->Blink, &dc->list_entry_hash);
-            inserted = TRUE;
+            inserted = true;
             break;
         }
 
@@ -1458,7 +1418,7 @@ void insert_dir_child_into_hash_lists(fcb* fcb, dir_child* dc) {
 
     c = dc->hash_uc >> 24;
 
-    inserted = FALSE;
+    inserted = false;
 
     d = c;
     do {
@@ -1478,7 +1438,7 @@ void insert_dir_child_into_hash_lists(fcb* fcb, dir_child* dc) {
 
         if (dc2->hash_uc > dc->hash_uc) {
             InsertHeadList(le->Blink, &dc->list_entry_hash_uc);
-            inserted = TRUE;
+            inserted = true;
             break;
         }
 
@@ -1498,7 +1458,7 @@ void insert_dir_child_into_hash_lists(fcb* fcb, dir_child* dc) {
     }
 }
 
-static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OBJECT FileObject, PFILE_OBJECT tfo, BOOL ex) {
+static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OBJECT FileObject, PFILE_OBJECT tfo, bool ex) {
     FILE_RENAME_INFORMATION_EX* fri = Irp->AssociatedIrp.SystemBuffer;
     fcb *fcb = FileObject->FsContext;
     ccb* ccb = FileObject->FsContext2;
@@ -1554,9 +1514,9 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
         }
     }
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
-    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, TRUE);
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
+    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, true);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (fcb->ads) {
         // MSDN says that NTFS data streams can be renamed (https://msdn.microsoft.com/en-us/library/windows/hardware/ff540344.aspx),
@@ -1567,17 +1527,17 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
     }
 
     fnus.Buffer = fn;
-    fnus.Length = fnus.MaximumLength = (UINT16)(fnlen * sizeof(WCHAR));
+    fnus.Length = fnus.MaximumLength = (uint16_t)(fnlen * sizeof(WCHAR));
 
     TRACE("fnus = %.*S\n", fnus.Length / sizeof(WCHAR), fnus.Buffer);
 
     origutf8len = fileref->dc->utf8.Length;
 
-    Status = RtlUnicodeToUTF8N(NULL, 0, &utf8len, fn, (ULONG)fnlen * sizeof(WCHAR));
+    Status = utf16_to_utf8(NULL, 0, &utf8len, fn, (ULONG)fnlen * sizeof(WCHAR));
     if (!NT_SUCCESS(Status))
         goto end;
 
-    utf8.MaximumLength = utf8.Length = (UINT16)utf8len;
+    utf8.MaximumLength = utf8.Length = (uint16_t)utf8len;
     utf8.Buffer = ExAllocatePoolWithTag(PagedPool, utf8.MaximumLength, ALLOC_TAG);
     if (!utf8.Buffer) {
         ERR("out of memory\n");
@@ -1585,7 +1545,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
         goto end;
     }
 
-    Status = RtlUnicodeToUTF8N(utf8.Buffer, utf8len, &utf8len, fn, (ULONG)fnlen * sizeof(WCHAR));
+    Status = utf16_to_utf8(utf8.Buffer, utf8len, &utf8len, fn, (ULONG)fnlen * sizeof(WCHAR));
     if (!NT_SUCCESS(Status))
         goto end;
 
@@ -1599,7 +1559,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
         increase_fileref_refcount(related);
     }
 
-    Status = open_fileref(Vcb, &oldfileref, &fnus, related, FALSE, NULL, NULL, PagedPool, ccb->case_sensitive,  Irp);
+    Status = open_fileref(Vcb, &oldfileref, &fnus, related, false, NULL, NULL, PagedPool, ccb->case_sensitive,  Irp);
 
     if (NT_SUCCESS(Status)) {
         TRACE("destination file %S already exists\n", file_desc_fileref(oldfileref));
@@ -1633,7 +1593,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
     }
 
     if (!related) {
-        Status = open_fileref(Vcb, &related, &fnus, NULL, TRUE, NULL, NULL, PagedPool, ccb->case_sensitive, Irp);
+        Status = open_fileref(Vcb, &related, &fnus, NULL, true, NULL, NULL, PagedPool, ccb->case_sensitive, Irp);
 
         if (!NT_SUCCESS(Status)) {
             ERR("open_fileref returned %08x\n", Status);
@@ -1648,7 +1608,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
 
     SeCaptureSubjectContext(&subjcont);
 
-    if (!SeAccessCheck(related->fcb->sd, &subjcont, FALSE, fcb->type == BTRFS_TYPE_DIRECTORY ? FILE_ADD_SUBDIRECTORY : FILE_ADD_FILE, 0, NULL,
+    if (!SeAccessCheck(related->fcb->sd, &subjcont, false, fcb->type == BTRFS_TYPE_DIRECTORY ? FILE_ADD_SUBDIRECTORY : FILE_ADD_FILE, 0, NULL,
         IoGetFileObjectGenericMapping(), Irp->RequestorMode, &access, &Status)) {
         SeReleaseSubjectContext(&subjcont);
         TRACE("SeAccessCheck failed, returning %08x\n", Status);
@@ -1666,7 +1626,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
     if (oldfileref) {
         SeCaptureSubjectContext(&subjcont);
 
-        if (!SeAccessCheck(oldfileref->fcb->sd, &subjcont, FALSE, DELETE, 0, NULL,
+        if (!SeAccessCheck(oldfileref->fcb->sd, &subjcont, false, DELETE, 0, NULL,
                            IoGetFileObjectGenericMapping(), Irp->RequestorMode, &access, &Status)) {
             SeReleaseSubjectContext(&subjcont);
             TRACE("SeAccessCheck failed, returning %08x\n", Status);
@@ -1676,8 +1636,8 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
         SeReleaseSubjectContext(&subjcont);
 
         if (oldfileref->open_count > 0 && flags & FILE_RENAME_POSIX_SEMANTICS) {
-            oldfileref->delete_on_close = TRUE;
-            oldfileref->posix_delete = TRUE;
+            oldfileref->delete_on_close = true;
+            oldfileref->posix_delete = true;
         }
 
         Status = delete_fileref(oldfileref, NULL, oldfileref->open_count > 0 && flags & FILE_RENAME_POSIX_SEMANTICS, Irp, &rollback);
@@ -1715,7 +1675,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
             goto end;
         }
 
-        oldfn.MaximumLength = (UINT16)reqlen;
+        oldfn.MaximumLength = (uint16_t)reqlen;
 
         Status = fileref_get_filename(fileref, &oldfn, &name_offset, &reqlen);
         if (!NT_SUCCESS(Status)) {
@@ -1743,7 +1703,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
         mark_fileref_dirty(fileref);
 
         if (fileref->dc) {
-            ExAcquireResourceExclusiveLite(&fileref->parent->fcb->nonpaged->dir_children_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&fileref->parent->fcb->nonpaged->dir_children_lock, true);
 
             ExFreePool(fileref->dc->utf8.Buffer);
             ExFreePool(fileref->dc->name.Buffer);
@@ -1773,7 +1733,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
             fileref->dc->name.Length = fileref->dc->name.MaximumLength = fnus.Length;
             RtlCopyMemory(fileref->dc->name.Buffer, fnus.Buffer, fnus.Length);
 
-            Status = RtlUpcaseUnicodeString(&fileref->dc->name_uc, &fileref->dc->name, TRUE);
+            Status = RtlUpcaseUnicodeString(&fileref->dc->name_uc, &fileref->dc->name, true);
             if (!NT_SUCCESS(Status)) {
                 ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
                 ExReleaseResourceLite(&fileref->parent->fcb->nonpaged->dir_children_lock);
@@ -1783,8 +1743,8 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
 
             remove_dir_child_from_hash_lists(fileref->parent->fcb, fileref->dc);
 
-            fileref->dc->hash = calc_crc32c(0xffffffff, (UINT8*)fileref->dc->name.Buffer, fileref->dc->name.Length);
-            fileref->dc->hash_uc = calc_crc32c(0xffffffff, (UINT8*)fileref->dc->name_uc.Buffer, fileref->dc->name_uc.Length);
+            fileref->dc->hash = calc_crc32c(0xffffffff, (uint8_t*)fileref->dc->name.Buffer, fileref->dc->name.Length);
+            fileref->dc->hash_uc = calc_crc32c(0xffffffff, (uint8_t*)fileref->dc->name_uc.Buffer, fileref->dc->name_uc.Length);
 
             insert_dir_child_into_hash_lists(fileref->parent->fcb, fileref->dc);
 
@@ -1808,7 +1768,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
             goto end;
         }
 
-        newfn.MaximumLength = (UINT16)reqlen;
+        newfn.MaximumLength = (uint16_t)reqlen;
 
         Status = fileref_get_filename(fileref, &newfn, &name_offset, &reqlen);
         if (!NT_SUCCESS(Status)) {
@@ -1828,21 +1788,21 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
             if (!ccb->user_set_change_time)
                 fcb->inode_item.st_ctime = now;
 
-            fcb->inode_item_changed = TRUE;
+            fcb->inode_item_changed = true;
             mark_fcb_dirty(fcb);
         }
 
         // update parent's INODE_ITEM
 
         related->fcb->inode_item.transid = Vcb->superblock.generation;
-        TRACE("related->fcb->inode_item.st_size (inode %llx) was %llx\n", related->fcb->inode, related->fcb->inode_item.st_size);
+        TRACE("related->fcb->inode_item.st_size (inode %I64x) was %I64x\n", related->fcb->inode, related->fcb->inode_item.st_size);
         related->fcb->inode_item.st_size = related->fcb->inode_item.st_size + (2 * utf8.Length) - (2* oldutf8len);
-        TRACE("related->fcb->inode_item.st_size (inode %llx) now %llx\n", related->fcb->inode, related->fcb->inode_item.st_size);
+        TRACE("related->fcb->inode_item.st_size (inode %I64x) now %I64x\n", related->fcb->inode, related->fcb->inode_item.st_size);
         related->fcb->inode_item.sequence++;
         related->fcb->inode_item.st_ctime = now;
         related->fcb->inode_item.st_mtime = now;
 
-        related->fcb->inode_item_changed = TRUE;
+        related->fcb->inode_item_changed = true;
         mark_fcb_dirty(related->fcb);
         send_notification_fileref(related, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_ACTION_MODIFIED, NULL);
 
@@ -1871,7 +1831,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
     fr2->oldutf8 = fileref->oldutf8;
     fr2->oldindex = fileref->dc->index;
     fr2->delete_on_close = fileref->delete_on_close;
-    fr2->deleted = TRUE;
+    fr2->deleted = true;
     fr2->created = fileref->created;
     fr2->parent = fileref->parent;
     fr2->dc = NULL;
@@ -1897,11 +1857,11 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
 
     fileref->oldutf8.Length = fileref->oldutf8.MaximumLength = 0;
     fileref->oldutf8.Buffer = NULL;
-    fileref->deleted = FALSE;
-    fileref->created = TRUE;
+    fileref->deleted = false;
+    fileref->created = true;
     fileref->parent = related;
 
-    ExAcquireResourceExclusiveLite(&fileref->parent->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&fileref->parent->fcb->nonpaged->dir_children_lock, true);
     InsertHeadList(&fileref->list_entry, &fr2->list_entry);
     RemoveEntryList(&fileref->list_entry);
     ExReleaseResourceLite(&fileref->parent->fcb->nonpaged->dir_children_lock);
@@ -1911,7 +1871,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
 
     if (fileref->dc) {
         // remove from old parent
-        ExAcquireResourceExclusiveLite(&fr2->parent->fcb->nonpaged->dir_children_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&fr2->parent->fcb->nonpaged->dir_children_lock, true);
         RemoveEntryList(&fileref->dc->list_entry_index);
         remove_dir_child_from_hash_lists(fr2->parent->fcb, fileref->dc);
         ExReleaseResourceLite(&fr2->parent->fcb->nonpaged->dir_children_lock);
@@ -1943,18 +1903,18 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
             fileref->dc->name.Length = fileref->dc->name.MaximumLength = fnus.Length;
             RtlCopyMemory(fileref->dc->name.Buffer, fnus.Buffer, fnus.Length);
 
-            Status = RtlUpcaseUnicodeString(&fileref->dc->name_uc, &fileref->dc->name, TRUE);
+            Status = RtlUpcaseUnicodeString(&fileref->dc->name_uc, &fileref->dc->name, true);
             if (!NT_SUCCESS(Status)) {
                 ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
                 goto end;
             }
 
-            fileref->dc->hash = calc_crc32c(0xffffffff, (UINT8*)fileref->dc->name.Buffer, fileref->dc->name.Length);
-            fileref->dc->hash_uc = calc_crc32c(0xffffffff, (UINT8*)fileref->dc->name_uc.Buffer, fileref->dc->name_uc.Length);
+            fileref->dc->hash = calc_crc32c(0xffffffff, (uint8_t*)fileref->dc->name.Buffer, fileref->dc->name.Length);
+            fileref->dc->hash_uc = calc_crc32c(0xffffffff, (uint8_t*)fileref->dc->name_uc.Buffer, fileref->dc->name_uc.Length);
         }
 
         // add to new parent
-        ExAcquireResourceExclusiveLite(&related->fcb->nonpaged->dir_children_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&related->fcb->nonpaged->dir_children_lock, true);
 
         if (IsListEmpty(&related->fcb->dir_children_index))
             fileref->dc->index = 2;
@@ -1969,7 +1929,7 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
         ExReleaseResourceLite(&related->fcb->nonpaged->dir_children_lock);
     }
 
-    ExAcquireResourceExclusiveLite(&related->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&related->fcb->nonpaged->dir_children_lock, true);
     InsertTailList(&related->children, &fileref->list_entry);
     ExReleaseResourceLite(&related->fcb->nonpaged->dir_children_lock);
 
@@ -2048,36 +2008,36 @@ static NTSTATUS set_rename_information(device_extension* Vcb, PIRP Irp, PFILE_OB
         if (!ccb->user_set_change_time)
             fcb->inode_item.st_ctime = now;
 
-        fcb->inode_item_changed = TRUE;
+        fcb->inode_item_changed = true;
         mark_fcb_dirty(fcb);
     }
 
     // update new parent's INODE_ITEM
 
     related->fcb->inode_item.transid = Vcb->superblock.generation;
-    TRACE("related->fcb->inode_item.st_size (inode %llx) was %llx\n", related->fcb->inode, related->fcb->inode_item.st_size);
+    TRACE("related->fcb->inode_item.st_size (inode %I64x) was %I64x\n", related->fcb->inode, related->fcb->inode_item.st_size);
     related->fcb->inode_item.st_size += 2 * utf8len;
-    TRACE("related->fcb->inode_item.st_size (inode %llx) now %llx\n", related->fcb->inode, related->fcb->inode_item.st_size);
+    TRACE("related->fcb->inode_item.st_size (inode %I64x) now %I64x\n", related->fcb->inode, related->fcb->inode_item.st_size);
     related->fcb->inode_item.sequence++;
     related->fcb->inode_item.st_ctime = now;
     related->fcb->inode_item.st_mtime = now;
 
-    related->fcb->inode_item_changed = TRUE;
+    related->fcb->inode_item_changed = true;
     mark_fcb_dirty(related->fcb);
 
     // update old parent's INODE_ITEM
 
     fr2->parent->fcb->inode_item.transid = Vcb->superblock.generation;
-    TRACE("fr2->parent->fcb->inode_item.st_size (inode %llx) was %llx\n", fr2->parent->fcb->inode, fr2->parent->fcb->inode_item.st_size);
+    TRACE("fr2->parent->fcb->inode_item.st_size (inode %I64x) was %I64x\n", fr2->parent->fcb->inode, fr2->parent->fcb->inode_item.st_size);
     fr2->parent->fcb->inode_item.st_size -= 2 * origutf8len;
-    TRACE("fr2->parent->fcb->inode_item.st_size (inode %llx) now %llx\n", fr2->parent->fcb->inode, fr2->parent->fcb->inode_item.st_size);
+    TRACE("fr2->parent->fcb->inode_item.st_size (inode %I64x) now %I64x\n", fr2->parent->fcb->inode, fr2->parent->fcb->inode_item.st_size);
     fr2->parent->fcb->inode_item.sequence++;
     fr2->parent->fcb->inode_item.st_ctime = now;
     fr2->parent->fcb->inode_item.st_mtime = now;
 
     free_fileref(fr2);
 
-    fr2->parent->fcb->inode_item_changed = TRUE;
+    fr2->parent->fcb->inode_item_changed = true;
     mark_fcb_dirty(fr2->parent->fcb);
 
     send_notification_fileref(fileref, fcb->type == BTRFS_TYPE_DIRECTORY ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME, FILE_ACTION_ADDED, NULL);
@@ -2108,11 +2068,11 @@ end:
     return Status;
 }
 
-NTSTATUS stream_set_end_of_file_information(device_extension* Vcb, UINT16 end, fcb* fcb, file_ref* fileref, BOOL advance_only) {
+NTSTATUS stream_set_end_of_file_information(device_extension* Vcb, uint16_t end, fcb* fcb, file_ref* fileref, bool advance_only) {
     LARGE_INTEGER time;
     BTRFS_TIME now;
 
-    TRACE("setting new end to %llx bytes (currently %x)\n", end, fcb->adsdata.Length);
+    TRACE("setting new end to %I64x bytes (currently %x)\n", end, fcb->adsdata.Length);
 
     if (!fileref || !fileref->parent) {
         ERR("no fileref for stream\n");
@@ -2123,11 +2083,11 @@ NTSTATUS stream_set_end_of_file_information(device_extension* Vcb, UINT16 end, f
         if (advance_only)
             return STATUS_SUCCESS;
 
-        TRACE("truncating stream to %llx bytes\n", end);
+        TRACE("truncating stream to %I64x bytes\n", end);
 
         fcb->adsdata.Length = end;
     } else if (end > fcb->adsdata.Length) {
-        TRACE("extending stream to %llx bytes\n", end);
+        TRACE("extending stream to %I64x bytes\n", end);
 
         if (end > fcb->adsmaxlen) {
             ERR("error - xattr too long (%u > %u)\n", end, fcb->adsmaxlen);
@@ -2169,7 +2129,7 @@ NTSTATUS stream_set_end_of_file_information(device_extension* Vcb, UINT16 end, f
     fileref->parent->fcb->inode_item.sequence++;
     fileref->parent->fcb->inode_item.st_ctime = now;
 
-    fileref->parent->fcb->inode_item_changed = TRUE;
+    fileref->parent->fcb->inode_item_changed = true;
     mark_fcb_dirty(fileref->parent->fcb);
 
     fileref->parent->fcb->subvol->root_item.ctransid = Vcb->superblock.generation;
@@ -2178,7 +2138,7 @@ NTSTATUS stream_set_end_of_file_information(device_extension* Vcb, UINT16 end, f
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS set_end_of_file_information(device_extension* Vcb, PIRP Irp, PFILE_OBJECT FileObject, BOOL advance_only, BOOL prealloc) {
+static NTSTATUS set_end_of_file_information(device_extension* Vcb, PIRP Irp, PFILE_OBJECT FileObject, bool advance_only, bool prealloc) {
     FILE_END_OF_FILE_INFORMATION* feofi = Irp->AssociatedIrp.SystemBuffer;
     fcb* fcb = FileObject->FsContext;
     ccb* ccb = FileObject->FsContext2;
@@ -2187,7 +2147,7 @@ static NTSTATUS set_end_of_file_information(device_extension* Vcb, PIRP Irp, PFI
     LARGE_INTEGER time;
     CC_FILE_SIZES ccfs;
     LIST_ENTRY rollback;
-    BOOL set_size = FALSE;
+    bool set_size = false;
     ULONG filter;
 
     if (!fileref) {
@@ -2197,9 +2157,9 @@ static NTSTATUS set_end_of_file_information(device_extension* Vcb, PIRP Irp, PFI
 
     InitializeListHead(&rollback);
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (fileref ? fileref->deleted : fcb->deleted) {
         Status = STATUS_FILE_CLOSED;
@@ -2217,13 +2177,13 @@ static NTSTATUS set_end_of_file_information(device_extension* Vcb, PIRP Irp, PFI
             goto end;
         }
 
-        Status = stream_set_end_of_file_information(Vcb, (UINT16)feofi->EndOfFile.QuadPart, fcb, fileref, advance_only);
+        Status = stream_set_end_of_file_information(Vcb, (uint16_t)feofi->EndOfFile.QuadPart, fcb, fileref, advance_only);
 
         if (NT_SUCCESS(Status)) {
             ccfs.AllocationSize = fcb->Header.AllocationSize;
             ccfs.FileSize = fcb->Header.FileSize;
             ccfs.ValidDataLength = fcb->Header.ValidDataLength;
-            set_size = TRUE;
+            set_size = true;
         }
 
         filter = FILE_NOTIFY_CHANGE_STREAM_SIZE;
@@ -2233,7 +2193,7 @@ static NTSTATUS set_end_of_file_information(device_extension* Vcb, PIRP Irp, PFI
             win_time_to_unix(time, &fileref->parent->fcb->inode_item.st_mtime);
             filter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
 
-            fileref->parent->fcb->inode_item_changed = TRUE;
+            fileref->parent->fcb->inode_item_changed = true;
             mark_fcb_dirty(fileref->parent->fcb);
         }
 
@@ -2243,19 +2203,19 @@ static NTSTATUS set_end_of_file_information(device_extension* Vcb, PIRP Irp, PFI
     }
 
     TRACE("file: %S\n", file_desc(FileObject));
-    TRACE("paging IO: %s\n", Irp->Flags & IRP_PAGING_IO ? "TRUE" : "FALSE");
-    TRACE("FileObject: AllocationSize = %llx, FileSize = %llx, ValidDataLength = %llx\n",
+    TRACE("paging IO: %s\n", Irp->Flags & IRP_PAGING_IO ? "true" : "false");
+    TRACE("FileObject: AllocationSize = %I64x, FileSize = %I64x, ValidDataLength = %I64x\n",
         fcb->Header.AllocationSize.QuadPart, fcb->Header.FileSize.QuadPart, fcb->Header.ValidDataLength.QuadPart);
 
-    TRACE("setting new end to %llx bytes (currently %llx)\n", feofi->EndOfFile.QuadPart, fcb->inode_item.st_size);
+    TRACE("setting new end to %I64x bytes (currently %I64x)\n", feofi->EndOfFile.QuadPart, fcb->inode_item.st_size);
 
-    if ((UINT64)feofi->EndOfFile.QuadPart < fcb->inode_item.st_size) {
+    if ((uint64_t)feofi->EndOfFile.QuadPart < fcb->inode_item.st_size) {
         if (advance_only) {
             Status = STATUS_SUCCESS;
             goto end;
         }
 
-        TRACE("truncating file to %llx bytes\n", feofi->EndOfFile.QuadPart);
+        TRACE("truncating file to %I64x bytes\n", feofi->EndOfFile.QuadPart);
 
         if (!MmCanFileBeTruncated(&fcb->nonpaged->segment_object, &feofi->EndOfFile)) {
             Status = STATUS_USER_MAPPED_FILE;
@@ -2267,21 +2227,21 @@ static NTSTATUS set_end_of_file_information(device_extension* Vcb, PIRP Irp, PFI
             ERR("error - truncate_file failed\n");
             goto end;
         }
-    } else if ((UINT64)feofi->EndOfFile.QuadPart > fcb->inode_item.st_size) {
+    } else if ((uint64_t)feofi->EndOfFile.QuadPart > fcb->inode_item.st_size) {
         if (Irp->Flags & IRP_PAGING_IO) {
             TRACE("paging IO tried to extend file size\n");
             Status = STATUS_SUCCESS;
             goto end;
         }
 
-        TRACE("extending file to %llx bytes\n", feofi->EndOfFile.QuadPart);
+        TRACE("extending file to %I64x bytes\n", feofi->EndOfFile.QuadPart);
 
         Status = extend_file(fcb, fileref, feofi->EndOfFile.QuadPart, prealloc, NULL, &rollback);
         if (!NT_SUCCESS(Status)) {
             ERR("error - extend_file failed\n");
             goto end;
         }
-    } else if ((UINT64)feofi->EndOfFile.QuadPart == fcb->inode_item.st_size && advance_only) {
+    } else if ((uint64_t)feofi->EndOfFile.QuadPart == fcb->inode_item.st_size && advance_only) {
         Status = STATUS_SUCCESS;
         goto end;
     }
@@ -2289,7 +2249,7 @@ static NTSTATUS set_end_of_file_information(device_extension* Vcb, PIRP Irp, PFI
     ccfs.AllocationSize = fcb->Header.AllocationSize;
     ccfs.FileSize = fcb->Header.FileSize;
     ccfs.ValidDataLength = fcb->Header.ValidDataLength;
-    set_size = TRUE;
+    set_size = true;
 
     filter = FILE_NOTIFY_CHANGE_SIZE;
 
@@ -2299,7 +2259,7 @@ static NTSTATUS set_end_of_file_information(device_extension* Vcb, PIRP Irp, PFI
         filter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
     }
 
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
     mark_fcb_dirty(fcb);
     send_notification_fcb(fileref, filter, FILE_ACTION_MODIFIED, NULL);
 
@@ -2332,7 +2292,7 @@ end:
 static NTSTATUS set_position_information(PFILE_OBJECT FileObject, PIRP Irp) {
     FILE_POSITION_INFORMATION* fpi = (FILE_POSITION_INFORMATION*)Irp->AssociatedIrp.SystemBuffer;
 
-    TRACE("setting the position on %S to %llx\n", file_desc(FileObject), fpi->CurrentByteOffset.QuadPart);
+    TRACE("setting the position on %S to %I64x\n", file_desc(FileObject), fpi->CurrentByteOffset.QuadPart);
 
     // FIXME - make sure aligned for FO_NO_INTERMEDIATE_BUFFERING
 
@@ -2341,7 +2301,7 @@ static NTSTATUS set_position_information(PFILE_OBJECT FileObject, PIRP Irp) {
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJECT FileObject, PFILE_OBJECT tfo, BOOL ex) {
+static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJECT FileObject, PFILE_OBJECT tfo, bool ex) {
     FILE_LINK_INFORMATION_EX* fli = Irp->AssociatedIrp.SystemBuffer;
     fcb *fcb = FileObject->FsContext, *tfofcb, *parfcb;
     ccb* ccb = FileObject->FsContext2;
@@ -2407,9 +2367,9 @@ static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJE
         }
     }
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
-    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, TRUE);
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
+    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, true);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (fcb->type == BTRFS_TYPE_DIRECTORY) {
         WARN("tried to create hard link on directory\n");
@@ -2429,15 +2389,15 @@ static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJE
     }
 
     fnus.Buffer = fn;
-    fnus.Length = fnus.MaximumLength = (UINT16)(fnlen * sizeof(WCHAR));
+    fnus.Length = fnus.MaximumLength = (uint16_t)(fnlen * sizeof(WCHAR));
 
     TRACE("fnus = %.*S\n", fnus.Length / sizeof(WCHAR), fnus.Buffer);
 
-    Status = RtlUnicodeToUTF8N(NULL, 0, &utf8len, fn, (ULONG)fnlen * sizeof(WCHAR));
+    Status = utf16_to_utf8(NULL, 0, &utf8len, fn, (ULONG)fnlen * sizeof(WCHAR));
     if (!NT_SUCCESS(Status))
         goto end;
 
-    utf8.MaximumLength = utf8.Length = (UINT16)utf8len;
+    utf8.MaximumLength = utf8.Length = (uint16_t)utf8len;
     utf8.Buffer = ExAllocatePoolWithTag(PagedPool, utf8.MaximumLength, ALLOC_TAG);
     if (!utf8.Buffer) {
         ERR("out of memory\n");
@@ -2445,7 +2405,7 @@ static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJE
         goto end;
     }
 
-    Status = RtlUnicodeToUTF8N(utf8.Buffer, utf8len, &utf8len, fn, (ULONG)fnlen * sizeof(WCHAR));
+    Status = utf16_to_utf8(utf8.Buffer, utf8len, &utf8len, fn, (ULONG)fnlen * sizeof(WCHAR));
     if (!NT_SUCCESS(Status))
         goto end;
 
@@ -2456,7 +2416,7 @@ static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJE
         increase_fileref_refcount(related);
     }
 
-    Status = open_fileref(Vcb, &oldfileref, &fnus, related, FALSE, NULL, NULL, PagedPool, ccb->case_sensitive, Irp);
+    Status = open_fileref(Vcb, &oldfileref, &fnus, related, false, NULL, NULL, PagedPool, ccb->case_sensitive, Irp);
 
     if (NT_SUCCESS(Status)) {
         if (!oldfileref->deleted) {
@@ -2488,7 +2448,7 @@ static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJE
     }
 
     if (!related) {
-        Status = open_fileref(Vcb, &related, &fnus, NULL, TRUE, NULL, NULL, PagedPool, ccb->case_sensitive, Irp);
+        Status = open_fileref(Vcb, &related, &fnus, NULL, true, NULL, NULL, PagedPool, ccb->case_sensitive, Irp);
 
         if (!NT_SUCCESS(Status)) {
             ERR("open_fileref returned %08x\n", Status);
@@ -2498,7 +2458,7 @@ static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJE
 
     SeCaptureSubjectContext(&subjcont);
 
-    if (!SeAccessCheck(related->fcb->sd, &subjcont, FALSE, FILE_ADD_FILE, 0, NULL,
+    if (!SeAccessCheck(related->fcb->sd, &subjcont, false, FILE_ADD_FILE, 0, NULL,
                        IoGetFileObjectGenericMapping(), Irp->RequestorMode, &access, &Status)) {
         SeReleaseSubjectContext(&subjcont);
         TRACE("SeAccessCheck failed, returning %08x\n", Status);
@@ -2516,7 +2476,7 @@ static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJE
     if (oldfileref) {
         SeCaptureSubjectContext(&subjcont);
 
-        if (!SeAccessCheck(oldfileref->fcb->sd, &subjcont, FALSE, DELETE, 0, NULL,
+        if (!SeAccessCheck(oldfileref->fcb->sd, &subjcont, false, DELETE, 0, NULL,
                            IoGetFileObjectGenericMapping(), Irp->RequestorMode, &access, &Status)) {
             SeReleaseSubjectContext(&subjcont);
             TRACE("SeAccessCheck failed, returning %08x\n", Status);
@@ -2526,8 +2486,8 @@ static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJE
         SeReleaseSubjectContext(&subjcont);
 
         if (oldfileref->open_count > 0 && flags & FILE_RENAME_POSIX_SEMANTICS) {
-            oldfileref->delete_on_close = TRUE;
-            oldfileref->posix_delete = TRUE;
+            oldfileref->delete_on_close = true;
+            oldfileref->posix_delete = true;
         }
 
         Status = delete_fileref(oldfileref, NULL, oldfileref->open_count > 0 && flags & FILE_RENAME_POSIX_SEMANTICS, Irp, &rollback);
@@ -2542,17 +2502,17 @@ static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJE
     fr2->fcb = fcb;
     fcb->refcount++;
 
-    fr2->created = TRUE;
+    fr2->created = true;
     fr2->parent = related;
 
-    Status = add_dir_child(related->fcb, fcb->inode, FALSE, &utf8, &fnus, fcb->type, &dc);
+    Status = add_dir_child(related->fcb, fcb->inode, false, &utf8, &fnus, fcb->type, &dc);
     if (!NT_SUCCESS(Status))
         WARN("add_dir_child returned %08x\n", Status);
 
     fr2->dc = dc;
     dc->fileref = fr2;
 
-    ExAcquireResourceExclusiveLite(&related->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&related->fcb->nonpaged->dir_children_lock, true);
     InsertTailList(&related->children, &fr2->list_entry);
     ExReleaseResourceLite(&related->fcb->nonpaged->dir_children_lock);
 
@@ -2649,19 +2609,19 @@ static NTSTATUS set_link_information(device_extension* Vcb, PIRP Irp, PFILE_OBJE
     if (!ccb->user_set_change_time)
         fcb->inode_item.st_ctime = now;
 
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
     mark_fcb_dirty(fcb);
 
     // update parent's INODE_ITEM
 
     parfcb->inode_item.transid = Vcb->superblock.generation;
-    TRACE("parfcb->inode_item.st_size (inode %llx) was %llx\n", parfcb->inode, parfcb->inode_item.st_size);
+    TRACE("parfcb->inode_item.st_size (inode %I64x) was %I64x\n", parfcb->inode, parfcb->inode_item.st_size);
     parfcb->inode_item.st_size += 2 * utf8len;
-    TRACE("parfcb->inode_item.st_size (inode %llx) now %llx\n", parfcb->inode, parfcb->inode_item.st_size);
+    TRACE("parfcb->inode_item.st_size (inode %I64x) now %I64x\n", parfcb->inode, parfcb->inode_item.st_size);
     parfcb->inode_item.sequence++;
     parfcb->inode_item.st_ctime = now;
 
-    parfcb->inode_item_changed = TRUE;
+    parfcb->inode_item_changed = true;
     mark_fcb_dirty(parfcb);
 
     send_notification_fileref(fr2, FILE_NOTIFY_CHANGE_FILE_NAME, FILE_ACTION_ADDED, NULL);
@@ -2700,7 +2660,7 @@ static NTSTATUS set_valid_data_length_information(device_extension* Vcb, PIRP Ir
     LARGE_INTEGER time;
     CC_FILE_SIZES ccfs;
     LIST_ENTRY rollback;
-    BOOL set_size = FALSE;
+    bool set_size = false;
     ULONG filter;
 
     if (IrpSp->Parameters.SetFile.Length < sizeof(FILE_VALID_DATA_LENGTH_INFORMATION)) {
@@ -2715,9 +2675,9 @@ static NTSTATUS set_valid_data_length_information(device_extension* Vcb, PIRP Ir
 
     InitializeListHead(&rollback);
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (fcb->atts & FILE_ATTRIBUTE_SPARSE_FILE) {
         Status = STATUS_INVALID_PARAMETER;
@@ -2725,7 +2685,7 @@ static NTSTATUS set_valid_data_length_information(device_extension* Vcb, PIRP Ir
     }
 
     if (fvdli->ValidDataLength.QuadPart <= fcb->Header.ValidDataLength.QuadPart || fvdli->ValidDataLength.QuadPart > fcb->Header.FileSize.QuadPart) {
-        TRACE("invalid VDL of %llu (current VDL = %llu, file size = %llu)\n", fvdli->ValidDataLength.QuadPart,
+        TRACE("invalid VDL of %I64u (current VDL = %I64u, file size = %I64u)\n", fvdli->ValidDataLength.QuadPart,
               fcb->Header.ValidDataLength.QuadPart, fcb->Header.FileSize.QuadPart);
         Status = STATUS_INVALID_PARAMETER;
         goto end;
@@ -2742,7 +2702,7 @@ static NTSTATUS set_valid_data_length_information(device_extension* Vcb, PIRP Ir
     ccfs.AllocationSize = fcb->Header.AllocationSize;
     ccfs.FileSize = fcb->Header.FileSize;
     ccfs.ValidDataLength = fvdli->ValidDataLength;
-    set_size = TRUE;
+    set_size = true;
 
     filter = FILE_NOTIFY_CHANGE_SIZE;
 
@@ -2752,7 +2712,7 @@ static NTSTATUS set_valid_data_length_information(device_extension* Vcb, PIRP Ir
         filter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
     }
 
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
     mark_fcb_dirty(fcb);
 
     send_notification_fcb(fileref, filter, FILE_ACTION_MODIFIED, NULL);
@@ -2808,7 +2768,7 @@ static NTSTATUS set_case_sensitive_information(PIRP Irp) {
         return STATUS_INVALID_PARAMETER;
     }
 
-    ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
 
     fcb->case_sensitive = fcsi->Flags & FILE_CS_FLAG_CASE_SENSITIVE_DIR;
     mark_fcb_dirty(fcb);
@@ -2821,13 +2781,13 @@ static NTSTATUS set_case_sensitive_information(PIRP Irp) {
 
 _Dispatch_type_(IRP_MJ_SET_INFORMATION)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
+NTSTATUS __stdcall drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     device_extension* Vcb = DeviceObject->DeviceExtension;
     fcb* fcb = IrpSp->FileObject->FsContext;
     ccb* ccb = IrpSp->FileObject->FsContext2;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -2866,11 +2826,7 @@ NTSTATUS NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
     }
 
     if (fcb != Vcb->dummy_fcb && is_subvol_readonly(fcb->subvol, Irp) && IrpSp->Parameters.SetFile.FileInformationClass != FilePositionInformation &&
-#ifndef __REACTOS__
         (fcb->inode != SUBVOL_ROOT_INODE || (IrpSp->Parameters.SetFile.FileInformationClass != FileBasicInformation && IrpSp->Parameters.SetFile.FileInformationClass != FileRenameInformation && IrpSp->Parameters.SetFile.FileInformationClass != FileRenameInformationEx))) {
-#else
-        (fcb->inode != SUBVOL_ROOT_INODE || (IrpSp->Parameters.SetFile.FileInformationClass != FileBasicInformation && IrpSp->Parameters.SetFile.FileInformationClass != FileRenameInformation))) {
-#endif
         Status = STATUS_ACCESS_DENIED;
         goto end;
     }
@@ -2890,7 +2846,7 @@ NTSTATUS NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
                 break;
             }
 
-            Status = set_end_of_file_information(Vcb, Irp, IrpSp->FileObject, FALSE, TRUE);
+            Status = set_end_of_file_information(Vcb, Irp, IrpSp->FileObject, false, true);
             break;
         }
 
@@ -2919,7 +2875,7 @@ NTSTATUS NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
                 break;
             }
 
-            Status = set_disposition_information(Vcb, Irp, IrpSp->FileObject, FALSE);
+            Status = set_disposition_information(Vcb, Irp, IrpSp->FileObject, false);
 
             break;
         }
@@ -2934,14 +2890,14 @@ NTSTATUS NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
                 break;
             }
 
-            Status = set_end_of_file_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.AdvanceOnly, FALSE);
+            Status = set_end_of_file_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.AdvanceOnly, false);
 
             break;
         }
 
         case FileLinkInformation:
             TRACE("FileLinkInformation\n");
-            Status = set_link_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, FALSE);
+            Status = set_link_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, false);
             break;
 
         case FilePositionInformation:
@@ -2952,7 +2908,7 @@ NTSTATUS NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
         case FileRenameInformation:
             TRACE("FileRenameInformation\n");
             // FIXME - make this work with streams
-            Status = set_rename_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, FALSE);
+            Status = set_rename_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, false);
             break;
 
         case FileValidDataLengthInformation:
@@ -2970,11 +2926,11 @@ NTSTATUS NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
             break;
         }
 
+#ifndef __REACTOS__
 #ifndef _MSC_VER
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch"
 #endif
-#ifndef __REACTOS__
         case FileDispositionInformationEx:
         {
             TRACE("FileDispositionInformationEx\n");
@@ -2985,19 +2941,19 @@ NTSTATUS NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
                 break;
             }
 
-            Status = set_disposition_information(Vcb, Irp, IrpSp->FileObject, TRUE);
+            Status = set_disposition_information(Vcb, Irp, IrpSp->FileObject, true);
 
             break;
         }
 
         case FileRenameInformationEx:
             TRACE("FileRenameInformationEx\n");
-            Status = set_rename_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, TRUE);
+            Status = set_rename_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, true);
             break;
 
         case FileLinkInformationEx:
             TRACE("FileLinkInformationEx\n");
-            Status = set_link_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, TRUE);
+            Status = set_link_information(Vcb, Irp, IrpSp->FileObject, IrpSp->Parameters.SetFile.FileObject, true);
             break;
 
         case FileCaseSensitiveInformation:
@@ -3011,9 +2967,9 @@ NTSTATUS NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
 
             Status = set_case_sensitive_information(Irp);
             break;
-#endif
 #ifndef _MSC_VER
 #pragma GCC diagnostic pop
+#endif
 #endif
 
         default:
@@ -3123,7 +3079,7 @@ static NTSTATUS fill_in_file_standard_information(FILE_STANDARD_INFORMATION* fsi
 
         fsi->AllocationSize.QuadPart = fsi->EndOfFile.QuadPart = fcb->adsdata.Length;
         fsi->NumberOfLinks = fileref->parent->fcb->inode_item.st_nlink;
-        fsi->Directory = FALSE;
+        fsi->Directory = false;
     } else {
         fsi->AllocationSize.QuadPart = fcb_alloc_size(fcb);
         fsi->EndOfFile.QuadPart = S_ISDIR(fcb->inode_item.st_mode) ? 0 : fcb->inode_item.st_size;
@@ -3131,9 +3087,9 @@ static NTSTATUS fill_in_file_standard_information(FILE_STANDARD_INFORMATION* fsi
         fsi->Directory = S_ISDIR(fcb->inode_item.st_mode);
     }
 
-    TRACE("length = %llu\n", fsi->EndOfFile.QuadPart);
+    TRACE("length = %I64u\n", fsi->EndOfFile.QuadPart);
 
-    fsi->DeletePending = fileref ? fileref->delete_on_close : FALSE;
+    fsi->DeletePending = fileref ? fileref->delete_on_close : false;
 
     return STATUS_SUCCESS;
 }
@@ -3174,7 +3130,7 @@ NTSTATUS fileref_get_filename(file_ref* fileref, PUNICODE_STRING fn, USHORT* nam
     NTSTATUS Status;
     ULONG reqlen = 0;
     USHORT offset;
-    BOOL overflow = FALSE;
+    bool overflow = false;
 
     // FIXME - we need a lock on filerefs' filepart
 
@@ -3207,7 +3163,7 @@ NTSTATUS fileref_get_filename(file_ref* fileref, PUNICODE_STRING fn, USHORT* nam
 
         if (!overflow) {
             if (fr->dc->name.Length + sizeof(WCHAR) + fn->Length > fn->MaximumLength)
-                overflow = TRUE;
+                overflow = true;
         }
 
         if (overflow)
@@ -3231,7 +3187,7 @@ NTSTATUS fileref_get_filename(file_ref* fileref, PUNICODE_STRING fn, USHORT* nam
 
             if (fn->Length > fn->MaximumLength) {
                 fn->Length = fn->MaximumLength;
-                overflow = TRUE;
+                overflow = true;
             }
         }
 
@@ -3261,7 +3217,7 @@ static NTSTATUS fill_in_file_name_information(FILE_NAME_INFORMATION* fni, fcb* f
     UNICODE_STRING fn;
     NTSTATUS Status;
     static const WCHAR datasuf[] = {':','$','D','A','T','A',0};
-    UINT16 datasuflen = sizeof(datasuf) - sizeof(WCHAR);
+    uint16_t datasuflen = sizeof(datasuf) - sizeof(WCHAR);
 
     if (!fileref) {
         ERR("called without fileref\n");
@@ -3277,7 +3233,7 @@ static NTSTATUS fill_in_file_name_information(FILE_NAME_INFORMATION* fni, fcb* f
 
     fn.Buffer = fni->FileName;
     fn.Length = 0;
-    fn.MaximumLength = (UINT16)*length;
+    fn.MaximumLength = (uint16_t)*length;
 
     Status = fileref_get_filename(fileref, &fn, NULL, &reqlen);
     if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
@@ -3356,7 +3312,7 @@ static NTSTATUS fill_in_file_stream_information(FILE_STREAM_INFORMATION* fsi, fi
     else
         reqsize = 0;
 
-    ExAcquireResourceSharedLite(&fileref->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceSharedLite(&fileref->fcb->nonpaged->dir_children_lock, true);
 
     le = fileref->fcb->dir_children_index.Flink;
     while (le != &fileref->fcb->dir_children_index) {
@@ -3395,7 +3351,7 @@ static NTSTATUS fill_in_file_stream_information(FILE_STREAM_INFORMATION* fsi, fi
         off = (ULONG)sector_align(sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR), sizeof(LONGLONG));
 
         lastentry = entry;
-        entry = (FILE_STREAM_INFORMATION*)((UINT8*)entry + off);
+        entry = (FILE_STREAM_INFORMATION*)((uint8_t*)entry + off);
     }
 
     le = fileref->fcb->dir_children_index.Flink;
@@ -3421,12 +3377,12 @@ static NTSTATUS fill_in_file_stream_information(FILE_STREAM_INFORMATION* fsi, fi
             RtlCopyMemory(&entry->StreamName[1 + (dc->name.Length / sizeof(WCHAR))], suf.Buffer, suf.Length);
 
             if (lastentry)
-                lastentry->NextEntryOffset = (UINT32)((UINT8*)entry - (UINT8*)lastentry);
+                lastentry->NextEntryOffset = (uint32_t)((uint8_t*)entry - (uint8_t*)lastentry);
 
             off = (ULONG)sector_align(sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR) + dc->name.Length, sizeof(LONGLONG));
 
             lastentry = entry;
-            entry = (FILE_STREAM_INFORMATION*)((UINT8*)entry + off);
+            entry = (FILE_STREAM_INFORMATION*)((uint8_t*)entry + off);
         } else
             break;
 
@@ -3451,8 +3407,8 @@ static NTSTATUS fill_in_file_standard_link_information(FILE_STANDARD_LINK_INFORM
 
     fsli->NumberOfAccessibleLinks = fcb->inode_item.st_nlink;
     fsli->TotalNumberOfLinks = fcb->inode_item.st_nlink;
-    fsli->DeletePending = fileref ? fileref->delete_on_close : FALSE;
-    fsli->Directory = (!fcb->ads && fcb->type == BTRFS_TYPE_DIRECTORY) ? TRUE : FALSE;
+    fsli->DeletePending = fileref ? fileref->delete_on_close : false;
+    fsli->Directory = (!fcb->ads && fcb->type == BTRFS_TYPE_DIRECTORY) ? true : false;
 
     *length -= sizeof(FILE_STANDARD_LINK_INFORMATION);
 
@@ -3464,7 +3420,7 @@ static NTSTATUS fill_in_hard_link_information(FILE_LINKS_INFORMATION* fli, file_
     LIST_ENTRY* le;
     LONG bytes_needed;
     FILE_LINK_ENTRY_INFORMATION* feli;
-    BOOL overflow = FALSE;
+    bool overflow = false;
     fcb* fcb = fileref->fcb;
     ULONG len;
 
@@ -3480,7 +3436,7 @@ static NTSTATUS fill_in_hard_link_information(FILE_LINKS_INFORMATION* fli, file_
     len = bytes_needed;
     feli = NULL;
 
-    ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
     if (fcb->inode == SUBVOL_ROOT_INODE) {
         ULONG namelen;
@@ -3493,7 +3449,7 @@ static NTSTATUS fill_in_hard_link_information(FILE_LINKS_INFORMATION* fli, file_
         bytes_needed += sizeof(FILE_LINK_ENTRY_INFORMATION) - sizeof(WCHAR) + namelen;
 
         if (bytes_needed > *length)
-            overflow = TRUE;
+            overflow = true;
 
         if (!overflow) {
             feli = &fli->Entry;
@@ -3514,13 +3470,13 @@ static NTSTATUS fill_in_hard_link_information(FILE_LINKS_INFORMATION* fli, file_
             len = bytes_needed;
         }
     } else {
-        ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, true);
 
         if (IsListEmpty(&fcb->hardlinks)) {
             bytes_needed += sizeof(FILE_LINK_ENTRY_INFORMATION) + fileref->dc->name.Length - sizeof(WCHAR);
 
             if (bytes_needed > *length)
-                overflow = TRUE;
+                overflow = true;
 
             if (!overflow) {
                 feli = &fli->Entry;
@@ -3540,7 +3496,7 @@ static NTSTATUS fill_in_hard_link_information(FILE_LINKS_INFORMATION* fli, file_
                 hardlink* hl = CONTAINING_RECORD(le, hardlink, list_entry);
                 file_ref* parfr;
 
-                TRACE("parent %llx, index %llx, name %.*S\n", hl->parent, hl->index, hl->name.Length / sizeof(WCHAR), hl->name.Buffer);
+                TRACE("parent %I64x, index %I64x, name %.*S\n", hl->parent, hl->index, hl->name.Length / sizeof(WCHAR), hl->name.Buffer);
 
                 Status = open_fileref_by_inode(fcb->Vcb, fcb->subvol, hl->parent, &parfr, Irp);
 
@@ -3548,7 +3504,7 @@ static NTSTATUS fill_in_hard_link_information(FILE_LINKS_INFORMATION* fli, file_
                     ERR("open_fileref_by_inode returned %08x\n", Status);
                 } else if (!parfr->deleted) {
                     LIST_ENTRY* le2;
-                    BOOL found = FALSE, deleted = FALSE;
+                    bool found = false, deleted = false;
                     UNICODE_STRING* fn = NULL;
 
                     le2 = parfr->children.Flink;
@@ -3556,7 +3512,7 @@ static NTSTATUS fill_in_hard_link_information(FILE_LINKS_INFORMATION* fli, file_
                         file_ref* fr2 = CONTAINING_RECORD(le2, file_ref, list_entry);
 
                         if (fr2->dc->index == hl->index) {
-                            found = TRUE;
+                            found = true;
                             deleted = fr2->deleted;
 
                             if (!deleted)
@@ -3580,12 +3536,12 @@ static NTSTATUS fill_in_hard_link_information(FILE_LINKS_INFORMATION* fli, file_
                         bytes_needed += sizeof(FILE_LINK_ENTRY_INFORMATION) + fn->Length - sizeof(WCHAR);
 
                         if (bytes_needed > *length)
-                            overflow = TRUE;
+                            overflow = true;
 
                         if (!overflow) {
                             if (feli) {
                                 feli->NextEntryOffset = (ULONG)sector_align(sizeof(FILE_LINK_ENTRY_INFORMATION) + ((feli->FileNameLength - 1) * sizeof(WCHAR)), 8);
-                                feli = (FILE_LINK_ENTRY_INFORMATION*)((UINT8*)feli + feli->NextEntryOffset);
+                                feli = (FILE_LINK_ENTRY_INFORMATION*)((uint8_t*)feli + feli->NextEntryOffset);
                             } else
                                 feli = &fli->Entry;
 
@@ -3620,15 +3576,13 @@ static NTSTATUS fill_in_hard_link_information(FILE_LINKS_INFORMATION* fli, file_
 
     return Status;
 }
-#endif /* __REACTOS__ */
 
-#if (NTDDI_VERSION >= NTDDI_WIN10)
 static NTSTATUS fill_in_hard_link_full_id_information(FILE_LINKS_FULL_ID_INFORMATION* flfii, file_ref* fileref, PIRP Irp, LONG* length) {
     NTSTATUS Status;
     LIST_ENTRY* le;
     LONG bytes_needed;
     FILE_LINK_ENTRY_FULL_ID_INFORMATION* flefii;
-    BOOL overflow = FALSE;
+    bool overflow = false;
     fcb* fcb = fileref->fcb;
     ULONG len;
 
@@ -3644,7 +3598,7 @@ static NTSTATUS fill_in_hard_link_full_id_information(FILE_LINKS_FULL_ID_INFORMA
     len = bytes_needed;
     flefii = NULL;
 
-    ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
     if (fcb->inode == SUBVOL_ROOT_INODE) {
         ULONG namelen;
@@ -3657,7 +3611,7 @@ static NTSTATUS fill_in_hard_link_full_id_information(FILE_LINKS_FULL_ID_INFORMA
         bytes_needed += offsetof(FILE_LINK_ENTRY_FULL_ID_INFORMATION, FileName[0]) + namelen;
 
         if (bytes_needed > *length)
-            overflow = TRUE;
+            overflow = true;
 
         if (!overflow) {
             flefii = &flfii->Entry;
@@ -3669,8 +3623,8 @@ static NTSTATUS fill_in_hard_link_full_id_information(FILE_LINKS_FULL_ID_INFORMA
                 flefii->FileNameLength = 1;
                 flefii->FileName[0] = '.';
             } else {
-                RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &fileref->parent->fcb->inode, sizeof(UINT64));
-                RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(UINT64)], &fileref->parent->fcb->subvol->id, sizeof(UINT64));
+                RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &fileref->parent->fcb->inode, sizeof(uint64_t));
+                RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(uint64_t)], &fileref->parent->fcb->subvol->id, sizeof(uint64_t));
 
                 flefii->FileNameLength = fileref->dc->name.Length / sizeof(WCHAR);
                 RtlCopyMemory(flefii->FileName, fileref->dc->name.Buffer, fileref->dc->name.Length);
@@ -3681,21 +3635,21 @@ static NTSTATUS fill_in_hard_link_full_id_information(FILE_LINKS_FULL_ID_INFORMA
             len = bytes_needed;
         }
     } else {
-        ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, true);
 
         if (IsListEmpty(&fcb->hardlinks)) {
             bytes_needed += offsetof(FILE_LINK_ENTRY_FULL_ID_INFORMATION, FileName[0]) + fileref->dc->name.Length;
 
             if (bytes_needed > *length)
-                overflow = TRUE;
+                overflow = true;
 
             if (!overflow) {
                 flefii = &flfii->Entry;
 
                 flefii->NextEntryOffset = 0;
 
-                RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &fileref->parent->fcb->inode, sizeof(UINT64));
-                RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(UINT64)], &fileref->parent->fcb->subvol->id, sizeof(UINT64));
+                RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &fileref->parent->fcb->inode, sizeof(uint64_t));
+                RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(uint64_t)], &fileref->parent->fcb->subvol->id, sizeof(uint64_t));
 
                 flefii->FileNameLength = fileref->dc->name.Length / sizeof(WCHAR);
                 RtlCopyMemory(flefii->FileName, fileref->dc->name.Buffer, fileref->dc->name.Length);
@@ -3710,7 +3664,7 @@ static NTSTATUS fill_in_hard_link_full_id_information(FILE_LINKS_FULL_ID_INFORMA
                 hardlink* hl = CONTAINING_RECORD(le, hardlink, list_entry);
                 file_ref* parfr;
 
-                TRACE("parent %llx, index %llx, name %.*S\n", hl->parent, hl->index, hl->name.Length / sizeof(WCHAR), hl->name.Buffer);
+                TRACE("parent %I64x, index %I64x, name %.*S\n", hl->parent, hl->index, hl->name.Length / sizeof(WCHAR), hl->name.Buffer);
 
                 Status = open_fileref_by_inode(fcb->Vcb, fcb->subvol, hl->parent, &parfr, Irp);
 
@@ -3718,7 +3672,7 @@ static NTSTATUS fill_in_hard_link_full_id_information(FILE_LINKS_FULL_ID_INFORMA
                     ERR("open_fileref_by_inode returned %08x\n", Status);
                 } else if (!parfr->deleted) {
                     LIST_ENTRY* le2;
-                    BOOL found = FALSE, deleted = FALSE;
+                    bool found = false, deleted = false;
                     UNICODE_STRING* fn = NULL;
 
                     le2 = parfr->children.Flink;
@@ -3726,7 +3680,7 @@ static NTSTATUS fill_in_hard_link_full_id_information(FILE_LINKS_FULL_ID_INFORMA
                         file_ref* fr2 = CONTAINING_RECORD(le2, file_ref, list_entry);
 
                         if (fr2->dc->index == hl->index) {
-                            found = TRUE;
+                            found = true;
                             deleted = fr2->deleted;
 
                             if (!deleted)
@@ -3750,19 +3704,19 @@ static NTSTATUS fill_in_hard_link_full_id_information(FILE_LINKS_FULL_ID_INFORMA
                         bytes_needed += offsetof(FILE_LINK_ENTRY_FULL_ID_INFORMATION, FileName[0]) + fn->Length;
 
                         if (bytes_needed > *length)
-                            overflow = TRUE;
+                            overflow = true;
 
                         if (!overflow) {
                             if (flefii) {
                                 flefii->NextEntryOffset = (ULONG)sector_align(offsetof(FILE_LINK_ENTRY_FULL_ID_INFORMATION, FileName[0]) + (flefii->FileNameLength * sizeof(WCHAR)), 8);
-                                flefii = (FILE_LINK_ENTRY_FULL_ID_INFORMATION*)((UINT8*)flefii + flefii->NextEntryOffset);
+                                flefii = (FILE_LINK_ENTRY_FULL_ID_INFORMATION*)((uint8_t*)flefii + flefii->NextEntryOffset);
                             } else
                                 flefii = &flfii->Entry;
 
                             flefii->NextEntryOffset = 0;
 
-                            RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &parfr->fcb->inode, sizeof(UINT64));
-                            RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(UINT64)], &parfr->fcb->subvol->id, sizeof(UINT64));
+                            RtlCopyMemory(&flefii->ParentFileId.Identifier[0], &parfr->fcb->inode, sizeof(uint64_t));
+                            RtlCopyMemory(&flefii->ParentFileId.Identifier[sizeof(uint64_t)], &parfr->fcb->subvol->id, sizeof(uint64_t));
 
                             flefii->FileNameLength = fn->Length / sizeof(WCHAR);
                             RtlCopyMemory(flefii->FileName, fn->Buffer, fn->Length);
@@ -3795,22 +3749,20 @@ static NTSTATUS fill_in_hard_link_full_id_information(FILE_LINKS_FULL_ID_INFORMA
 }
 
 static NTSTATUS fill_in_file_id_information(FILE_ID_INFORMATION* fii, fcb* fcb, LONG* length) {
-    RtlCopyMemory(&fii->VolumeSerialNumber, &fcb->Vcb->superblock.uuid.uuid[8], sizeof(UINT64));
-    RtlCopyMemory(&fii->FileId.Identifier[0], &fcb->inode, sizeof(UINT64));
-    RtlCopyMemory(&fii->FileId.Identifier[sizeof(UINT64)], &fcb->subvol->id, sizeof(UINT64));
+    RtlCopyMemory(&fii->VolumeSerialNumber, &fcb->Vcb->superblock.uuid.uuid[8], sizeof(uint64_t));
+    RtlCopyMemory(&fii->FileId.Identifier[0], &fcb->inode, sizeof(uint64_t));
+    RtlCopyMemory(&fii->FileId.Identifier[sizeof(uint64_t)], &fcb->subvol->id, sizeof(uint64_t));
 
     *length -= sizeof(FILE_ID_INFORMATION);
 
     return STATUS_SUCCESS;
 }
-#endif
 
-#ifndef __REACTOS__
 static NTSTATUS fill_in_file_stat_information(FILE_STAT_INFORMATION* fsi, fcb* fcb, ccb* ccb, LONG* length) {
     INODE_ITEM* ii;
 
-    fsi->FileId.LowPart = (UINT32)fcb->inode;
-    fsi->FileId.HighPart = (UINT32)fcb->subvol->id;
+    fsi->FileId.LowPart = (uint32_t)fcb->inode;
+    fsi->FileId.HighPart = (uint32_t)fcb->subvol->id;
 
     if (fcb->ads)
         ii = &ccb->fileref->parent->fcb->inode_item;
@@ -3869,8 +3821,8 @@ static NTSTATUS fill_in_file_stat_information(FILE_STAT_INFORMATION* fsi, fcb* f
 static NTSTATUS fill_in_file_stat_lx_information(FILE_STAT_LX_INFORMATION* fsli, fcb* fcb, ccb* ccb, LONG* length) {
     INODE_ITEM* ii;
 
-    fsli->FileId.LowPart = (UINT32)fcb->inode;
-    fsli->FileId.HighPart = (UINT32)fcb->subvol->id;
+    fsli->FileId.LowPart = (uint32_t)fcb->inode;
+    fsli->FileId.HighPart = (uint32_t)fcb->subvol->id;
 
     if (fcb->ads)
         ii = &ccb->fileref->parent->fcb->inode_item;
@@ -4038,7 +3990,7 @@ static NTSTATUS query_info(device_extension* Vcb, PFILE_OBJECT FileObject, PIRP
                 goto exit;
             }
 
-            ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
             Status = fill_in_file_attribute_information(ati, fcb, ccb, &length);
             ExReleaseResourceLite(&Vcb->tree_lock);
 
@@ -4180,7 +4132,7 @@ static NTSTATUS query_info(device_extension* Vcb, PFILE_OBJECT FileObject, PIRP
 
             TRACE("FileHardLinkInformation\n");
 
-            ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
             Status = fill_in_hard_link_information(fli, fileref, Irp, &length);
             ExReleaseResourceLite(&Vcb->tree_lock);
 
@@ -4197,9 +4149,7 @@ static NTSTATUS query_info(device_extension* Vcb, PFILE_OBJECT FileObject, PIRP
 
             break;
         }
-#endif
 
-#if (NTDDI_VERSION >= NTDDI_WIN7)
         case FileStandardLinkInformation:
         {
             FILE_STANDARD_LINK_INFORMATION* fsli = Irp->AssociatedIrp.SystemBuffer;
@@ -4215,9 +4165,7 @@ static NTSTATUS query_info(device_extension* Vcb, PFILE_OBJECT FileObject, PIRP
             TRACE("FileRemoteProtocolInformation\n");
             Status = STATUS_INVALID_PARAMETER;
             goto exit;
-#endif
 
-#if (NTDDI_VERSION >= NTDDI_WIN10)
 #ifndef _MSC_VER
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch"
@@ -4296,7 +4244,7 @@ static NTSTATUS query_info(device_extension* Vcb, PFILE_OBJECT FileObject, PIRP
 
             TRACE("FileHardLinkFullIdInformation\n");
 
-            ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
             Status = fill_in_hard_link_full_id_information(flfii, fileref, Irp, &length);
             ExReleaseResourceLite(&Vcb->tree_lock);
 
@@ -4328,12 +4276,12 @@ exit:
 
 _Dispatch_type_(IRP_MJ_QUERY_INFORMATION)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_query_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
+NTSTATUS __stdcall drv_query_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     PIO_STACK_LOCATION IrpSp;
     NTSTATUS Status;
     fcb* fcb;
     device_extension* Vcb = DeviceObject->DeviceExtension;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -4376,9 +4324,9 @@ end:
 
 _Dispatch_type_(IRP_MJ_QUERY_EA)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
+NTSTATUS __stdcall drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     NTSTATUS Status;
-    BOOL top_level;
+    bool top_level;
     device_extension* Vcb = DeviceObject->DeviceExtension;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     PFILE_OBJECT FileObject = IrpSp->FileObject;
@@ -4439,7 +4387,7 @@ NTSTATUS NTAPI drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     if (fcb->ads)
         fcb = ccb->fileref->parent->fcb;
 
-    ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
     Status = STATUS_SUCCESS;
 
@@ -4462,31 +4410,31 @@ NTSTATUS NTAPI drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
             if (in->NextEntryOffset == 0)
                 break;
 
-            in = (FILE_GET_EA_INFORMATION*)(((UINT8*)in) + in->NextEntryOffset);
-        } while (TRUE);
+            in = (FILE_GET_EA_INFORMATION*)(((uint8_t*)in) + in->NextEntryOffset);
+        } while (true);
 
         ea = (FILE_FULL_EA_INFORMATION*)fcb->ea_xattr.Buffer;
         out = NULL;
 
         do {
-            BOOL found = FALSE;
+            bool found = false;
 
             in = IrpSp->Parameters.QueryEa.EaList;
             do {
                 if (in->EaNameLength == ea->EaNameLength &&
                     RtlCompareMemory(in->EaName, ea->EaName, in->EaNameLength) == in->EaNameLength) {
-                    found = TRUE;
+                    found = true;
                     break;
                 }
 
                 if (in->NextEntryOffset == 0)
                     break;
 
-                in = (FILE_GET_EA_INFORMATION*)(((UINT8*)in) + in->NextEntryOffset);
-            } while (TRUE);
+                in = (FILE_GET_EA_INFORMATION*)(((uint8_t*)in) + in->NextEntryOffset);
+            } while (true);
 
             if (found) {
-                UINT8 padding = retlen % 4 > 0 ? (4 - (retlen % 4)) : 0;
+                uint8_t padding = retlen % 4 > 0 ? (4 - (retlen % 4)) : 0;
 
                 if (offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + 1 + ea->EaValueLength > IrpSp->Parameters.QueryEa.Length - retlen - padding) {
                     Status = STATUS_BUFFER_OVERFLOW;
@@ -4498,7 +4446,7 @@ NTSTATUS NTAPI drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
 
                 if (out) {
                     out->NextEntryOffset = (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + out->EaNameLength + 1 + out->EaValueLength + padding;
-                    out = (FILE_FULL_EA_INFORMATION*)(((UINT8*)out) + out->NextEntryOffset);
+                    out = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)out) + out->NextEntryOffset);
                 } else
                     out = ffei;
 
@@ -4517,8 +4465,8 @@ NTSTATUS NTAPI drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
             if (ea->NextEntryOffset == 0)
                 break;
 
-            ea = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ea) + ea->NextEntryOffset);
-        } while (TRUE);
+            ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
+        } while (true);
     } else {
         FILE_FULL_EA_INFORMATION *ea, *out;
         ULONG index;
@@ -4544,14 +4492,14 @@ NTSTATUS NTAPI drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
                 if (ea->NextEntryOffset == 0) // last item
                     goto end2;
 
-                ea = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ea) + ea->NextEntryOffset);
+                ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
             }
         }
 
         out = NULL;
 
         do {
-            UINT8 padding = retlen % 4 > 0 ? (4 - (retlen % 4)) : 0;
+            uint8_t padding = retlen % 4 > 0 ? (4 - (retlen % 4)) : 0;
 
             if (offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + 1 + ea->EaValueLength > IrpSp->Parameters.QueryEa.Length - retlen - padding) {
                 Status = retlen == 0 ? STATUS_BUFFER_TOO_SMALL : STATUS_BUFFER_OVERFLOW;
@@ -4562,7 +4510,7 @@ NTSTATUS NTAPI drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
 
             if (out) {
                 out->NextEntryOffset = (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + out->EaNameLength + 1 + out->EaValueLength + padding;
-                out = (FILE_FULL_EA_INFORMATION*)(((UINT8*)out) + out->NextEntryOffset);
+                out = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)out) + out->NextEntryOffset);
             } else
                 out = ffei;
 
@@ -4580,8 +4528,8 @@ NTSTATUS NTAPI drv_query_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
             if (ea->NextEntryOffset == 0 || IrpSp->Flags & SL_RETURN_SINGLE_ENTRY)
                 break;
 
-            ea = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ea) + ea->NextEntryOffset);
-        } while (TRUE);
+            ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
+        } while (true);
     }
 
 end2:
@@ -4605,10 +4553,10 @@ end:
 
 _Dispatch_type_(IRP_MJ_SET_EA)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
+NTSTATUS __stdcall drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     device_extension* Vcb = DeviceObject->DeviceExtension;
     NTSTATUS Status;
-    BOOL top_level;
+    bool top_level;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     fcb* fcb;
@@ -4691,7 +4639,7 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
 
     InitializeListHead(&ealist);
 
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (fcb->ea_xattr.Length > 0) {
         ea = (FILE_FULL_EA_INFORMATION*)fcb->ea_xattr.Buffer;
@@ -4717,15 +4665,15 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
             if (ea->NextEntryOffset == 0)
                 break;
 
-            ea = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ea) + ea->NextEntryOffset);
-        } while (TRUE);
+            ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
+        } while (true);
     }
 
     ea = ffei;
 
     do {
         STRING s;
-        BOOL found = FALSE;
+        bool found = false;
 
         s.Length = s.MaximumLength = ea->EaNameLength;
         s.Buffer = ea->EaName;
@@ -4741,7 +4689,7 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
                 item->flags = ea->Flags;
                 item->value.Length = item->value.MaximumLength = ea->EaValueLength;
                 item->value.Buffer = &ea->EaName[ea->EaNameLength + 1];
-                found = TRUE;
+                found = true;
                 break;
             }
 
@@ -4770,8 +4718,8 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
         if (ea->NextEntryOffset == 0)
             break;
 
-        ea = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ea) + ea->NextEntryOffset);
-    } while (TRUE);
+        ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
+    } while (true);
 
     // remove entries with zero-length value
     le = ealist.Flink;
@@ -4796,44 +4744,44 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
         item = CONTAINING_RECORD(le, ea_item, list_entry);
 
         if (item->name.Length == sizeof(lxuid) - 1 && RtlCompareMemory(item->name.Buffer, lxuid, item->name.Length) == item->name.Length) {
-            if (item->value.Length < sizeof(UINT32)) {
+            if (item->value.Length < sizeof(uint32_t)) {
                 ERR("uid value was shorter than expected\n");
                 Status = STATUS_INVALID_PARAMETER;
                 goto end2;
             }
 
             if (Irp->RequestorMode == KernelMode) {
-                RtlCopyMemory(&fcb->inode_item.st_uid, item->value.Buffer, sizeof(UINT32));
-                fcb->sd_dirty = TRUE;
-                fcb->sd_deleted = FALSE;
+                RtlCopyMemory(&fcb->inode_item.st_uid, item->value.Buffer, sizeof(uint32_t));
+                fcb->sd_dirty = true;
+                fcb->sd_deleted = false;
             }
 
             RemoveEntryList(&item->list_entry);
             ExFreePool(item);
         } else if (item->name.Length == sizeof(lxgid) - 1 && RtlCompareMemory(item->name.Buffer, lxgid, item->name.Length) == item->name.Length) {
-            if (item->value.Length < sizeof(UINT32)) {
+            if (item->value.Length < sizeof(uint32_t)) {
                 ERR("gid value was shorter than expected\n");
                 Status = STATUS_INVALID_PARAMETER;
                 goto end2;
             }
 
             if (Irp->RequestorMode == KernelMode)
-                RtlCopyMemory(&fcb->inode_item.st_gid, item->value.Buffer, sizeof(UINT32));
+                RtlCopyMemory(&fcb->inode_item.st_gid, item->value.Buffer, sizeof(uint32_t));
 
             RemoveEntryList(&item->list_entry);
             ExFreePool(item);
         } else if (item->name.Length == sizeof(lxmod) - 1 && RtlCompareMemory(item->name.Buffer, lxmod, item->name.Length) == item->name.Length) {
-            if (item->value.Length < sizeof(UINT32)) {
+            if (item->value.Length < sizeof(uint32_t)) {
                 ERR("mode value was shorter than expected\n");
                 Status = STATUS_INVALID_PARAMETER;
                 goto end2;
             }
 
             if (Irp->RequestorMode == KernelMode) {
-                UINT32 allowed = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH | S_ISGID | S_ISVTX | S_ISUID;
-                UINT32 val;
+                uint32_t allowed = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH | S_ISGID | S_ISVTX | S_ISUID;
+                uint32_t val;
 
-                RtlCopyMemory(&val, item->value.Buffer, sizeof(UINT32));
+                RtlCopyMemory(&val, item->value.Buffer, sizeof(uint32_t));
 
                 fcb->inode_item.st_mode &= ~allowed;
                 fcb->inode_item.st_mode |= val & allowed;
@@ -4855,7 +4803,7 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
         fcb->ea_xattr.Length = fcb->ea_xattr.MaximumLength = 0;
         fcb->ea_xattr.Buffer = NULL;
     } else {
-        UINT16 size = 0;
+        uint16_t size = 0;
         char *buf, *oldbuf;
 
         le = ealist.Flink;
@@ -4865,7 +4813,7 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
             if (size % 4 > 0)
                 size += 4 - (size % 4);
 
-            size += (UINT16)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + item->name.Length + 1 + item->value.Length;
+            size += (uint16_t)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + item->name.Length + 1 + item->value.Length;
 
             le = le->Flink;
         }
@@ -4895,7 +4843,7 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
                 if (ea->NextEntryOffset % 4 > 0)
                     ea->NextEntryOffset += 4 - (ea->NextEntryOffset % 4);
 
-                ea = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ea) + ea->NextEntryOffset);
+                ea = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)ea) + ea->NextEntryOffset);
             } else
                 ea = (FILE_FULL_EA_INFORMATION*)fcb->ea_xattr.Buffer;
 
@@ -4917,7 +4865,7 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
             ExFreePool(oldbuf);
     }
 
-    fcb->ea_changed = TRUE;
+    fcb->ea_changed = true;
 
     KeQuerySystemTime(&time);
     win_time_to_unix(time, &now);
@@ -4928,7 +4876,7 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     if (!ccb->user_set_change_time)
         fcb->inode_item.st_ctime = now;
 
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
     mark_fcb_dirty(fcb);
 
     send_notification_fileref(fileref, FILE_NOTIFY_CHANGE_EA, FILE_ACTION_MODIFIED, NULL);
diff --git a/drivers/filesystems/btrfs/flushthread.c b/drivers/filesystems/btrfs/flushthread.c
index 5801ff3329d..ef847a59cca 100644
--- a/drivers/filesystems/btrfs/flushthread.c
+++ b/drivers/filesystems/btrfs/flushthread.c
@@ -31,13 +31,13 @@ typedef struct {
 
 typedef struct {
     EXTENT_ITEM_TREE eit;
-    UINT8 type;
+    uint8_t type;
     TREE_BLOCK_REF tbr;
 } EXTENT_ITEM_TREE2;
 
 typedef struct {
     EXTENT_ITEM ei;
-    UINT8 type;
+    uint8_t type;
     TREE_BLOCK_REF tbr;
 } EXTENT_ITEM_SKINNY_METADATA;
 
@@ -49,37 +49,34 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
 #endif
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI write_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#else
-static NTSTATUS write_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#endif
+static NTSTATUS __stdcall write_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
     write_context* context = conptr;
 
     UNUSED(DeviceObject);
 
     context->iosb = Irp->IoStatus;
-    KeSetEvent(&context->Event, 0, FALSE);
+    KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
 
-NTSTATUS write_data_phys(_In_ PDEVICE_OBJECT device, _In_ UINT64 address, _In_reads_bytes_(length) void* data, _In_ UINT32 length) {
+NTSTATUS write_data_phys(_In_ PDEVICE_OBJECT device, _In_ PFILE_OBJECT fileobj, _In_ uint64_t address,
+                         _In_reads_bytes_(length) void* data, _In_ uint32_t length) {
     NTSTATUS Status;
     LARGE_INTEGER offset;
     PIRP Irp;
     PIO_STACK_LOCATION IrpSp;
     write_context context;
 
-    TRACE("(%p, %llx, %p, %x)\n", device, address, data, length);
+    TRACE("(%p, %I64x, %p, %x)\n", device, address, data, length);
 
     RtlZeroMemory(&context, sizeof(write_context));
 
-    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&context.Event, NotificationEvent, false);
 
     offset.QuadPart = address;
 
-    Irp = IoAllocateIrp(device->StackSize, FALSE);
+    Irp = IoAllocateIrp(device->StackSize, false);
 
     if (!Irp) {
         ERR("IoAllocateIrp failed\n");
@@ -88,13 +85,14 @@ NTSTATUS write_data_phys(_In_ PDEVICE_OBJECT device, _In_ UINT64 address, _In_re
 
     IrpSp = IoGetNextIrpStackLocation(Irp);
     IrpSp->MajorFunction = IRP_MJ_WRITE;
+    IrpSp->FileObject = fileobj;
 
     if (device->Flags & DO_BUFFERED_IO) {
         Irp->AssociatedIrp.SystemBuffer = data;
 
         Irp->Flags = IRP_BUFFERED_IO;
     } else if (device->Flags & DO_DIRECT_IO) {
-        Irp->MdlAddress = IoAllocateMdl(data, length, FALSE, FALSE, NULL);
+        Irp->MdlAddress = IoAllocateMdl(data, length, false, false, NULL);
         if (!Irp->MdlAddress) {
             DbgPrint("IoAllocateMdl failed\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -125,12 +123,12 @@ NTSTATUS write_data_phys(_In_ PDEVICE_OBJECT device, _In_ UINT64 address, _In_re
 
     Irp->UserEvent = &context.Event;
 
-    IoSetCompletionRoutine(Irp, write_completion, &context, TRUE, TRUE, TRUE);
+    IoSetCompletionRoutine(Irp, write_completion, &context, true, true, true);
 
     Status = IoCallDriver(device, Irp);
 
     if (Status == STATUS_PENDING) {
-        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+        KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
         Status = context.iosb.Status;
     }
 
@@ -149,7 +147,7 @@ exit:
     return Status;
 }
 
-static void add_trim_entry(device* dev, UINT64 address, UINT64 size) {
+static void add_trim_entry(device* dev, uint64_t address, uint64_t size) {
     space* s = ExAllocatePoolWithTag(PagedPool, sizeof(space), ALLOC_TAG);
     if (!s) {
         ERR("out of memory\n");
@@ -190,22 +188,22 @@ static void clean_space_cache_chunk(device_extension* Vcb, chunk* c) {
             CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
 
             if (type == BLOCK_FLAG_DUPLICATE) {
-                UINT16 i;
+                uint16_t i;
 
                 for (i = 0; i < c->chunk_item->num_stripes; i++) {
                     if (c->devices[i] && c->devices[i]->devobj && !c->devices[i]->readonly && c->devices[i]->trim)
                         add_trim_entry(c->devices[i], s->address - c->offset + cis[i].offset, s->size);
                 }
             } else if (type == BLOCK_FLAG_RAID0) {
-                UINT64 startoff, endoff;
-                UINT16 startoffstripe, endoffstripe, i;
+                uint64_t startoff, endoff;
+                uint16_t startoffstripe, endoffstripe, i;
 
                 get_raid0_offset(s->address - c->offset, c->chunk_item->stripe_length, c->chunk_item->num_stripes, &startoff, &startoffstripe);
                 get_raid0_offset(s->address - c->offset + s->size - 1, c->chunk_item->stripe_length, c->chunk_item->num_stripes, &endoff, &endoffstripe);
 
                 for (i = 0; i < c->chunk_item->num_stripes; i++) {
                     if (c->devices[i] && c->devices[i]->devobj && !c->devices[i]->readonly && c->devices[i]->trim) {
-                        UINT64 stripestart, stripeend;
+                        uint64_t stripestart, stripeend;
 
                         if (startoffstripe > i)
                             stripestart = startoff - (startoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length;
@@ -226,8 +224,8 @@ static void clean_space_cache_chunk(device_extension* Vcb, chunk* c) {
                     }
                 }
             } else if (type == BLOCK_FLAG_RAID10) {
-                UINT64 startoff, endoff;
-                UINT16 sub_stripes, startoffstripe, endoffstripe, i;
+                uint64_t startoff, endoff;
+                uint16_t sub_stripes, startoffstripe, endoffstripe, i;
 
                 sub_stripes = max(1, c->chunk_item->sub_stripes);
 
@@ -239,7 +237,7 @@ static void clean_space_cache_chunk(device_extension* Vcb, chunk* c) {
 
                 for (i = 0; i < c->chunk_item->num_stripes; i += sub_stripes) {
                     ULONG j;
-                    UINT64 stripestart, stripeend;
+                    uint64_t stripestart, stripeend;
 
                     if (startoffstripe > i)
                         stripestart = startoff - (startoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length;
@@ -276,6 +274,10 @@ typedef struct {
     ATA_PASS_THROUGH_EX apte;
     PIRP Irp;
     IO_STATUS_BLOCK iosb;
+#ifdef DEBUG_TRIM_EMULATION
+    PMDL mdl;
+    void* buf;
+#endif
 } ioctl_context_stripe;
 
 typedef struct {
@@ -285,11 +287,7 @@ typedef struct {
 } ioctl_context;
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI ioctl_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#else
-static NTSTATUS ioctl_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#endif
+static NTSTATUS __stdcall ioctl_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
     ioctl_context* context = (ioctl_context*)conptr;
     LONG left2 = InterlockedDecrement(&context->left);
 
@@ -297,19 +295,111 @@ static NTSTATUS ioctl_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID co
     UNUSED(Irp);
 
     if (left2 == 0)
-        KeSetEvent(&context->Event, 0, FALSE);
+        KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
 
+#ifdef DEBUG_TRIM_EMULATION
+static void trim_emulation(device* dev) {
+    LIST_ENTRY* le;
+    ioctl_context context;
+    unsigned int i = 0, count = 0;
+
+    le = dev->trim_list.Flink;
+    while (le != &dev->trim_list) {
+        count++;
+        le = le->Flink;
+    }
+
+    context.left = count;
+
+    KeInitializeEvent(&context.Event, NotificationEvent, false);
+
+    context.stripes = ExAllocatePoolWithTag(NonPagedPool, sizeof(ioctl_context_stripe) * context.left, ALLOC_TAG);
+    if (!context.stripes) {
+        ERR("out of memory\n");
+        return;
+    }
+
+    RtlZeroMemory(context.stripes, sizeof(ioctl_context_stripe) * context.left);
+
+    i = 0;
+    le = dev->trim_list.Flink;
+    while (le != &dev->trim_list) {
+        ioctl_context_stripe* stripe = &context.stripes[i];
+        space* s = CONTAINING_RECORD(le, space, list_entry);
+
+        WARN("(%I64x, %I64x)\n", s->address, s->size);
+
+        stripe->Irp = IoAllocateIrp(dev->devobj->StackSize, false);
+
+        if (!stripe->Irp) {
+            ERR("IoAllocateIrp failed\n");
+        } else {
+            PIO_STACK_LOCATION IrpSp = IoGetNextIrpStackLocation(stripe->Irp);
+            IrpSp->MajorFunction = IRP_MJ_WRITE;
+            IrpSp->FileObject = dev->fileobj;
+
+            stripe->buf = ExAllocatePoolWithTag(NonPagedPool, (uint32_t)s->size, ALLOC_TAG);
+
+            if (!stripe->buf) {
+                ERR("out of memory\n");
+            } else {
+                RtlZeroMemory(stripe->buf, (uint32_t)s->size); // FIXME - randomize instead?
+
+                stripe->mdl = IoAllocateMdl(stripe->buf, (uint32_t)s->size, false, false, NULL);
+
+                if (!stripe->mdl) {
+                    ERR("IoAllocateMdl failed\n");
+                } else {
+                    MmBuildMdlForNonPagedPool(stripe->mdl);
+
+                    stripe->Irp->MdlAddress = stripe->mdl;
+
+                    IrpSp->Parameters.Write.ByteOffset.QuadPart = s->address;
+                    IrpSp->Parameters.Write.Length = s->size;
+
+                    stripe->Irp->UserIosb = &stripe->iosb;
+
+                    IoSetCompletionRoutine(stripe->Irp, ioctl_completion, &context, true, true, true);
+
+                    IoCallDriver(dev->devobj, stripe->Irp);
+                }
+            }
+        }
+
+        i++;
+
+        le = le->Flink;
+    }
+
+    KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
+
+    for (i = 0; i < count; i++) {
+        ioctl_context_stripe* stripe = &context.stripes[i];
+
+        if (stripe->mdl)
+            IoFreeMdl(stripe->mdl);
+
+        if (stripe->buf)
+            ExFreePool(stripe->buf);
+    }
+
+    ExFreePool(context.stripes);
+}
+#endif
+
 static void clean_space_cache(device_extension* Vcb) {
     LIST_ENTRY* le;
     chunk* c;
+#ifndef DEBUG_TRIM_EMULATION
     ULONG num;
+#endif
 
     TRACE("(%p)\n", Vcb);
 
-    ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
     le = Vcb->chunks.Flink;
     while (le != &Vcb->chunks) {
@@ -321,7 +411,7 @@ static void clean_space_cache(device_extension* Vcb) {
             if (c->space_changed)
                 clean_space_cache_chunk(Vcb, c);
 
-            c->space_changed = FALSE;
+            c->space_changed = false;
 
             release_chunk_lock(c, Vcb);
         }
@@ -332,6 +422,7 @@ static void clean_space_cache(device_extension* Vcb) {
     ExReleaseResourceLite(&Vcb->chunk_lock);
 
     if (Vcb->trim && !Vcb->options.no_trim) {
+#ifndef DEBUG_TRIM_EMULATION
         ioctl_context context;
         ULONG total_num;
 
@@ -353,7 +444,7 @@ static void clean_space_cache(device_extension* Vcb) {
         total_num = context.left;
         num = 0;
 
-        KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+        KeInitializeEvent(&context.Event, NotificationEvent, false);
 
         context.stripes = ExAllocatePoolWithTag(NonPagedPool, sizeof(ioctl_context_stripe) * context.left, ALLOC_TAG);
         if (!context.stripes) {
@@ -362,16 +453,20 @@ static void clean_space_cache(device_extension* Vcb) {
         }
 
         RtlZeroMemory(context.stripes, sizeof(ioctl_context_stripe) * context.left);
+#endif
 
         le = Vcb->devices.Flink;
         while (le != &Vcb->devices) {
             device* dev = CONTAINING_RECORD(le, device, list_entry);
 
             if (dev->devobj && !dev->readonly && dev->trim && dev->num_trim_entries > 0) {
+#ifdef DEBUG_TRIM_EMULATION
+                trim_emulation(dev);
+#else
                 LIST_ENTRY* le2;
                 ioctl_context_stripe* stripe = &context.stripes[num];
                 DEVICE_DATA_SET_RANGE* ranges;
-                ULONG datalen = (ULONG)sector_align(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), sizeof(UINT64)) + (dev->num_trim_entries * sizeof(DEVICE_DATA_SET_RANGE)), i;
+                ULONG datalen = (ULONG)sector_align(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), sizeof(uint64_t)) + (dev->num_trim_entries * sizeof(DEVICE_DATA_SET_RANGE)), i;
                 PIO_STACK_LOCATION IrpSp;
 
                 stripe->dmdsa = ExAllocatePoolWithTag(PagedPool, datalen, ALLOC_TAG);
@@ -385,10 +480,10 @@ static void clean_space_cache(device_extension* Vcb) {
                 stripe->dmdsa->Flags = DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED;
                 stripe->dmdsa->ParameterBlockOffset = 0;
                 stripe->dmdsa->ParameterBlockLength = 0;
-                stripe->dmdsa->DataSetRangesOffset = (ULONG)sector_align(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), sizeof(UINT64));
+                stripe->dmdsa->DataSetRangesOffset = (ULONG)sector_align(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), sizeof(uint64_t));
                 stripe->dmdsa->DataSetRangesLength = dev->num_trim_entries * sizeof(DEVICE_DATA_SET_RANGE);
 
-                ranges = (DEVICE_DATA_SET_RANGE*)((UINT8*)stripe->dmdsa + stripe->dmdsa->DataSetRangesOffset);
+                ranges = (DEVICE_DATA_SET_RANGE*)((uint8_t*)stripe->dmdsa + stripe->dmdsa->DataSetRangesOffset);
 
                 i = 0;
 
@@ -403,7 +498,7 @@ static void clean_space_cache(device_extension* Vcb) {
                     le2 = le2->Flink;
                 }
 
-                stripe->Irp = IoAllocateIrp(dev->devobj->StackSize, FALSE);
+                stripe->Irp = IoAllocateIrp(dev->devobj->StackSize, false);
 
                 if (!stripe->Irp) {
                     ERR("IoAllocateIrp failed\n");
@@ -412,6 +507,7 @@ static void clean_space_cache(device_extension* Vcb) {
 
                 IrpSp = IoGetNextIrpStackLocation(stripe->Irp);
                 IrpSp->MajorFunction = IRP_MJ_DEVICE_CONTROL;
+                IrpSp->FileObject = dev->fileobj;
 
                 IrpSp->Parameters.DeviceIoControl.IoControlCode = IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES;
                 IrpSp->Parameters.DeviceIoControl.InputBufferLength = datalen;
@@ -422,11 +518,12 @@ static void clean_space_cache(device_extension* Vcb) {
                 stripe->Irp->UserBuffer = NULL;
                 stripe->Irp->UserIosb = &stripe->iosb;
 
-                IoSetCompletionRoutine(stripe->Irp, ioctl_completion, &context, TRUE, TRUE, TRUE);
+                IoSetCompletionRoutine(stripe->Irp, ioctl_completion, &context, true, true, true);
 
                 IoCallDriver(dev->devobj, stripe->Irp);
 
 nextdev:
+#endif
                 while (!IsListEmpty(&dev->trim_list)) {
                     space* s = CONTAINING_RECORD(RemoveHeadList(&dev->trim_list), space, list_entry);
                     ExFreePool(s);
@@ -434,13 +531,16 @@ nextdev:
 
                 dev->num_trim_entries = 0;
 
+#ifndef DEBUG_TRIM_EMULATION
                 num++;
+#endif
             }
 
             le = le->Flink;
         }
 
-        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+#ifndef DEBUG_TRIM_EMULATION
+        KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
 
         for (num = 0; num < total_num; num++) {
             if (context.stripes[num].dmdsa)
@@ -448,10 +548,11 @@ nextdev:
         }
 
         ExFreePool(context.stripes);
+#endif
     }
 }
 
-static BOOL trees_consistent(device_extension* Vcb) {
+static bool trees_consistent(device_extension* Vcb) {
     ULONG maxsize = Vcb->superblock.node_size - sizeof(tree_header);
     LIST_ENTRY* le;
 
@@ -464,28 +565,28 @@ static BOOL trees_consistent(device_extension* Vcb) {
 #ifdef DEBUG_WRITE_LOOPS
                 ERR("empty tree found, looping again\n");
 #endif
-                return FALSE;
+                return false;
             }
 
             if (t->size > maxsize) {
 #ifdef DEBUG_WRITE_LOOPS
                 ERR("overlarge tree found (%u > %u), looping again\n", t->size, maxsize);
 #endif
-                return FALSE;
+                return false;
             }
 
             if (!t->has_new_address) {
 #ifdef DEBUG_WRITE_LOOPS
                 ERR("tree found without new address, looping again\n");
 #endif
-                return FALSE;
+                return false;
             }
         }
 
         le = le->Flink;
     }
 
-    return TRUE;
+    return true;
 }
 
 static NTSTATUS add_parents(device_extension* Vcb, PIRP Irp) {
@@ -493,7 +594,7 @@ static NTSTATUS add_parents(device_extension* Vcb, PIRP Irp) {
     LIST_ENTRY* le;
 
     for (level = 0; level <= 255; level++) {
-        BOOL nothing_found = TRUE;
+        bool nothing_found = true;
 
         TRACE("level = %u\n", level);
 
@@ -502,15 +603,15 @@ static NTSTATUS add_parents(device_extension* Vcb, PIRP Irp) {
             tree* t = CONTAINING_RECORD(le, tree, list_entry);
 
             if (t->write && t->header.level == level) {
-                TRACE("tree %p: root = %llx, level = %x, parent = %p\n", t, t->header.tree_id, t->header.level, t->parent);
+                TRACE("tree %p: root = %I64x, level = %x, parent = %p\n", t, t->header.tree_id, t->header.level, t->parent);
 
-                nothing_found = FALSE;
+                nothing_found = false;
 
                 if (t->parent) {
                     if (!t->parent->write)
                         TRACE("adding tree %p (level %x)\n", t->parent, t->header.level);
 
-                    t->parent->write = TRUE;
+                    t->parent->write = true;
                 } else if (t->root != Vcb->root_root && t->root != Vcb->chunk_root) {
                     KEY searchkey;
                     traverse_ptr tp;
@@ -523,14 +624,14 @@ static NTSTATUS add_parents(device_extension* Vcb, PIRP Irp) {
                     searchkey.obj_type = TYPE_ROOT_ITEM;
                     searchkey.offset = 0xffffffffffffffff;
 
-                    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+                    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
                     if (!NT_SUCCESS(Status)) {
                         ERR("error - find_item returned %08x\n", Status);
                         return Status;
                     }
 
                     if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-                        ERR("could not find ROOT_ITEM for tree %llx\n", searchkey.obj_id);
+                        ERR("could not find ROOT_ITEM for tree %I64x\n", searchkey.obj_id);
                         return STATUS_INTERNAL_ERROR;
                     }
 
@@ -565,7 +666,7 @@ static NTSTATUS add_parents(device_extension* Vcb, PIRP Irp) {
                     t2 = tp.tree;
 #endif
                     while (t2) {
-                        t2->write = TRUE;
+                        t2->write = true;
 
                         t2 = t2->parent;
                     }
@@ -585,11 +686,11 @@ static NTSTATUS add_parents(device_extension* Vcb, PIRP Irp) {
 static void add_parents_to_cache(tree* t) {
     while (t->parent) {
         t = t->parent;
-        t->write = TRUE;
+        t->write = true;
     }
 }
 
-static BOOL insert_tree_extent_skinny(device_extension* Vcb, UINT8 level, UINT64 root_id, chunk* c, UINT64 address, PIRP Irp, LIST_ENTRY* rollback) {
+static bool insert_tree_extent_skinny(device_extension* Vcb, uint8_t level, uint64_t root_id, chunk* c, uint64_t address, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     EXTENT_ITEM_SKINNY_METADATA* eism;
     traverse_ptr insert_tp;
@@ -597,7 +698,7 @@ static BOOL insert_tree_extent_skinny(device_extension* Vcb, UINT8 level, UINT64
     eism = ExAllocatePoolWithTag(PagedPool, sizeof(EXTENT_ITEM_SKINNY_METADATA), ALLOC_TAG);
     if (!eism) {
         ERR("out of memory\n");
-        return FALSE;
+        return false;
     }
 
     eism->ei.refcount = 1;
@@ -610,51 +711,51 @@ static BOOL insert_tree_extent_skinny(device_extension* Vcb, UINT8 level, UINT64
     if (!NT_SUCCESS(Status)) {
         ERR("insert_tree_item returned %08x\n", Status);
         ExFreePool(eism);
-        return FALSE;
+        return false;
     }
 
     acquire_chunk_lock(c, Vcb);
 
-    space_list_subtract(c, FALSE, address, Vcb->superblock.node_size, rollback);
+    space_list_subtract(c, false, address, Vcb->superblock.node_size, rollback);
 
     release_chunk_lock(c, Vcb);
 
     add_parents_to_cache(insert_tp.tree);
 
-    return TRUE;
+    return true;
 }
 
-BOOL find_metadata_address_in_chunk(device_extension* Vcb, chunk* c, UINT64* address) {
+bool find_metadata_address_in_chunk(device_extension* Vcb, chunk* c, uint64_t* address) {
     LIST_ENTRY* le;
     space* s;
 
-    TRACE("(%p, %llx, %p)\n", Vcb, c->offset, address);
+    TRACE("(%p, %I64x, %p)\n", Vcb, c->offset, address);
 
     if (Vcb->superblock.node_size > c->chunk_item->size - c->used)
-        return FALSE;
+        return false;
 
     if (!c->cache_loaded) {
         NTSTATUS Status = load_cache_chunk(Vcb, c, NULL);
 
         if (!NT_SUCCESS(Status)) {
             ERR("load_cache_chunk returned %08x\n", Status);
-            return FALSE;
+            return false;
         }
     }
 
     if (IsListEmpty(&c->space_size))
-        return FALSE;
+        return false;
 
     if (!c->last_alloc_set) {
         s = CONTAINING_RECORD(c->space.Blink, space, list_entry);
 
         c->last_alloc = s->address;
-        c->last_alloc_set = TRUE;
+        c->last_alloc_set = true;
 
         if (s->size >= Vcb->superblock.node_size) {
             *address = s->address;
             c->last_alloc += Vcb->superblock.node_size;
-            return TRUE;
+            return true;
         }
     }
 
@@ -665,7 +766,7 @@ BOOL find_metadata_address_in_chunk(device_extension* Vcb, chunk* c, UINT64* add
         if (s->address <= c->last_alloc && s->address + s->size >= c->last_alloc + Vcb->superblock.node_size) {
             *address = c->last_alloc;
             c->last_alloc += Vcb->superblock.node_size;
-            return TRUE;
+            return true;
         }
 
         le = le->Flink;
@@ -678,17 +779,17 @@ BOOL find_metadata_address_in_chunk(device_extension* Vcb, chunk* c, UINT64* add
         if (s->size == Vcb->superblock.node_size) {
             *address = s->address;
             c->last_alloc = s->address + Vcb->superblock.node_size;
-            return TRUE;
+            return true;
         } else if (s->size < Vcb->superblock.node_size) {
             if (le == c->space_size.Flink)
-                return FALSE;
+                return false;
 
             s = CONTAINING_RECORD(le->Blink, space, list_entry_size);
 
             *address = s->address;
             c->last_alloc = s->address + Vcb->superblock.node_size;
 
-            return TRUE;
+            return true;
         }
 
         le = le->Flink;
@@ -699,25 +800,25 @@ BOOL find_metadata_address_in_chunk(device_extension* Vcb, chunk* c, UINT64* add
     if (s->size > Vcb->superblock.node_size) {
         *address = s->address;
         c->last_alloc = s->address + Vcb->superblock.node_size;
-        return TRUE;
+        return true;
     }
 
-    return FALSE;
+    return false;
 }
 
-static BOOL insert_tree_extent(device_extension* Vcb, UINT8 level, UINT64 root_id, chunk* c, UINT64* new_address, PIRP Irp, LIST_ENTRY* rollback) {
+static bool insert_tree_extent(device_extension* Vcb, uint8_t level, uint64_t root_id, chunk* c, uint64_t* new_address, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
-    UINT64 address;
+    uint64_t address;
     EXTENT_ITEM_TREE2* eit2;
     traverse_ptr insert_tp;
 
-    TRACE("(%p, %x, %llx, %p, %p, %p, %p)\n", Vcb, level, root_id, c, new_address, rollback);
+    TRACE("(%p, %x, %I64x, %p, %p, %p, %p)\n", Vcb, level, root_id, c, new_address, rollback);
 
     if (!find_metadata_address_in_chunk(Vcb, c, &address))
-        return FALSE;
+        return false;
 
     if (Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA) {
-        BOOL b = insert_tree_extent_skinny(Vcb, level, root_id, c, address, Irp, rollback);
+        bool b = insert_tree_extent_skinny(Vcb, level, root_id, c, address, Irp, rollback);
 
         if (b)
             *new_address = address;
@@ -728,7 +829,7 @@ static BOOL insert_tree_extent(device_extension* Vcb, UINT8 level, UINT64 root_i
     eit2 = ExAllocatePoolWithTag(PagedPool, sizeof(EXTENT_ITEM_TREE2), ALLOC_TAG);
     if (!eit2) {
         ERR("out of memory\n");
-        return FALSE;
+        return false;
     }
 
     eit2->eit.extent_item.refcount = 1;
@@ -742,12 +843,12 @@ static BOOL insert_tree_extent(device_extension* Vcb, UINT8 level, UINT64 root_i
     if (!NT_SUCCESS(Status)) {
         ERR("insert_tree_item returned %08x\n", Status);
         ExFreePool(eit2);
-        return FALSE;
+        return false;
     }
 
     acquire_chunk_lock(c, Vcb);
 
-    space_list_subtract(c, FALSE, address, Vcb->superblock.node_size, rollback);
+    space_list_subtract(c, false, address, Vcb->superblock.node_size, rollback);
 
     release_chunk_lock(c, Vcb);
 
@@ -755,14 +856,14 @@ static BOOL insert_tree_extent(device_extension* Vcb, UINT8 level, UINT64 root_i
 
     *new_address = address;
 
-    return TRUE;
+    return true;
 }
 
 NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     chunk *origchunk = NULL, *c;
     LIST_ENTRY* le;
-    UINT64 flags, addr;
+    uint64_t flags, addr;
 
     if (t->root->id == BTRFS_ROOT_CHUNK)
         flags = Vcb->system_flags;
@@ -775,12 +876,12 @@ NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENT
         if (origchunk && !origchunk->readonly && !origchunk->reloc && origchunk->chunk_item->type == flags &&
             insert_tree_extent(Vcb, t->header.level, t->root->id, origchunk, &addr, Irp, rollback)) {
             t->new_address = addr;
-            t->has_new_address = TRUE;
+            t->has_new_address = true;
             return STATUS_SUCCESS;
         }
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
     le = Vcb->chunks.Flink;
     while (le != &Vcb->chunks) {
@@ -794,7 +895,7 @@ NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENT
                     release_chunk_lock(c, Vcb);
                     ExReleaseResourceLite(&Vcb->chunk_lock);
                     t->new_address = addr;
-                    t->has_new_address = TRUE;
+                    t->has_new_address = true;
                     return STATUS_SUCCESS;
                 }
             }
@@ -807,7 +908,7 @@ NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENT
 
     // allocate new chunk if necessary
 
-    Status = alloc_chunk(Vcb, flags, &c, FALSE);
+    Status = alloc_chunk(Vcb, flags, &c, false);
 
     if (!NT_SUCCESS(Status)) {
         ERR("alloc_chunk returned %08x\n", Status);
@@ -822,7 +923,7 @@ NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENT
             release_chunk_lock(c, Vcb);
             ExReleaseResourceLite(&Vcb->chunk_lock);
             t->new_address = addr;
-            t->has_new_address = TRUE;
+            t->has_new_address = true;
             return STATUS_SUCCESS;
         }
     }
@@ -836,15 +937,15 @@ NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENT
     return STATUS_DISK_FULL;
 }
 
-static NTSTATUS reduce_tree_extent(device_extension* Vcb, UINT64 address, tree* t, UINT64 parent_root, UINT8 level, PIRP Irp, LIST_ENTRY* rollback) {
+static NTSTATUS reduce_tree_extent(device_extension* Vcb, uint64_t address, tree* t, uint64_t parent_root, uint8_t level, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
-    UINT64 rc, root;
+    uint64_t rc, root;
 
-    TRACE("(%p, %llx, %p)\n", Vcb, address, t);
+    TRACE("(%p, %I64x, %p)\n", Vcb, address, t);
 
     rc = get_extent_refcount(Vcb, address, Vcb->superblock.node_size, Irp);
     if (rc == 0) {
-        ERR("error - refcount for extent %llx was 0\n", address);
+        ERR("error - refcount for extent %I64x was 0\n", address);
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -881,13 +982,13 @@ static NTSTATUS reduce_tree_extent(device_extension* Vcb, UINT64 address, tree*
 
             release_chunk_lock(c, Vcb);
         } else
-            ERR("could not find chunk for address %llx\n", address);
+            ERR("could not find chunk for address %I64x\n", address);
     }
 
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS add_changed_extent_ref_edr(changed_extent* ce, EXTENT_DATA_REF* edr, BOOL old) {
+static NTSTATUS add_changed_extent_ref_edr(changed_extent* ce, EXTENT_DATA_REF* edr, bool old) {
     LIST_ENTRY *le2, *list;
     changed_extent_ref* cer;
 
@@ -924,7 +1025,7 @@ end:
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS add_changed_extent_ref_sdr(changed_extent* ce, SHARED_DATA_REF* sdr, BOOL old) {
+static NTSTATUS add_changed_extent_ref_sdr(changed_extent* ce, SHARED_DATA_REF* sdr, bool old) {
     LIST_ENTRY *le2, *list;
     changed_extent_ref* cer;
 
@@ -961,7 +1062,7 @@ end:
     return STATUS_SUCCESS;
 }
 
-static BOOL shared_tree_is_unique(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENTRY* rollback) {
+static bool shared_tree_is_unique(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENTRY* rollback) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
@@ -970,7 +1071,7 @@ static BOOL shared_tree_is_unique(device_extension* Vcb, tree* t, PIRP Irp, LIST
         Status = update_tree_extents(Vcb, t, Irp, rollback);
         if (!NT_SUCCESS(Status)) {
             ERR("update_tree_extents returned %08x\n", Status);
-            return FALSE;
+            return false;
         }
     }
 
@@ -978,31 +1079,31 @@ static BOOL shared_tree_is_unique(device_extension* Vcb, tree* t, PIRP Irp, LIST
     searchkey.obj_type = Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA ? TYPE_METADATA_ITEM : TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
     if (tp.item->key.obj_id == t->header.address && (tp.item->key.obj_type == TYPE_METADATA_ITEM || tp.item->key.obj_type == TYPE_EXTENT_ITEM))
-        return FALSE;
+        return false;
     else
-        return TRUE;
+        return true;
 }
 
 static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
-    UINT64 rc = get_extent_refcount(Vcb, t->header.address, Vcb->superblock.node_size, Irp);
-    UINT64 flags = get_extent_flags(Vcb, t->header.address, Irp);
+    uint64_t rc = get_extent_refcount(Vcb, t->header.address, Vcb->superblock.node_size, Irp);
+    uint64_t flags = get_extent_flags(Vcb, t->header.address, Irp);
 
     if (rc == 0) {
-        ERR("refcount for extent %llx was 0\n", t->header.address);
+        ERR("refcount for extent %I64x was 0\n", t->header.address);
         return STATUS_INTERNAL_ERROR;
     }
 
     if (flags & EXTENT_ITEM_SHARED_BACKREFS || t->header.flags & HEADER_FLAG_SHARED_BACKREF || !(t->header.flags & HEADER_FLAG_MIXED_BACKREF)) {
         TREE_BLOCK_REF tbr;
-        BOOL unique = rc > 1 ? FALSE : (t->parent ? shared_tree_is_unique(Vcb, t->parent, Irp, rollback) : FALSE);
+        bool unique = rc > 1 ? false : (t->parent ? shared_tree_is_unique(Vcb, t->parent, Irp, rollback) : false);
 
         if (t->header.level == 0) {
             LIST_ENTRY* le;
@@ -1044,13 +1145,13 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
                             edr.count = 1;
 
                             if (ce) {
-                                Status = add_changed_extent_ref_edr(ce, &edr, TRUE);
+                                Status = add_changed_extent_ref_edr(ce, &edr, true);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("add_changed_extent_ref_edr returned %08x\n", Status);
                                     return Status;
                                 }
 
-                                Status = add_changed_extent_ref_edr(ce, &edr, FALSE);
+                                Status = add_changed_extent_ref_edr(ce, &edr, false);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("add_changed_extent_ref_edr returned %08x\n", Status);
                                     return Status;
@@ -1064,7 +1165,7 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
                             }
 
                             if ((flags & EXTENT_ITEM_SHARED_BACKREFS && unique) || !(t->header.flags & HEADER_FLAG_MIXED_BACKREF)) {
-                                UINT64 sdrrc = find_extent_shared_data_refcount(Vcb, ed2->address, t->header.address, Irp);
+                                uint64_t sdrrc = find_extent_shared_data_refcount(Vcb, ed2->address, t->header.address, Irp);
 
                                 if (sdrrc > 0) {
                                     SHARED_DATA_REF sdr;
@@ -1073,7 +1174,7 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
                                     sdr.count = 1;
 
                                     Status = decrease_extent_refcount(Vcb, ed2->address, ed2->size, TYPE_SHARED_DATA_REF, &sdr, NULL, 0,
-                                                                      t->header.address, ce ? ce->superseded : FALSE, Irp);
+                                                                      t->header.address, ce ? ce->superseded : false, Irp);
                                     if (!NT_SUCCESS(Status)) {
                                         ERR("decrease_extent_refcount returned %08x\n", Status);
                                         return Status;
@@ -1143,7 +1244,7 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
                     }
 
                     if (unique || !(t->header.flags & HEADER_FLAG_MIXED_BACKREF)) {
-                        UINT64 sbrrc = find_extent_shared_tree_refcount(Vcb, td->treeholder.address, t->header.address, Irp);
+                        uint64_t sbrrc = find_extent_shared_tree_refcount(Vcb, td->treeholder.address, t->header.address, Irp);
 
                         if (sbrrc > 0) {
                             SHARED_BLOCK_REF sbr;
@@ -1151,7 +1252,7 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
                             sbr.offset = t->header.address;
 
                             Status = decrease_extent_refcount(Vcb, td->treeholder.address, Vcb->superblock.node_size, TYPE_SHARED_BLOCK_REF, &sbr, NULL, 0,
-                                                              t->header.address, FALSE, Irp);
+                                                              t->header.address, false, Irp);
                             if (!NT_SUCCESS(Status)) {
                                 ERR("decrease_extent_refcount returned %08x\n", Status);
                                 return Status;
@@ -1167,7 +1268,7 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
         }
 
         if (unique) {
-            UINT64 sbrrc = find_extent_shared_tree_refcount(Vcb, t->header.address, t->parent->header.address, Irp);
+            uint64_t sbrrc = find_extent_shared_tree_refcount(Vcb, t->header.address, t->parent->header.address, Irp);
 
             if (sbrrc == 1) {
                 SHARED_BLOCK_REF sbr;
@@ -1175,7 +1276,7 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
                 sbr.offset = t->parent->header.address;
 
                 Status = decrease_extent_refcount(Vcb, t->header.address, Vcb->superblock.node_size, TYPE_SHARED_BLOCK_REF, &sbr, NULL, 0,
-                                                  t->parent->header.address, FALSE, Irp);
+                                                  t->parent->header.address, false, Irp);
                 if (!NT_SUCCESS(Status)) {
                     ERR("decrease_extent_refcount returned %08x\n", Status);
                     return Status;
@@ -1209,7 +1310,7 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
         }
     }
 
-    t->has_address = FALSE;
+    t->has_address = false;
 
     if ((rc > 1 || t->header.tree_id != t->root->id) && !(flags & EXTENT_ITEM_SHARED_BACKREFS)) {
         if (t->header.tree_id == t->root->id) {
@@ -1287,13 +1388,13 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
                                 sdr.count = 1;
 
                                 if (ce) {
-                                    Status = add_changed_extent_ref_sdr(ce, &sdr, TRUE);
+                                    Status = add_changed_extent_ref_sdr(ce, &sdr, true);
                                     if (!NT_SUCCESS(Status)) {
                                         ERR("add_changed_extent_ref_edr returned %08x\n", Status);
                                         return Status;
                                     }
 
-                                    Status = add_changed_extent_ref_sdr(ce, &sdr, FALSE);
+                                    Status = add_changed_extent_ref_sdr(ce, &sdr, false);
                                     if (!NT_SUCCESS(Status)) {
                                         ERR("add_changed_extent_ref_edr returned %08x\n", Status);
                                         return Status;
@@ -1310,13 +1411,13 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
                                 edr.count = 1;
 
                                 if (ce) {
-                                    Status = add_changed_extent_ref_edr(ce, &edr, TRUE);
+                                    Status = add_changed_extent_ref_edr(ce, &edr, true);
                                     if (!NT_SUCCESS(Status)) {
                                         ERR("add_changed_extent_ref_edr returned %08x\n", Status);
                                         return Status;
                                     }
 
-                                    Status = add_changed_extent_ref_edr(ce, &edr, FALSE);
+                                    Status = add_changed_extent_ref_edr(ce, &edr, false);
                                     if (!NT_SUCCESS(Status)) {
                                         ERR("add_changed_extent_ref_edr returned %08x\n", Status);
                                         return Status;
@@ -1339,7 +1440,7 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
         }
     }
 
-    t->updated_extents = TRUE;
+    t->updated_extents = true;
     t->header.tree_id = t->root->id;
 
     return STATUS_SUCCESS;
@@ -1348,8 +1449,8 @@ static NTSTATUS update_tree_extents(device_extension* Vcb, tree* t, PIRP Irp, LI
 static NTSTATUS allocate_tree_extents(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback) {
     LIST_ENTRY* le;
     NTSTATUS Status;
-    BOOL changed = FALSE;
-    UINT8 max_level = 0, level;
+    bool changed = false;
+    uint8_t max_level = 0, level;
 
     TRACE("(%p)\n", Vcb);
 
@@ -1388,18 +1489,18 @@ static NTSTATUS allocate_tree_extents(device_extension* Vcb, PIRP Irp, LIST_ENTR
                 return Status;
             }
 
-            TRACE("allocated extent %llx\n", t->new_address);
+            TRACE("allocated extent %I64x\n", t->new_address);
 
             c = get_chunk_from_address(Vcb, t->new_address);
 
             if (c)
                 c->used += Vcb->superblock.node_size;
             else {
-                ERR("could not find chunk for address %llx\n", t->new_address);
+                ERR("could not find chunk for address %I64x\n", t->new_address);
                 return STATUS_INTERNAL_ERROR;
             }
 
-            changed = TRUE;
+            changed = true;
 
             if (t->header.level > max_level)
                 max_level = t->header.level;
@@ -1432,12 +1533,12 @@ static NTSTATUS allocate_tree_extents(device_extension* Vcb, PIRP Irp, LIST_ENTR
             break;
 
         level--;
-    } while (TRUE);
+    } while (true);
 
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS update_root_root(device_extension* Vcb, BOOL no_cache, PIRP Irp, LIST_ENTRY* rollback) {
+static NTSTATUS update_root_root(device_extension* Vcb, bool no_cache, PIRP Irp, LIST_ENTRY* rollback) {
     LIST_ENTRY* le;
     NTSTATUS Status;
 
@@ -1456,18 +1557,18 @@ static NTSTATUS update_root_root(device_extension* Vcb, BOOL no_cache, PIRP Irp,
                 searchkey.obj_type = TYPE_ROOT_ITEM;
                 searchkey.offset = 0xffffffffffffffff;
 
-                Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+                Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
                 if (!NT_SUCCESS(Status)) {
                     ERR("error - find_item returned %08x\n", Status);
                     return Status;
                 }
 
                 if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-                    ERR("could not find ROOT_ITEM for tree %llx\n", searchkey.obj_id);
+                    ERR("could not find ROOT_ITEM for tree %I64x\n", searchkey.obj_id);
                     return STATUS_INTERNAL_ERROR;
                 }
 
-                TRACE("updating the address for root %llx to %llx\n", searchkey.obj_id, t->new_address);
+                TRACE("updating the address for root %I64x to %I64x\n", searchkey.obj_id, t->new_address);
 
                 t->root->root_item.block_number = t->new_address;
                 t->root->root_item.root_level = t->header.level;
@@ -1487,7 +1588,7 @@ static NTSTATUS update_root_root(device_extension* Vcb, BOOL no_cache, PIRP Irp,
     }
 
     if (!no_cache && !(Vcb->superblock.compat_ro_flags & BTRFS_COMPAT_RO_FLAGS_FREE_SPACE_CACHE)) {
-        ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+        ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
         Status = update_chunk_caches(Vcb, Irp, rollback);
         ExReleaseResourceLite(&Vcb->chunk_lock);
 
@@ -1500,7 +1601,7 @@ static NTSTATUS update_root_root(device_extension* Vcb, BOOL no_cache, PIRP Irp,
     return STATUS_SUCCESS;
 }
 
-NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, BOOL no_free) {
+NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, bool no_free) {
     chunk* c;
     LIST_ENTRY* le;
     tree_write* tw;
@@ -1508,7 +1609,7 @@ NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, BOOL no_
     ULONG i, num_bits;
     write_data_context* wtc;
     ULONG bit_num = 0;
-    BOOL raid56 = FALSE;
+    bool raid56 = false;
 
     // merge together runs
     c = NULL;
@@ -1522,7 +1623,7 @@ NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, BOOL no_
             tree_write* tw2 = CONTAINING_RECORD(le->Blink, tree_write, list_entry);
 
             if (tw->address == tw2->address + tw2->length) {
-                UINT8* data = ExAllocatePoolWithTag(NonPagedPool, tw2->length + tw->length, ALLOC_TAG);
+                uint8_t* data = ExAllocatePoolWithTag(NonPagedPool, tw2->length + tw->length, ALLOC_TAG);
 
                 if (!data) {
                     ERR("out of memory\n");
@@ -1552,7 +1653,7 @@ NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, BOOL no_
         tw->c = c;
 
         if (c->chunk_item->type & (BLOCK_FLAG_RAID5 | BLOCK_FLAG_RAID6))
-            raid56 = TRUE;
+            raid56 = true;
 
         le = le->Flink;
     }
@@ -1579,16 +1680,16 @@ NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, BOOL no_
     while (le != tree_writes) {
         tw = CONTAINING_RECORD(le, tree_write, list_entry);
 
-        TRACE("address: %llx, size: %x\n", tw->address, tw->length);
+        TRACE("address: %I64x, size: %x\n", tw->address, tw->length);
 
-        KeInitializeEvent(&wtc[bit_num].Event, NotificationEvent, FALSE);
+        KeInitializeEvent(&wtc[bit_num].Event, NotificationEvent, false);
         InitializeListHead(&wtc[bit_num].stripes);
-        wtc[bit_num].need_wait = FALSE;
+        wtc[bit_num].need_wait = false;
         wtc[bit_num].stripes_left = 0;
         wtc[bit_num].parity1 = wtc[bit_num].parity2 = wtc[bit_num].scratch = NULL;
         wtc[bit_num].mdl = wtc[bit_num].parity1_mdl = wtc[bit_num].parity2_mdl = NULL;
 
-        Status = write_data(Vcb, tw->address, tw->data, tw->length, &wtc[bit_num], NULL, NULL, FALSE, 0, HighPagePriority);
+        Status = write_data(Vcb, tw->address, tw->data, tw->length, &wtc[bit_num], NULL, NULL, false, 0, HighPagePriority);
         if (!NT_SUCCESS(Status)) {
             ERR("write_data returned %08x\n", Status);
 
@@ -1613,7 +1714,7 @@ NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, BOOL no_
                 write_data_stripe* stripe = CONTAINING_RECORD(le, write_data_stripe, list_entry);
 
                 if (stripe->status != WriteDataStatus_Ignore) {
-                    wtc[i].need_wait = TRUE;
+                    wtc[i].need_wait = true;
                     IoCallDriver(stripe->device->devobj, stripe->Irp);
                 }
 
@@ -1624,7 +1725,7 @@ NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, BOOL no_
 
     for (i = 0; i < num_bits; i++) {
         if (wtc[i].need_wait)
-            KeWaitForSingleObject(&wtc[i].Event, Executive, KernelMode, FALSE, NULL);
+            KeWaitForSingleObject(&wtc[i].Event, Executive, KernelMode, false, NULL);
     }
 
     for (i = 0; i < num_bits; i++) {
@@ -1656,7 +1757,7 @@ NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, BOOL no_
             if (tw->c != c) {
                 c = tw->c;
 
-                ExAcquireResourceExclusiveLite(&c->partial_stripes_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&c->partial_stripes_lock, true);
 
                 while (!IsListEmpty(&c->partial_stripes)) {
                     partial_stripe* ps = CONTAINING_RECORD(RemoveHeadList(&c->partial_stripes), partial_stripe, list_entry);
@@ -1687,8 +1788,8 @@ NTSTATUS do_tree_writes(device_extension* Vcb, LIST_ENTRY* tree_writes, BOOL no_
 
 static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
     ULONG level;
-    UINT8 *data, *body;
-    UINT32 crc32;
+    uint8_t *data, *body;
+    uint32_t crc32;
     NTSTATUS Status;
     LIST_ENTRY* le;
     LIST_ENTRY tree_writes;
@@ -1699,7 +1800,7 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
     InitializeListHead(&tree_writes);
 
     for (level = 0; level <= 255; level++) {
-        BOOL nothing_found = TRUE;
+        bool nothing_found = true;
 
         TRACE("level = %u\n", level);
 
@@ -1740,19 +1841,19 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
                     searchkey.obj_type = TYPE_EXTENT_ITEM;
                     searchkey.offset = Vcb->superblock.node_size;
 
-                    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+                    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
                     if (!NT_SUCCESS(Status)) {
                         ERR("error - find_item returned %08x\n", Status);
                         return Status;
                     }
 
                     if (keycmp(searchkey, tp.item->key)) {
-                        ERR("could not find %llx,%x,%llx in extent_root (found %llx,%x,%llx instead)\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset, tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                        ERR("could not find %I64x,%x,%I64x in extent_root (found %I64x,%x,%I64x instead)\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset, tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
                         return STATUS_INTERNAL_ERROR;
                     }
 
                     if (tp.item->size < sizeof(EXTENT_ITEM_TREE)) {
-                        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM_TREE));
+                        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM_TREE));
                         return STATUS_INTERNAL_ERROR;
                     }
 
@@ -1760,7 +1861,7 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
                     eit->firstitem = firstitem;
                 }
 
-                nothing_found = FALSE;
+                nothing_found = false;
             }
 
             le = le->Flink;
@@ -1777,13 +1878,13 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
         tree* t = CONTAINING_RECORD(le, tree, list_entry);
         LIST_ENTRY* le2;
 #ifdef DEBUG_PARANOID
-        UINT32 num_items = 0, size = 0;
-        BOOL crash = FALSE;
+        uint32_t num_items = 0, size = 0;
+        bool crash = false;
 #endif
 
         if (t->write) {
 #ifdef DEBUG_PARANOID
-            BOOL first = TRUE;
+            bool first = true;
             KEY lastkey;
 
             le2 = t->itemlist.Flink;
@@ -1794,14 +1895,14 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
 
                     if (!first) {
                         if (keycmp(td->key, lastkey) == 0) {
-                            ERR("(%llx,%x,%llx): duplicate key\n", td->key.obj_id, td->key.obj_type, td->key.offset);
-                            crash = TRUE;
+                            ERR("(%I64x,%x,%I64x): duplicate key\n", td->key.obj_id, td->key.obj_type, td->key.offset);
+                            crash = true;
                         } else if (keycmp(td->key, lastkey) == -1) {
-                            ERR("(%llx,%x,%llx): key out of order\n", td->key.obj_id, td->key.obj_type, td->key.offset);
-                            crash = TRUE;
+                            ERR("(%I64x,%x,%I64x): key out of order\n", td->key.obj_id, td->key.obj_type, td->key.offset);
+                            crash = true;
                         }
                     } else
-                        first = FALSE;
+                        first = false;
 
                     lastkey = td->key;
 
@@ -1817,23 +1918,23 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
                 size += num_items * sizeof(internal_node);
 
             if (num_items != t->header.num_items) {
-                ERR("tree %llx, level %x: num_items was %x, expected %x\n", t->root->id, t->header.level, num_items, t->header.num_items);
-                crash = TRUE;
+                ERR("tree %I64x, level %x: num_items was %x, expected %x\n", t->root->id, t->header.level, num_items, t->header.num_items);
+                crash = true;
             }
 
             if (size != t->size) {
-                ERR("tree %llx, level %x: size was %x, expected %x\n", t->root->id, t->header.level, size, t->size);
-                crash = TRUE;
+                ERR("tree %I64x, level %x: size was %x, expected %x\n", t->root->id, t->header.level, size, t->size);
+                crash = true;
             }
 
             if (t->header.num_items == 0 && t->parent) {
-                ERR("tree %llx, level %x: tried to write empty tree with parent\n", t->root->id, t->header.level);
-                crash = TRUE;
+                ERR("tree %I64x, level %x: tried to write empty tree with parent\n", t->root->id, t->header.level);
+                crash = true;
             }
 
             if (t->size > Vcb->superblock.node_size - sizeof(tree_header)) {
-                ERR("tree %llx, level %x: tried to write overlarge tree (%x > %x)\n", t->root->id, t->header.level, t->size, Vcb->superblock.node_size - sizeof(tree_header));
-                crash = TRUE;
+                ERR("tree %I64x, level %x: tried to write overlarge tree (%x > %x)\n", t->root->id, t->header.level, t->size, Vcb->superblock.node_size - sizeof(tree_header));
+                crash = true;
             }
 
             if (crash) {
@@ -1842,7 +1943,7 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
                 while (le2 != &t->itemlist) {
                     tree_data* td = CONTAINING_RECORD(le2, tree_data, list_entry);
                     if (!td->ignore) {
-                        ERR("%llx,%x,%llx inserted=%u\n", td->key.obj_id, td->key.obj_type, td->key.offset, td->inserted);
+                        ERR("%I64x,%x,%I64x inserted=%u\n", td->key.obj_id, td->key.obj_type, td->key.offset, td->inserted);
                     }
                     le2 = le2->Flink;
                 }
@@ -1854,7 +1955,7 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
             t->header.tree_id = t->root->id;
             t->header.flags |= HEADER_FLAG_MIXED_BACKREF;
             t->header.fs_uuid = Vcb->superblock.uuid;
-            t->has_address = TRUE;
+            t->has_address = true;
 
             data = ExAllocatePoolWithTag(NonPagedPool, Vcb->superblock.node_size, ALLOC_TAG);
             if (!data) {
@@ -1871,7 +1972,7 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
             if (t->header.level == 0) {
                 leaf_node* itemptr = (leaf_node*)body;
                 int i = 0;
-                UINT8* dataptr = data + Vcb->superblock.node_size;
+                uint8_t* dataptr = data + Vcb->superblock.node_size;
 
                 le2 = t->itemlist.Flink;
                 while (le2 != &t->itemlist) {
@@ -1880,7 +1981,7 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
                         dataptr = dataptr - td->size;
 
                         itemptr[i].key = td->key;
-                        itemptr[i].offset = (UINT32)((UINT8*)dataptr - (UINT8*)body);
+                        itemptr[i].offset = (uint32_t)((uint8_t*)dataptr - (uint8_t*)body);
                         itemptr[i].size = td->size;
                         i++;
 
@@ -1908,9 +2009,9 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
                 }
             }
 
-            crc32 = calc_crc32c(0xffffffff, (UINT8*)&((tree_header*)data)->fs_uuid, Vcb->superblock.node_size - sizeof(((tree_header*)data)->csum));
+            crc32 = calc_crc32c(0xffffffff, (uint8_t*)&((tree_header*)data)->fs_uuid, Vcb->superblock.node_size - sizeof(((tree_header*)data)->csum));
             crc32 = ~crc32;
-            *((UINT32*)data) = crc32;
+            *((uint32_t*)data) = crc32;
             TRACE("setting crc32 to %08x\n", crc32);
 
             tw = ExAllocatePoolWithTag(PagedPool, sizeof(tree_write), ALLOC_TAG);
@@ -1928,7 +2029,7 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
             if (IsListEmpty(&tree_writes))
                 InsertTailList(&tree_writes, &tw->list_entry);
             else {
-                BOOL inserted = FALSE;
+                bool inserted = false;
 
                 le2 = tree_writes.Flink;
                 while (le2 != &tree_writes) {
@@ -1936,7 +2037,7 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
 
                     if (tw2->address > tw->address) {
                         InsertHeadList(le2->Blink, &tw->list_entry);
-                        inserted = TRUE;
+                        inserted = true;
                         break;
                     }
 
@@ -1951,7 +2052,7 @@ static NTSTATUS write_trees(device_extension* Vcb, PIRP Irp) {
         le = le->Flink;
     }
 
-    Status = do_tree_writes(Vcb, &tree_writes, FALSE);
+    Status = do_tree_writes(Vcb, &tree_writes, false);
     if (!NT_SUCCESS(Status)) {
         ERR("do_tree_writes returned %08x\n", Status);
         goto end;
@@ -1991,7 +2092,7 @@ static void update_backup_superblock(device_extension* Vcb, superblock_backup* s
     searchkey.obj_type = TYPE_ROOT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    if (NT_SUCCESS(find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp))) {
+    if (NT_SUCCESS(find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp))) {
         if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type && tp.item->size >= sizeof(ROOT_ITEM)) {
             ROOT_ITEM* ri = (ROOT_ITEM*)tp.item->data;
 
@@ -2003,7 +2104,7 @@ static void update_backup_superblock(device_extension* Vcb, superblock_backup* s
 
     searchkey.obj_id = BTRFS_ROOT_FSTREE;
 
-    if (NT_SUCCESS(find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp))) {
+    if (NT_SUCCESS(find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp))) {
         if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type && tp.item->size >= sizeof(ROOT_ITEM)) {
             ROOT_ITEM* ri = (ROOT_ITEM*)tp.item->data;
 
@@ -2015,7 +2116,7 @@ static void update_backup_superblock(device_extension* Vcb, superblock_backup* s
 
     searchkey.obj_id = BTRFS_ROOT_DEVTREE;
 
-    if (NT_SUCCESS(find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp))) {
+    if (NT_SUCCESS(find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp))) {
         if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type && tp.item->size >= sizeof(ROOT_ITEM)) {
             ROOT_ITEM* ri = (ROOT_ITEM*)tp.item->data;
 
@@ -2027,7 +2128,7 @@ static void update_backup_superblock(device_extension* Vcb, superblock_backup* s
 
     searchkey.obj_id = BTRFS_ROOT_CHECKSUM;
 
-    if (NT_SUCCESS(find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp))) {
+    if (NT_SUCCESS(find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp))) {
         if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type && tp.item->size >= sizeof(ROOT_ITEM)) {
             ROOT_ITEM* ri = (ROOT_ITEM*)tp.item->data;
 
@@ -2044,7 +2145,7 @@ static void update_backup_superblock(device_extension* Vcb, superblock_backup* s
 
 typedef struct {
     void* context;
-    UINT8* buf;
+    uint8_t* buf;
     PMDL mdl;
     device* device;
     NTSTATUS Status;
@@ -2059,11 +2160,7 @@ typedef struct _write_superblocks_context {
 } write_superblocks_context;
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI write_superblock_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#else
-static NTSTATUS write_superblock_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#endif
+static NTSTATUS __stdcall write_superblock_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
     write_superblocks_stripe* stripe = conptr;
     write_superblocks_context* context = stripe->context;
 
@@ -2072,7 +2169,7 @@ static NTSTATUS write_superblock_completion(PDEVICE_OBJECT DeviceObject, PIRP Ir
     stripe->Status = Irp->IoStatus.Status;
 
     if (InterlockedDecrement(&context->left) == 0)
-        KeSetEvent(&context->Event, 0, FALSE);
+        KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
@@ -2086,7 +2183,7 @@ static NTSTATUS write_superblock(device_extension* Vcb, device* device, write_su
     while (superblock_addrs[i] > 0 && device->devitem.num_bytes >= superblock_addrs[i] + sizeof(superblock)) {
         ULONG sblen = (ULONG)sector_align(sizeof(superblock), Vcb->superblock.sector_size);
         superblock* sb;
-        UINT32 crc32;
+        uint32_t crc32;
         write_superblocks_stripe* stripe;
         PIO_STACK_LOCATION IrpSp;
 
@@ -2099,13 +2196,13 @@ static NTSTATUS write_superblock(device_extension* Vcb, device* device, write_su
         RtlCopyMemory(sb, &Vcb->superblock, sizeof(superblock));
 
         if (sblen > sizeof(superblock))
-            RtlZeroMemory((UINT8*)sb + sizeof(superblock), sblen - sizeof(superblock));
+            RtlZeroMemory((uint8_t*)sb + sizeof(superblock), sblen - sizeof(superblock));
 
         RtlCopyMemory(&sb->dev_item, &device->devitem, sizeof(DEV_ITEM));
         sb->sb_phys_addr = superblock_addrs[i];
 
-        crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
-        RtlCopyMemory(&sb->checksum, &crc32, sizeof(UINT32));
+        crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
+        RtlCopyMemory(&sb->checksum, &crc32, sizeof(uint32_t));
 
         stripe = ExAllocatePoolWithTag(NonPagedPool, sizeof(write_superblocks_stripe), ALLOC_TAG);
         if (!stripe) {
@@ -2114,9 +2211,9 @@ static NTSTATUS write_superblock(device_extension* Vcb, device* device, write_su
             return STATUS_INSUFFICIENT_RESOURCES;
         }
 
-        stripe->buf = (UINT8*)sb;
+        stripe->buf = (uint8_t*)sb;
 
-        stripe->Irp = IoAllocateIrp(device->devobj->StackSize, FALSE);
+        stripe->Irp = IoAllocateIrp(device->devobj->StackSize, false);
         if (!stripe->Irp) {
             ERR("IoAllocateIrp failed\n");
             ExFreePool(stripe);
@@ -2126,6 +2223,7 @@ static NTSTATUS write_superblock(device_extension* Vcb, device* device, write_su
 
         IrpSp = IoGetNextIrpStackLocation(stripe->Irp);
         IrpSp->MajorFunction = IRP_MJ_WRITE;
+        IrpSp->FileObject = device->fileobj;
 
         if (i == 0)
             IrpSp->Flags |= SL_WRITE_THROUGH;
@@ -2136,7 +2234,7 @@ static NTSTATUS write_superblock(device_extension* Vcb, device* device, write_su
 
             stripe->Irp->Flags = IRP_BUFFERED_IO;
         } else if (device->devobj->Flags & DO_DIRECT_IO) {
-            stripe->mdl = IoAllocateMdl(sb, sblen, FALSE, FALSE, NULL);
+            stripe->mdl = IoAllocateMdl(sb, sblen, false, false, NULL);
             if (!stripe->mdl) {
                 ERR("IoAllocateMdl failed\n");
                 IoFreeIrp(stripe->Irp);
@@ -2156,7 +2254,7 @@ static NTSTATUS write_superblock(device_extension* Vcb, device* device, write_su
         IrpSp->Parameters.Write.Length = sblen;
         IrpSp->Parameters.Write.ByteOffset.QuadPart = superblock_addrs[i];
 
-        IoSetCompletionRoutine(stripe->Irp, write_superblock_completion, stripe, TRUE, TRUE, TRUE);
+        IoSetCompletionRoutine(stripe->Irp, write_superblock_completion, stripe, true, true, true);
 
         stripe->context = context;
         stripe->device = device;
@@ -2174,7 +2272,7 @@ static NTSTATUS write_superblock(device_extension* Vcb, device* device, write_su
 }
 
 static NTSTATUS write_superblocks(device_extension* Vcb, PIRP Irp) {
-    UINT64 i;
+    uint64_t i;
     NTSTATUS Status;
     LIST_ENTRY* le;
     write_superblocks_context context;
@@ -2205,7 +2303,7 @@ static NTSTATUS write_superblocks(device_extension* Vcb, PIRP Irp) {
 
     update_backup_superblock(Vcb, &Vcb->superblock.backup[BTRFS_NUM_BACKUP_ROOTS - 1], Irp);
 
-    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&context.Event, NotificationEvent, false);
     InitializeListHead(&context.stripes);
     context.left = 0;
 
@@ -2239,14 +2337,14 @@ static NTSTATUS write_superblocks(device_extension* Vcb, PIRP Irp) {
         le = le->Flink;
     }
 
-    KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+    KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
 
     le = context.stripes.Flink;
     while (le != &context.stripes) {
         write_superblocks_stripe* stripe = CONTAINING_RECORD(le, write_superblocks_stripe, list_entry);
 
         if (!NT_SUCCESS(stripe->Status)) {
-            ERR("device %llx returned %08x\n", stripe->device->devitem.dev_id, stripe->Status);
+            ERR("device %I64x returned %08x\n", stripe->device->devitem.dev_id, stripe->Status);
             log_device_error(Vcb, stripe->device, BTRFS_DEV_STAT_WRITE_ERRORS);
             Status = stripe->Status;
             goto end;
@@ -2283,7 +2381,7 @@ end:
 static NTSTATUS flush_changed_extent(device_extension* Vcb, chunk* c, changed_extent* ce, PIRP Irp, LIST_ENTRY* rollback) {
     LIST_ENTRY *le, *le2;
     NTSTATUS Status;
-    UINT64 old_size;
+    uint64_t old_size;
 
     if (ce->count == 0 && ce->old_count == 0) {
         while (!IsListEmpty(&ce->refs)) {
@@ -2302,7 +2400,7 @@ static NTSTATUS flush_changed_extent(device_extension* Vcb, chunk* c, changed_ex
     le = ce->refs.Flink;
     while (le != &ce->refs) {
         changed_extent_ref* cer = CONTAINING_RECORD(le, changed_extent_ref, list_entry);
-        UINT32 old_count = 0;
+        uint32_t old_count = 0;
 
         if (cer->type == TYPE_EXTENT_DATA_REF) {
             le2 = ce->old_refs.Flink;
@@ -2349,7 +2447,7 @@ static NTSTATUS flush_changed_extent(device_extension* Vcb, chunk* c, changed_ex
     while (le != &ce->refs) {
         changed_extent_ref* cer = CONTAINING_RECORD(le, changed_extent_ref, list_entry);
         LIST_ENTRY* le3 = le->Flink;
-        UINT32 old_count = 0;
+        uint32_t old_count = 0;
 
         if (cer->type == TYPE_EXTENT_DATA_REF) {
             le2 = ce->old_refs.Flink;
@@ -2388,14 +2486,14 @@ static NTSTATUS flush_changed_extent(device_extension* Vcb, chunk* c, changed_ex
                 searchkey.obj_type = TYPE_EXTENT_ITEM;
                 searchkey.offset = ce->old_size;
 
-                Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+                Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
                 if (!NT_SUCCESS(Status)) {
                     ERR("error - find_item returned %08x\n", Status);
                     return Status;
                 }
 
                 if (keycmp(searchkey, tp.item->key)) {
-                    ERR("could not find (%llx,%x,%llx) in extent tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+                    ERR("could not find (%I64x,%x,%I64x) in extent tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
                     return STATUS_INTERNAL_ERROR;
                 }
 
@@ -2449,43 +2547,45 @@ end:
     return STATUS_SUCCESS;
 }
 
-void add_checksum_entry(device_extension* Vcb, UINT64 address, ULONG length, UINT32* csum, PIRP Irp) {
+void add_checksum_entry(device_extension* Vcb, uint64_t address, ULONG length, uint32_t* csum, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp, next_tp;
     NTSTATUS Status;
-    UINT64 startaddr, endaddr;
+    uint64_t startaddr, endaddr;
     ULONG len;
-    UINT32* checksums;
+    uint32_t* checksums;
     RTL_BITMAP bmp;
     ULONG* bmparr;
     ULONG runlength, index;
 
+    TRACE("(%p, %I64x, %x, %p, %p)\n", Vcb, address, length, csum, Irp);
+
     searchkey.obj_id = EXTENT_CSUM_ID;
     searchkey.obj_type = TYPE_EXTENT_CSUM;
     searchkey.offset = address;
 
     // FIXME - create checksum_root if it doesn't exist at all
 
-    Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
     if (Status == STATUS_NOT_FOUND) { // tree is completely empty
         if (csum) { // not deleted
             ULONG length2 = length;
-            UINT64 off = address;
-            UINT32* data = csum;
+            uint64_t off = address;
+            uint32_t* data = csum;
 
             do {
-                UINT16 il = (UINT16)min(length2, MAX_CSUM_SIZE / sizeof(UINT32));
+                uint16_t il = (uint16_t)min(length2, MAX_CSUM_SIZE / sizeof(uint32_t));
 
-                checksums = ExAllocatePoolWithTag(PagedPool, il * sizeof(UINT32), ALLOC_TAG);
+                checksums = ExAllocatePoolWithTag(PagedPool, il * sizeof(uint32_t), ALLOC_TAG);
                 if (!checksums) {
                     ERR("out of memory\n");
                     return;
                 }
 
-                RtlCopyMemory(checksums, data, il * sizeof(UINT32));
+                RtlCopyMemory(checksums, data, il * sizeof(uint32_t));
 
                 Status = insert_tree_item(Vcb, Vcb->checksum_root, EXTENT_CSUM_ID, TYPE_EXTENT_CSUM, off, checksums,
-                                          il * sizeof(UINT32), NULL, Irp);
+                                          il * sizeof(uint32_t), NULL, Irp);
                 if (!NT_SUCCESS(Status)) {
                     ERR("insert_tree_item returned %08x\n", Status);
                     ExFreePool(checksums);
@@ -2504,11 +2604,11 @@ void add_checksum_entry(device_extension* Vcb, UINT64 address, ULONG length, UIN
         ERR("find_item returned %08x\n", Status);
         return;
     } else {
-        UINT32 tplen;
+        uint32_t tplen;
 
         // FIXME - check entry is TYPE_EXTENT_CSUM?
 
-        if (tp.item->key.offset < address && tp.item->key.offset + (tp.item->size * Vcb->superblock.sector_size / sizeof(UINT32)) >= address)
+        if (tp.item->key.offset < address && tp.item->key.offset + (tp.item->size * Vcb->superblock.sector_size / sizeof(uint32_t)) >= address)
             startaddr = tp.item->key.offset;
         else
             startaddr = address;
@@ -2517,26 +2617,26 @@ void add_checksum_entry(device_extension* Vcb, UINT64 address, ULONG length, UIN
         searchkey.obj_type = TYPE_EXTENT_CSUM;
         searchkey.offset = address + (length * Vcb->superblock.sector_size);
 
-        Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
             return;
         }
 
-        tplen = tp.item->size / sizeof(UINT32);
+        tplen = tp.item->size / sizeof(uint32_t);
 
         if (tp.item->key.offset + (tplen * Vcb->superblock.sector_size) >= address + (length * Vcb->superblock.sector_size))
             endaddr = tp.item->key.offset + (tplen * Vcb->superblock.sector_size);
         else
             endaddr = address + (length * Vcb->superblock.sector_size);
 
-        TRACE("cs starts at %llx (%x sectors)\n", address, length);
-        TRACE("startaddr = %llx\n", startaddr);
-        TRACE("endaddr = %llx\n", endaddr);
+        TRACE("cs starts at %I64x (%x sectors)\n", address, length);
+        TRACE("startaddr = %I64x\n", startaddr);
+        TRACE("endaddr = %I64x\n", endaddr);
 
         len = (ULONG)((endaddr - startaddr) / Vcb->superblock.sector_size);
 
-        checksums = ExAllocatePoolWithTag(PagedPool, sizeof(UINT32) * len, ALLOC_TAG);
+        checksums = ExAllocatePoolWithTag(PagedPool, sizeof(uint32_t) * len, ALLOC_TAG);
         if (!checksums) {
             ERR("out of memory\n");
             return;
@@ -2556,7 +2656,7 @@ void add_checksum_entry(device_extension* Vcb, UINT64 address, ULONG length, UIN
         searchkey.obj_type = TYPE_EXTENT_CSUM;
         searchkey.offset = address;
 
-        Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
             ExFreePool(checksums);
@@ -2569,10 +2669,10 @@ void add_checksum_entry(device_extension* Vcb, UINT64 address, ULONG length, UIN
         while (tp.item->key.offset < endaddr) {
             if (tp.item->key.offset >= startaddr) {
                 if (tp.item->size > 0) {
-                    ULONG itemlen = (ULONG)min((len - (tp.item->key.offset - startaddr) / Vcb->superblock.sector_size) * sizeof(UINT32), tp.item->size);
+                    ULONG itemlen = (ULONG)min((len - (tp.item->key.offset - startaddr) / Vcb->superblock.sector_size) * sizeof(uint32_t), tp.item->size);
 
                     RtlCopyMemory(&checksums[(tp.item->key.offset - startaddr) / Vcb->superblock.sector_size], tp.item->data, itemlen);
-                    RtlClearBits(&bmp, (ULONG)((tp.item->key.offset - startaddr) / Vcb->superblock.sector_size), itemlen / sizeof(UINT32));
+                    RtlClearBits(&bmp, (ULONG)((tp.item->key.offset - startaddr) / Vcb->superblock.sector_size), itemlen / sizeof(uint32_t));
                 }
 
                 Status = delete_tree_item(Vcb, &tp);
@@ -2584,7 +2684,7 @@ void add_checksum_entry(device_extension* Vcb, UINT64 address, ULONG length, UIN
                 }
             }
 
-            if (find_next_item(Vcb, &tp, &next_tp, FALSE, Irp)) {
+            if (find_next_item(Vcb, &tp, &next_tp, false, Irp)) {
                 tp = next_tp;
             } else
                 break;
@@ -2593,24 +2693,34 @@ void add_checksum_entry(device_extension* Vcb, UINT64 address, ULONG length, UIN
         if (!csum) { // deleted
             RtlSetBits(&bmp, (ULONG)((address - startaddr) / Vcb->superblock.sector_size), length);
         } else {
-            RtlCopyMemory(&checksums[(address - startaddr) / Vcb->superblock.sector_size], csum, length * sizeof(UINT32));
+            RtlCopyMemory(&checksums[(address - startaddr) / Vcb->superblock.sector_size], csum, length * sizeof(uint32_t));
             RtlClearBits(&bmp, (ULONG)((address - startaddr) / Vcb->superblock.sector_size), length);
         }
 
         runlength = RtlFindFirstRunClear(&bmp, &index);
 
         while (runlength != 0) {
+            if (index >= len)
+                break;
+
+            if (index + runlength >= len) {
+                runlength = len - index;
+
+                if (runlength == 0)
+                    break;
+            }
+
             do {
-                UINT16 rl;
-                UINT64 off;
-                UINT32* data;
+                uint16_t rl;
+                uint64_t off;
+                uint32_t* data;
 
-                if (runlength * sizeof(UINT32) > MAX_CSUM_SIZE)
-                    rl = MAX_CSUM_SIZE / sizeof(UINT32);
+                if (runlength * sizeof(uint32_t) > MAX_CSUM_SIZE)
+                    rl = MAX_CSUM_SIZE / sizeof(uint32_t);
                 else
-                    rl = (UINT16)runlength;
+                    rl = (uint16_t)runlength;
 
-                data = ExAllocatePoolWithTag(PagedPool, sizeof(UINT32) * rl, ALLOC_TAG);
+                data = ExAllocatePoolWithTag(PagedPool, sizeof(uint32_t) * rl, ALLOC_TAG);
                 if (!data) {
                     ERR("out of memory\n");
                     ExFreePool(bmparr);
@@ -2618,11 +2728,11 @@ void add_checksum_entry(device_extension* Vcb, UINT64 address, ULONG length, UIN
                     return;
                 }
 
-                RtlCopyMemory(data, &checksums[index], sizeof(UINT32) * rl);
+                RtlCopyMemory(data, &checksums[index], sizeof(uint32_t) * rl);
 
                 off = startaddr + UInt32x32To64(index, Vcb->superblock.sector_size);
 
-                Status = insert_tree_item(Vcb, Vcb->checksum_root, EXTENT_CSUM_ID, TYPE_EXTENT_CSUM, off, data, sizeof(UINT32) * rl, NULL, Irp);
+                Status = insert_tree_item(Vcb, Vcb->checksum_root, EXTENT_CSUM_ID, TYPE_EXTENT_CSUM, off, data, sizeof(uint32_t) * rl, NULL, Irp);
                 if (!NT_SUCCESS(Status)) {
                     ERR("insert_tree_item returned %08x\n", Status);
                     ExFreePool(data);
@@ -2653,7 +2763,7 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY*
 
     TRACE("(%p)\n", Vcb);
 
-    ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
     while (le != &Vcb->chunks) {
         c = CONTAINING_RECORD(le, chunk, list_entry);
@@ -2702,7 +2812,7 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY*
 
                 InitializeListHead(&batchlist);
 
-                Status = flush_fcb(c->old_cache, FALSE, &batchlist, Irp);
+                Status = flush_fcb(c->old_cache, false, &batchlist, Irp);
                 if (!NT_SUCCESS(Status)) {
                     ERR("flush_fcb returned %08x\n", Status);
                     release_chunk_lock(c, Vcb);
@@ -2728,13 +2838,13 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY*
 
         if (c->used != c->oldused) {
 #ifdef __REACTOS__
-            UINT64 old_phys_used, phys_used;
+            uint64_t old_phys_used, phys_used;
 #endif
             searchkey.obj_id = c->offset;
             searchkey.obj_type = TYPE_BLOCK_GROUP_ITEM;
             searchkey.offset = c->chunk_item->size;
 
-            Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+            Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
             if (!NT_SUCCESS(Status)) {
                 ERR("error - find_item returned %08x\n", Status);
                 release_chunk_lock(c, Vcb);
@@ -2742,14 +2852,14 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY*
             }
 
             if (keycmp(searchkey, tp.item->key)) {
-                ERR("could not find (%llx,%x,%llx) in extent_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+                ERR("could not find (%I64x,%x,%I64x) in extent_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
                 Status = STATUS_INTERNAL_ERROR;
                 release_chunk_lock(c, Vcb);
                 goto end;
             }
 
             if (tp.item->size < sizeof(BLOCK_GROUP_ITEM)) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(BLOCK_GROUP_ITEM));
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(BLOCK_GROUP_ITEM));
                 Status = STATUS_INTERNAL_ERROR;
                 release_chunk_lock(c, Vcb);
                 goto end;
@@ -2766,7 +2876,14 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY*
             RtlCopyMemory(bgi, tp.item->data, tp.item->size);
             bgi->used = c->used;
 
-            TRACE("adjusting usage of chunk %llx to %llx\n", c->offset, c->used);
+#ifdef DEBUG_PARANOID
+            if (bgi->used & 0x8000000000000000) {
+                ERR("refusing to write BLOCK_GROUP_ITEM with negative usage value (%I64x)", bgi->used);
+                int3;
+            }
+#endif
+
+            TRACE("adjusting usage of chunk %I64x to %I64x\n", c->offset, c->used);
 
             Status = delete_tree_item(Vcb, &tp);
             if (!NT_SUCCESS(Status)) {
@@ -2785,8 +2902,8 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY*
             }
 
 #ifndef __REACTOS__
-            UINT64 old_phys_used = chunk_estimate_phys_size(Vcb, c, c->oldused);
-            UINT64 phys_used = chunk_estimate_phys_size(Vcb, c, c->used);
+            uint64_t old_phys_used = chunk_estimate_phys_size(Vcb, c, c->oldused);
+            uint64_t phys_used = chunk_estimate_phys_size(Vcb, c, c->used);
 #else
             old_phys_used = chunk_estimate_phys_size(Vcb, c, c->oldused);
             phys_used = chunk_estimate_phys_size(Vcb, c, c->used);
@@ -2825,12 +2942,12 @@ static void get_first_item(tree* t, KEY* key) {
     }
 }
 
-static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirstitem, UINT32 numitems, UINT32 size) {
+static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirstitem, uint32_t numitems, uint32_t size) {
     tree *nt, *pt;
     tree_data* td;
     tree_data* oldlastitem;
 
-    TRACE("splitting tree in %llx at (%llx,%x,%llx)\n", t->root->id, newfirstitem->key.obj_id, newfirstitem->key.obj_type, newfirstitem->key.offset);
+    TRACE("splitting tree in %I64x at (%I64x,%x,%I64x)\n", t->root->id, newfirstitem->key.obj_id, newfirstitem->key.obj_type, newfirstitem->key.offset);
 
     nt = ExAllocatePoolWithTag(PagedPool, sizeof(tree), ALLOC_TAG);
     if (!nt) {
@@ -2856,7 +2973,7 @@ static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirs
     nt->header.num_items = t->header.num_items - numitems;
     nt->header.flags = HEADER_FLAG_MIXED_BACKREF | HEADER_FLAG_WRITTEN;
 
-    nt->has_address = FALSE;
+    nt->has_address = false;
     nt->Vcb = Vcb;
     nt->parent = t->parent;
 
@@ -2866,10 +2983,10 @@ static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirs
 
     nt->root = t->root;
     nt->new_address = 0;
-    nt->has_new_address = FALSE;
-    nt->updated_extents = FALSE;
-    nt->uniqueness_determined = TRUE;
-    nt->is_unique = TRUE;
+    nt->has_new_address = false;
+    nt->updated_extents = false;
+    nt->uniqueness_determined = true;
+    nt->is_unique = true;
     nt->list_entry_hash.Flink = NULL;
     nt->buf = NULL;
     InitializeListHead(&nt->itemlist);
@@ -2887,7 +3004,7 @@ static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirs
     nt->size = t->size - size;
     t->size = size;
     t->header.num_items = numitems;
-    nt->write = TRUE;
+    nt->write = true;
 
     InsertTailList(&Vcb->trees, &nt->list_entry);
 
@@ -2913,7 +3030,7 @@ static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirs
             tree_data* td2 = CONTAINING_RECORD(le, tree_data, list_entry);
 
             if (!td2->inserted && td2->data) {
-                UINT8* data = ExAllocatePoolWithTag(PagedPool, td2->size, ALLOC_TAG);
+                uint8_t* data = ExAllocatePoolWithTag(PagedPool, td2->size, ALLOC_TAG);
 
                 if (!data) {
                     ERR("out of memory\n");
@@ -2922,7 +3039,7 @@ static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirs
 
                 RtlCopyMemory(data, td2->data, td2->size);
                 td2->data = data;
-                td2->inserted = TRUE;
+                td2->inserted = true;
             }
 
             le = le->Flink;
@@ -2940,8 +3057,8 @@ static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirs
 
         InsertHeadList(&t->paritem->list_entry, &td->list_entry);
 
-        td->ignore = FALSE;
-        td->inserted = TRUE;
+        td->ignore = false;
+        td->inserted = true;
         td->treeholder.tree = nt;
         nt->paritem = td;
 
@@ -2979,17 +3096,17 @@ static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirs
     pt->header.level = nt->header.level + 1;
     pt->header.flags = HEADER_FLAG_MIXED_BACKREF | HEADER_FLAG_WRITTEN;
 
-    pt->has_address = FALSE;
+    pt->has_address = false;
     pt->Vcb = Vcb;
     pt->parent = NULL;
     pt->paritem = NULL;
     pt->root = t->root;
     pt->new_address = 0;
-    pt->has_new_address = FALSE;
-    pt->updated_extents = FALSE;
+    pt->has_new_address = false;
+    pt->updated_extents = false;
     pt->size = pt->header.num_items * sizeof(internal_node);
-    pt->uniqueness_determined = TRUE;
-    pt->is_unique = TRUE;
+    pt->uniqueness_determined = true;
+    pt->is_unique = true;
     pt->list_entry_hash.Flink = NULL;
     pt->buf = NULL;
     InitializeListHead(&pt->itemlist);
@@ -3003,8 +3120,8 @@ static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirs
     }
 
     get_first_item(t, &td->key);
-    td->ignore = FALSE;
-    td->inserted = FALSE;
+    td->ignore = false;
+    td->inserted = false;
     td->treeholder.address = 0;
     td->treeholder.generation = Vcb->superblock.generation;
     td->treeholder.tree = t;
@@ -3018,15 +3135,15 @@ static NTSTATUS split_tree_at(device_extension* Vcb, tree* t, tree_data* newfirs
     }
 
     td->key = newfirstitem->key;
-    td->ignore = FALSE;
-    td->inserted = FALSE;
+    td->ignore = false;
+    td->inserted = false;
     td->treeholder.address = 0;
     td->treeholder.generation = Vcb->superblock.generation;
     td->treeholder.tree = nt;
     InsertTailList(&pt->itemlist, &td->list_entry);
     nt->paritem = td;
 
-    pt->write = TRUE;
+    pt->write = true;
 
     t->root->treeholder.tree = pt;
 
@@ -3046,7 +3163,7 @@ end:
 
 static NTSTATUS split_tree(device_extension* Vcb, tree* t) {
     LIST_ENTRY* le;
-    UINT32 size, ds, numitems;
+    uint32_t size, ds, numitems;
 
     size = 0;
     numitems = 0;
@@ -3064,7 +3181,7 @@ static NTSTATUS split_tree(device_extension* Vcb, tree* t) {
                 ds = sizeof(internal_node);
 
             if (numitems == 0 && ds > Vcb->superblock.node_size - sizeof(tree_header)) {
-                ERR("(%llx,%x,%llx) in tree %llx is too large (%x > %x)\n",
+                ERR("(%I64x,%x,%I64x) in tree %I64x is too large (%x > %x)\n",
                     td->key.obj_id, td->key.obj_type, td->key.offset, t->root->id,
                     ds, Vcb->superblock.node_size - sizeof(tree_header));
                 return STATUS_INTERNAL_ERROR;
@@ -3084,13 +3201,13 @@ static NTSTATUS split_tree(device_extension* Vcb, tree* t) {
     return STATUS_SUCCESS;
 }
 
-BOOL is_tree_unique(device_extension* Vcb, tree* t, PIRP Irp) {
+bool is_tree_unique(device_extension* Vcb, tree* t, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
-    BOOL ret = FALSE;
+    bool ret = false;
     EXTENT_ITEM* ei;
-    UINT8* type;
+    uint8_t* type;
 
     if (t->uniqueness_determined)
         return t->is_unique;
@@ -3103,7 +3220,7 @@ BOOL is_tree_unique(device_extension* Vcb, tree* t, PIRP Irp) {
         searchkey.obj_type = Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA ? TYPE_METADATA_ITEM : TYPE_EXTENT_ITEM;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             goto end;
@@ -3130,32 +3247,32 @@ BOOL is_tree_unique(device_extension* Vcb, tree* t, PIRP Irp) {
                 goto end;
 
             ei2 = (EXTENT_ITEM2*)&ei[1];
-            type = (UINT8*)&ei2[1];
+            type = (uint8_t*)&ei2[1];
         } else
-            type = (UINT8*)&ei[1];
+            type = (uint8_t*)&ei[1];
 
         if (type >= tp.item->data + tp.item->size || *type != TYPE_TREE_BLOCK_REF)
             goto end;
     }
 
-    ret = TRUE;
+    ret = true;
 
 end:
     t->is_unique = ret;
-    t->uniqueness_determined = TRUE;
+    t->uniqueness_determined = true;
 
     return ret;
 }
 
-static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done, BOOL* done_deletions, PIRP Irp, LIST_ENTRY* rollback) {
+static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, bool* done, bool* done_deletions, PIRP Irp, LIST_ENTRY* rollback) {
     LIST_ENTRY* le;
     tree_data* nextparitem = NULL;
     NTSTATUS Status;
     tree *next_tree, *par;
 
-    *done = FALSE;
+    *done = false;
 
-    TRACE("trying to amalgamate tree in root %llx, level %x (size %u)\n", t->root->id, t->header.level, t->size);
+    TRACE("trying to amalgamate tree in root %I64x, level %x (size %u)\n", t->root->id, t->header.level, t->size);
 
     // FIXME - doesn't capture everything, as it doesn't ascend
     le = t->paritem->list_entry.Flink;
@@ -3173,7 +3290,7 @@ static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done,
     if (!nextparitem)
         return STATUS_SUCCESS;
 
-    TRACE("nextparitem: key = %llx,%x,%llx\n", nextparitem->key.obj_id, nextparitem->key.obj_type, nextparitem->key.offset);
+    TRACE("nextparitem: key = %I64x,%x,%I64x\n", nextparitem->key.obj_id, nextparitem->key.obj_type, nextparitem->key.offset);
 
     if (!nextparitem->treeholder.tree) {
         Status = do_load_tree(Vcb, &nextparitem->treeholder, t->root, t->parent, nextparitem, NULL);
@@ -3215,7 +3332,7 @@ static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done,
 #endif
                 }
 
-                td2->inserted = TRUE;
+                td2->inserted = true;
                 le = le->Flink;
             }
         } else {
@@ -3225,7 +3342,7 @@ static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done,
                 tree_data* td2 = CONTAINING_RECORD(le, tree_data, list_entry);
 
                 if (!td2->inserted && td2->data) {
-                    UINT8* data = ExAllocatePoolWithTag(PagedPool, td2->size, ALLOC_TAG);
+                    uint8_t* data = ExAllocatePoolWithTag(PagedPool, td2->size, ALLOC_TAG);
 
                     if (!data) {
                         ERR("out of memory\n");
@@ -3234,7 +3351,7 @@ static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done,
 
                     RtlCopyMemory(data, td2->data, td2->size);
                     td2->data = data;
-                    td2->inserted = TRUE;
+                    td2->inserted = true;
                 }
 
                 le = le->Flink;
@@ -3268,16 +3385,16 @@ static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done,
         }
 
         if (!nextparitem->ignore) {
-            nextparitem->ignore = TRUE;
+            nextparitem->ignore = true;
             next_tree->parent->header.num_items--;
             next_tree->parent->size -= sizeof(internal_node);
 
-            *done_deletions = TRUE;
+            *done_deletions = true;
         }
 
         par = next_tree->parent;
         while (par) {
-            par->write = TRUE;
+            par->write = true;
             par = par->parent;
         }
 
@@ -3289,12 +3406,12 @@ static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done,
 
         free_tree(next_tree);
 
-        *done = TRUE;
+        *done = true;
     } else {
         // rebalance by moving items from second tree into first
         ULONG avg_size = (t->size + next_tree->size) / 2;
         KEY firstitem = {0, 0, 0};
-        BOOL changed = FALSE;
+        bool changed = false;
 
         TRACE("attempting rebalance\n");
 
@@ -3321,7 +3438,7 @@ static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done,
                     if (td->treeholder.tree->parent && td->treeholder.tree->parent->header.level <= td->treeholder.tree->header.level) int3;
 #endif
                 } else if (next_tree->header.level == 0 && !td->inserted && td->size > 0) {
-                    UINT8* data = ExAllocatePoolWithTag(PagedPool, td->size, ALLOC_TAG);
+                    uint8_t* data = ExAllocatePoolWithTag(PagedPool, td->size, ALLOC_TAG);
 
                     if (!data) {
                         ERR("out of memory\n");
@@ -3332,7 +3449,7 @@ static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done,
                     td->data = data;
                 }
 
-                td->inserted = TRUE;
+                td->inserted = true;
 
                 if (!td->ignore) {
                     next_tree->size -= size;
@@ -3341,7 +3458,7 @@ static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done,
                     t->header.num_items++;
                 }
 
-                changed = TRUE;
+                changed = true;
             } else
                 break;
 
@@ -3366,18 +3483,18 @@ static NTSTATUS try_tree_amalgamate(device_extension* Vcb, tree* t, BOOL* done,
 
         par = next_tree;
         while (par) {
-            par->write = TRUE;
+            par->write = true;
             par = par->parent;
         }
 
         if (changed)
-            *done = TRUE;
+            *done = true;
     }
 
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS update_extent_level(device_extension* Vcb, UINT64 address, tree* t, UINT8 level, PIRP Irp) {
+static NTSTATUS update_extent_level(device_extension* Vcb, uint64_t address, tree* t, uint8_t level, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
@@ -3387,7 +3504,7 @@ static NTSTATUS update_extent_level(device_extension* Vcb, UINT64 address, tree*
         searchkey.obj_type = TYPE_METADATA_ITEM;
         searchkey.offset = t->header.level;
 
-        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
@@ -3430,7 +3547,7 @@ static NTSTATUS update_extent_level(device_extension* Vcb, UINT64 address, tree*
     searchkey.obj_type = TYPE_EXTENT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
@@ -3440,7 +3557,7 @@ static NTSTATUS update_extent_level(device_extension* Vcb, UINT64 address, tree*
         EXTENT_ITEM_TREE* eit;
 
         if (tp.item->size < sizeof(EXTENT_ITEM_TREE)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM_TREE));
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM_TREE));
             return STATUS_INTERNAL_ERROR;
         }
 
@@ -3472,7 +3589,7 @@ static NTSTATUS update_extent_level(device_extension* Vcb, UINT64 address, tree*
         return STATUS_SUCCESS;
     }
 
-    ERR("could not find EXTENT_ITEM for address %llx\n", address);
+    ERR("could not find EXTENT_ITEM for address %I64x\n", address);
 
     return STATUS_INTERNAL_ERROR;
 }
@@ -3497,8 +3614,8 @@ static NTSTATUS update_tree_extents_recursive(device_extension* Vcb, tree* t, PI
 
 static NTSTATUS do_splits(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback) {
     ULONG level, max_level;
-    UINT32 min_size;
-    BOOL empty, done_deletions = FALSE;
+    uint32_t min_size;
+    bool empty, done_deletions = false;
     NTSTATUS Status;
     tree* t;
 
@@ -3509,7 +3626,7 @@ static NTSTATUS do_splits(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
     for (level = 0; level <= 255; level++) {
         LIST_ENTRY *le, *nextle;
 
-        empty = TRUE;
+        empty = true;
 
         TRACE("doing level %u\n", level);
 
@@ -3521,13 +3638,13 @@ static NTSTATUS do_splits(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
             nextle = le->Flink;
 
             if (t->write && t->header.level == level) {
-                empty = FALSE;
+                empty = false;
 
                 if (t->header.num_items == 0) {
                     if (t->parent) {
-                        done_deletions = TRUE;
+                        done_deletions = true;
 
-                        TRACE("deleting tree in root %llx\n", t->root->id);
+                        TRACE("deleting tree in root %I64x\n", t->root->id);
 
                         t->root->root_item.bytes_used -= Vcb->superblock.node_size;
 
@@ -3539,7 +3656,7 @@ static NTSTATUS do_splits(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
                                 return Status;
                             }
 
-                            t->has_new_address = FALSE;
+                            t->has_new_address = false;
                         } else if (t->has_address) {
                             Status = reduce_tree_extent(Vcb,t->header.address, t, t->parent->header.tree_id, t->header.level, Irp, rollback);
 
@@ -3548,11 +3665,11 @@ static NTSTATUS do_splits(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
                                 return Status;
                             }
 
-                            t->has_address = FALSE;
+                            t->has_address = false;
                         }
 
                         if (!t->paritem->ignore) {
-                            t->paritem->ignore = TRUE;
+                            t->paritem->ignore = true;
                             t->parent->header.num_items--;
                             t->parent->size -= sizeof(internal_node);
                         }
@@ -3617,7 +3734,7 @@ static NTSTATUS do_splits(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
 
             if (t->write && t->header.level == level && t->header.num_items > 0 && t->parent && t->size < min_size &&
                 t->root->id != BTRFS_ROOT_FREE_SPACE && is_tree_unique(Vcb, t, Irp)) {
-                BOOL done;
+                bool done;
 
                 do {
                     Status = try_tree_amalgamate(Vcb, t, &done, &done_deletions, Irp, rollback);
@@ -3656,7 +3773,7 @@ static NTSTATUS do_splits(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
                             le2 = le2->Flink;
                         }
 
-                        TRACE("deleting top-level tree in root %llx with one item\n", t->root->id);
+                        TRACE("deleting top-level tree in root %I64x with one item\n", t->root->id);
 
                         if (t->has_new_address) { // delete associated EXTENT_ITEM
                             Status = reduce_tree_extent(Vcb, t->new_address, t, t->header.tree_id, t->header.level, Irp, rollback);
@@ -3666,7 +3783,7 @@ static NTSTATUS do_splits(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
                                 return Status;
                             }
 
-                            t->has_new_address = FALSE;
+                            t->has_new_address = false;
                         } else if (t->has_address) {
                             Status = reduce_tree_extent(Vcb,t->header.address, t, t->header.tree_id, t->header.level, Irp, rollback);
 
@@ -3675,14 +3792,14 @@ static NTSTATUS do_splits(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
                                 return Status;
                             }
 
-                            t->has_address = FALSE;
+                            t->has_address = false;
                         }
 
                         if (!td->treeholder.tree) { // load first item if not already loaded
                             KEY searchkey = {0,0,0};
                             traverse_ptr tp;
 
-                            Status = find_item(Vcb, t->root, &tp, &searchkey, FALSE, Irp);
+                            Status = find_item(Vcb, t->root, &tp, &searchkey, false, Irp);
                             if (!NT_SUCCESS(Status)) {
                                 ERR("error - find_item returned %08x\n", Status);
                                 return Status;
@@ -3713,11 +3830,11 @@ static NTSTATUS do_splits(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS remove_root_extents(device_extension* Vcb, root* r, tree_holder* th, UINT8 level, tree* parent, PIRP Irp, LIST_ENTRY* rollback) {
+static NTSTATUS remove_root_extents(device_extension* Vcb, root* r, tree_holder* th, uint8_t level, tree* parent, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
 
     if (!th->tree) {
-        UINT8* buf;
+        uint8_t* buf;
         chunk* c;
 
         buf = ExAllocatePoolWithTag(PagedPool, Vcb->superblock.node_size, ALLOC_TAG);
@@ -3726,8 +3843,8 @@ static NTSTATUS remove_root_extents(device_extension* Vcb, root* r, tree_holder*
             return STATUS_INSUFFICIENT_RESOURCES;
         }
 
-        Status = read_data(Vcb, th->address, Vcb->superblock.node_size, NULL, TRUE, buf, NULL,
-                           &c, Irp, th->generation, FALSE, NormalPagePriority);
+        Status = read_data(Vcb, th->address, Vcb->superblock.node_size, NULL, true, buf, NULL,
+                           &c, Irp, th->generation, false, NormalPagePriority);
         if (!NT_SUCCESS(Status)) {
             ERR("read_data returned 0x%08x\n", Status);
             ExFreePool(buf);
@@ -3740,7 +3857,7 @@ static NTSTATUS remove_root_extents(device_extension* Vcb, root* r, tree_holder*
             ExFreePool(buf);
 
         if (!NT_SUCCESS(Status)) {
-            ERR("load_tree(%llx) returned %08x\n", th->address, Status);
+            ERR("load_tree(%I64x) returned %08x\n", th->address, Status);
             return Status;
         }
     }
@@ -3776,7 +3893,7 @@ static NTSTATUS remove_root_extents(device_extension* Vcb, root* r, tree_holder*
         Status = reduce_tree_extent(Vcb, th->address, NULL, parent ? parent->header.tree_id : r->id, level, Irp, rollback);
 
         if (!NT_SUCCESS(Status)) {
-            ERR("reduce_tree_extent(%llx) returned %08x\n", th->address, Status);
+            ERR("reduce_tree_extent(%I64x) returned %08x\n", th->address, Status);
             return Status;
         }
     }
@@ -3797,12 +3914,12 @@ static NTSTATUS drop_root(device_extension* Vcb, root* r, PIRP Irp, LIST_ENTRY*
 
     // remove entries in uuid root (tree 9)
     if (Vcb->uuid_root) {
-        RtlCopyMemory(&searchkey.obj_id, &r->root_item.uuid.uuid[0], sizeof(UINT64));
+        RtlCopyMemory(&searchkey.obj_id, &r->root_item.uuid.uuid[0], sizeof(uint64_t));
         searchkey.obj_type = TYPE_SUBVOL_UUID;
-        RtlCopyMemory(&searchkey.offset, &r->root_item.uuid.uuid[sizeof(UINT64)], sizeof(UINT64));
+        RtlCopyMemory(&searchkey.offset, &r->root_item.uuid.uuid[sizeof(uint64_t)], sizeof(uint64_t));
 
         if (searchkey.obj_id != 0 || searchkey.offset != 0) {
-            Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
+            Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, false, Irp);
             if (!NT_SUCCESS(Status)) {
                 WARN("find_item returned %08x\n", Status);
             } else {
@@ -3813,22 +3930,22 @@ static NTSTATUS drop_root(device_extension* Vcb, root* r, PIRP Irp, LIST_ENTRY*
                         return Status;
                     }
                 } else
-                    WARN("could not find (%llx,%x,%llx) in uuid tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+                    WARN("could not find (%I64x,%x,%I64x) in uuid tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
             }
         }
 
         if (r->root_item.rtransid > 0) {
-            RtlCopyMemory(&searchkey.obj_id, &r->root_item.received_uuid.uuid[0], sizeof(UINT64));
+            RtlCopyMemory(&searchkey.obj_id, &r->root_item.received_uuid.uuid[0], sizeof(uint64_t));
             searchkey.obj_type = TYPE_SUBVOL_REC_UUID;
-            RtlCopyMemory(&searchkey.offset, &r->root_item.received_uuid.uuid[sizeof(UINT64)], sizeof(UINT64));
+            RtlCopyMemory(&searchkey.offset, &r->root_item.received_uuid.uuid[sizeof(uint64_t)], sizeof(uint64_t));
 
-            Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
+            Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, false, Irp);
             if (!NT_SUCCESS(Status))
                 WARN("find_item returned %08x\n", Status);
             else {
                 if (!keycmp(tp.item->key, searchkey)) {
-                    if (tp.item->size == sizeof(UINT64)) {
-                        UINT64* id = (UINT64*)tp.item->data;
+                    if (tp.item->size == sizeof(uint64_t)) {
+                        uint64_t* id = (uint64_t*)tp.item->data;
 
                         if (*id == r->id) {
                             Status = delete_tree_item(Vcb, &tp);
@@ -3837,25 +3954,25 @@ static NTSTATUS drop_root(device_extension* Vcb, root* r, PIRP Irp, LIST_ENTRY*
                                 return Status;
                             }
                         }
-                    } else if (tp.item->size > sizeof(UINT64)) {
+                    } else if (tp.item->size > sizeof(uint64_t)) {
                         ULONG i;
-                        UINT64* ids = (UINT64*)tp.item->data;
+                        uint64_t* ids = (uint64_t*)tp.item->data;
 
-                        for (i = 0; i < tp.item->size / sizeof(UINT64); i++) {
+                        for (i = 0; i < tp.item->size / sizeof(uint64_t); i++) {
                             if (ids[i] == r->id) {
-                                UINT64* ne;
+                                uint64_t* ne;
 
-                                ne = ExAllocatePoolWithTag(PagedPool, tp.item->size - sizeof(UINT64), ALLOC_TAG);
+                                ne = ExAllocatePoolWithTag(PagedPool, tp.item->size - sizeof(uint64_t), ALLOC_TAG);
                                 if (!ne) {
                                     ERR("out of memory\n");
                                     return STATUS_INSUFFICIENT_RESOURCES;
                                 }
 
                                 if (i > 0)
-                                    RtlCopyMemory(ne, ids, sizeof(UINT64) * i);
+                                    RtlCopyMemory(ne, ids, sizeof(uint64_t) * i);
 
-                                if ((i + 1) * sizeof(UINT64) < tp.item->size)
-                                    RtlCopyMemory(&ne[i], &ids[i + 1], tp.item->size - ((i + 1) * sizeof(UINT64)));
+                                if ((i + 1) * sizeof(uint64_t) < tp.item->size)
+                                    RtlCopyMemory(&ne[i], &ids[i + 1], tp.item->size - ((i + 1) * sizeof(uint64_t)));
 
                                 Status = delete_tree_item(Vcb, &tp);
                                 if (!NT_SUCCESS(Status)) {
@@ -3865,7 +3982,7 @@ static NTSTATUS drop_root(device_extension* Vcb, root* r, PIRP Irp, LIST_ENTRY*
                                 }
 
                                 Status = insert_tree_item(Vcb, Vcb->uuid_root, tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
-                                                          ne, tp.item->size - sizeof(UINT64), NULL, Irp);
+                                                          ne, tp.item->size - sizeof(uint64_t), NULL, Irp);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("insert_tree_item returned %08x\n", Status);
                                     ExFreePool(ne);
@@ -3877,7 +3994,7 @@ static NTSTATUS drop_root(device_extension* Vcb, root* r, PIRP Irp, LIST_ENTRY*
                         }
                     }
                 } else
-                    WARN("could not find (%llx,%x,%llx) in uuid tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+                    WARN("could not find (%I64x,%x,%I64x) in uuid tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
             }
         }
     }
@@ -3888,7 +4005,7 @@ static NTSTATUS drop_root(device_extension* Vcb, root* r, PIRP Irp, LIST_ENTRY*
     searchkey.obj_type = TYPE_ROOT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
@@ -3902,7 +4019,7 @@ static NTSTATUS drop_root(device_extension* Vcb, root* r, PIRP Irp, LIST_ENTRY*
             return Status;
         }
     } else
-        WARN("could not find (%llx,%x,%llx) in root_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+        WARN("could not find (%I64x,%x,%I64x) in root_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
 
     // delete items in tree cache
 
@@ -3922,7 +4039,7 @@ static NTSTATUS drop_roots(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback
 
         Status = drop_root(Vcb, r, Irp, rollback);
         if (!NT_SUCCESS(Status)) {
-            ERR("drop_root(%llx) returned %08x\n", r->id, Status);
+            ERR("drop_root(%I64x) returned %08x\n", r->id, Status);
             return Status;
         }
 
@@ -3942,14 +4059,14 @@ NTSTATUS update_dev_item(device_extension* Vcb, device* device, PIRP Irp) {
     searchkey.obj_type = TYPE_DEV_ITEM;
     searchkey.offset = device->devitem.dev_id;
 
-    Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
     }
 
     if (keycmp(tp.item->key, searchkey)) {
-        ERR("error - could not find DEV_ITEM for device %llx\n", device->devitem.dev_id);
+        ERR("error - could not find DEV_ITEM for device %I64x\n", device->devitem.dev_id);
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -3987,7 +4104,7 @@ static void regen_bootstrap(device_extension* Vcb) {
     while (le != &Vcb->sys_chunks) {
         sc2 = CONTAINING_RECORD(le, sys_chunk, list_entry);
 
-        TRACE("%llx,%x,%llx\n", sc2->key.obj_id, sc2->key.obj_type, sc2->key.offset);
+        TRACE("%I64x,%x,%I64x\n", sc2->key.obj_id, sc2->key.obj_type, sc2->key.offset);
 
         RtlCopyMemory(&Vcb->superblock.sys_chunk_array[i], &sc2->key, sizeof(KEY));
         i += sizeof(KEY);
@@ -3999,7 +4116,7 @@ static void regen_bootstrap(device_extension* Vcb) {
     }
 }
 
-static NTSTATUS add_to_bootstrap(device_extension* Vcb, UINT64 obj_id, UINT8 obj_type, UINT64 offset, void* data, UINT16 size) {
+static NTSTATUS add_to_bootstrap(device_extension* Vcb, uint64_t obj_id, uint8_t obj_type, uint64_t offset, void* data, uint16_t size) {
     sys_chunk* sc;
     LIST_ENTRY* le;
 
@@ -4049,7 +4166,7 @@ static NTSTATUS create_chunk(device_extension* Vcb, chunk* c, PIRP Irp) {
     CHUNK_ITEM* ci;
     CHUNK_ITEM_STRIPE* cis;
     BLOCK_GROUP_ITEM* bgi;
-    UINT16 i, factor;
+    uint16_t i, factor;
     NTSTATUS Status;
 
     ci = ExAllocatePoolWithTag(PagedPool, c->size, ALLOC_TAG);
@@ -4139,7 +4256,7 @@ static NTSTATUS create_chunk(device_extension* Vcb, chunk* c, PIRP Irp) {
         }
     }
 
-    c->created = FALSE;
+    c->created = false;
     c->oldused = c->used;
 
     Vcb->superblock.bytes_used += chunk_estimate_phys_size(Vcb, c, c->used);
@@ -4147,7 +4264,7 @@ static NTSTATUS create_chunk(device_extension* Vcb, chunk* c, PIRP Irp) {
     return STATUS_SUCCESS;
 }
 
-static void remove_from_bootstrap(device_extension* Vcb, UINT64 obj_id, UINT8 obj_type, UINT64 offset) {
+static void remove_from_bootstrap(device_extension* Vcb, uint64_t obj_id, uint8_t obj_type, uint64_t offset) {
     sys_chunk* sc2;
     LIST_ENTRY* le;
 
@@ -4170,15 +4287,15 @@ static void remove_from_bootstrap(device_extension* Vcb, UINT64 obj_id, UINT8 ob
     }
 }
 
-static NTSTATUS set_xattr(device_extension* Vcb, LIST_ENTRY* batchlist, root* subvol, UINT64 inode, char* name, UINT16 namelen,
-                          UINT32 crc32, UINT8* data, UINT16 datalen) {
+static NTSTATUS set_xattr(device_extension* Vcb, LIST_ENTRY* batchlist, root* subvol, uint64_t inode, char* name, uint16_t namelen,
+                          uint32_t crc32, uint8_t* data, uint16_t datalen) {
     NTSTATUS Status;
-    UINT16 xasize;
+    uint16_t xasize;
     DIR_ITEM* xa;
 
-    TRACE("(%p, %llx, %llx, %.*s, %08x, %p, %u)\n", Vcb, subvol->id, inode, namelen, name, crc32, data, datalen);
+    TRACE("(%p, %I64x, %I64x, %.*s, %08x, %p, %u)\n", Vcb, subvol->id, inode, namelen, name, crc32, data, datalen);
 
-    xasize = (UINT16)offsetof(DIR_ITEM, name[0]) + namelen + datalen;
+    xasize = (uint16_t)offsetof(DIR_ITEM, name[0]) + namelen + datalen;
 
     xa = ExAllocatePoolWithTag(PagedPool, xasize, ALLOC_TAG);
     if (!xa) {
@@ -4206,15 +4323,15 @@ static NTSTATUS set_xattr(device_extension* Vcb, LIST_ENTRY* batchlist, root* su
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS delete_xattr(device_extension* Vcb, LIST_ENTRY* batchlist, root* subvol, UINT64 inode, char* name,
-                             UINT16 namelen, UINT32 crc32) {
+static NTSTATUS delete_xattr(device_extension* Vcb, LIST_ENTRY* batchlist, root* subvol, uint64_t inode, char* name,
+                             uint16_t namelen, uint32_t crc32) {
     NTSTATUS Status;
-    UINT16 xasize;
+    uint16_t xasize;
     DIR_ITEM* xa;
 
-    TRACE("(%p, %llx, %llx, %.*s, %08x)\n", Vcb, subvol->id, inode, namelen, name, crc32);
+    TRACE("(%p, %I64x, %I64x, %.*s, %08x)\n", Vcb, subvol->id, inode, namelen, name, crc32);
 
-    xasize = (UINT16)offsetof(DIR_ITEM, name[0]) + namelen;
+    xasize = (uint16_t)offsetof(DIR_ITEM, name[0]) + namelen;
 
     xa = ExAllocatePoolWithTag(PagedPool, xasize, ALLOC_TAG);
     if (!xa) {
@@ -4241,12 +4358,12 @@ static NTSTATUS delete_xattr(device_extension* Vcb, LIST_ENTRY* batchlist, root*
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS insert_sparse_extent(fcb* fcb, LIST_ENTRY* batchlist, UINT64 start, UINT64 length) {
+static NTSTATUS insert_sparse_extent(fcb* fcb, LIST_ENTRY* batchlist, uint64_t start, uint64_t length) {
     NTSTATUS Status;
     EXTENT_DATA* ed;
     EXTENT_DATA2* ed2;
 
-    TRACE("((%llx, %llx), %llx, %llx)\n", fcb->subvol->id, fcb->inode, start, length);
+    TRACE("((%I64x, %I64x), %I64x, %I64x)\n", fcb->subvol->id, fcb->inode, start, length);
 
     ed = ExAllocatePoolWithTag(PagedPool, sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2), ALLOC_TAG);
     if (!ed) {
@@ -4281,8 +4398,8 @@ static NTSTATUS insert_sparse_extent(fcb* fcb, LIST_ENTRY* batchlist, UINT64 sta
 #pragma warning(push)
 #pragma warning(suppress: 28194)
 #endif
-NTSTATUS insert_tree_item_batch(LIST_ENTRY* batchlist, device_extension* Vcb, root* r, UINT64 objid, UINT8 objtype, UINT64 offset,
-                                _In_opt_ _When_(return >= 0, __drv_aliasesMem) void* data, UINT16 datalen, enum batch_operation operation) {
+NTSTATUS insert_tree_item_batch(LIST_ENTRY* batchlist, device_extension* Vcb, root* r, uint64_t objid, uint8_t objtype, uint64_t offset,
+                                _In_opt_ _When_(return >= 0, __drv_aliasesMem) void* data, uint16_t datalen, enum batch_operation operation) {
     LIST_ENTRY* le;
     batch_root* br = NULL;
     batch_item* bi;
@@ -4346,13 +4463,13 @@ NTSTATUS insert_tree_item_batch(LIST_ENTRY* batchlist, device_extension* Vcb, ro
 #endif
 
 typedef struct {
-    UINT64 address;
-    UINT64 length;
-    UINT64 offset;
-    BOOL changed;
+    uint64_t address;
+    uint64_t length;
+    uint64_t offset;
+    bool changed;
     chunk* chunk;
-    UINT64 skip_start;
-    UINT64 skip_end;
+    uint64_t skip_start;
+    uint64_t skip_end;
     LIST_ENTRY list_entry;
 } extent_range;
 
@@ -4360,8 +4477,8 @@ static void rationalize_extents(fcb* fcb, PIRP Irp) {
     LIST_ENTRY* le;
     LIST_ENTRY extent_ranges;
     extent_range* er;
-    BOOL changed = FALSE, truncating = FALSE;
-    UINT32 num_extents = 0;
+    bool changed = false, truncating = false;
+    uint32_t num_extents = 0;
 
     InitializeListHead(&extent_ranges);
 
@@ -4398,13 +4515,13 @@ static void rationalize_extents(fcb* fcb, PIRP Irp) {
                 er->address = ed2->address;
                 er->length = ed2->size;
                 er->offset = ext->offset - ed2->offset;
-                er->changed = FALSE;
+                er->changed = false;
                 er->chunk = NULL;
                 er->skip_start = ed2->offset;
                 er->skip_end = ed2->size - ed2->offset - ed2->num_bytes;
 
                 if (er->skip_start != 0 || er->skip_end != 0)
-                    truncating = TRUE;
+                    truncating = true;
 
                 InsertHeadList(le2->Blink, &er->list_entry);
                 num_extents++;
@@ -4428,7 +4545,7 @@ cont:
             er->chunk = get_chunk_from_address(fcb->Vcb, er->address);
 
             if (!er->chunk) {
-                ERR("get_chunk_from_address(%llx) failed\n", er->address);
+                ERR("get_chunk_from_address(%I64x) failed\n", er->address);
                 goto end;
             }
 
@@ -4465,7 +4582,7 @@ cont:
                             NTSTATUS Status;
 
                             Status = update_changed_extent_ref(fcb->Vcb, er->chunk, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset,
-                                                               -1, fcb->inode_item.flags & BTRFS_INODE_NODATASUM, TRUE, Irp);
+                                                               -1, fcb->inode_item.flags & BTRFS_INODE_NODATASUM, true, Irp);
                             if (!NT_SUCCESS(Status)) {
                                 ERR("update_changed_extent_ref returned %08x\n", Status);
                                 goto end;
@@ -4521,7 +4638,7 @@ cont:
                             NTSTATUS Status;
 
                             Status = update_changed_extent_ref(fcb->Vcb, er->chunk, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset,
-                                                               -1, fcb->inode_item.flags & BTRFS_INODE_NODATASUM, TRUE, Irp);
+                                                               -1, fcb->inode_item.flags & BTRFS_INODE_NODATASUM, true, Irp);
                             if (!NT_SUCCESS(Status)) {
                                 ERR("update_changed_extent_ref returned %08x\n", Status);
                                 goto end;
@@ -4581,12 +4698,12 @@ cont:
                 if (er2->address == er->address + er->length && er2->offset >= er->offset + er->length) {
                     if (er->length + er2->length <= MAX_EXTENT_SIZE) {
                         er->length += er2->length;
-                        er->changed = TRUE;
+                        er->changed = true;
 
                         RemoveEntryList(&er2->list_entry);
                         ExFreePool(er2);
 
-                        changed = TRUE;
+                        changed = true;
                         continue;
                     }
                 }
@@ -4617,7 +4734,7 @@ cont:
                         NTSTATUS Status;
 
                         Status = update_changed_extent_ref(fcb->Vcb, er2->chunk, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset,
-                                                           -1, fcb->inode_item.flags & BTRFS_INODE_NODATASUM, TRUE, Irp);
+                                                           -1, fcb->inode_item.flags & BTRFS_INODE_NODATASUM, true, Irp);
                         if (!NT_SUCCESS(Status)) {
                             ERR("update_changed_extent_ref returned %08x\n", Status);
                             goto end;
@@ -4651,15 +4768,15 @@ end:
     }
 }
 
-NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
+NTSTATUS flush_fcb(fcb* fcb, bool cache, LIST_ENTRY* batchlist, PIRP Irp) {
     traverse_ptr tp;
     KEY searchkey;
     NTSTATUS Status;
     INODE_ITEM* ii;
-    UINT64 ii_offset;
+    uint64_t ii_offset;
 #ifdef DEBUG_PARANOID
-    UINT64 old_size = 0;
-    BOOL extents_changed;
+    uint64_t old_size = 0;
+    bool extents_changed;
 #endif
 
     if (fcb->ads) {
@@ -4671,22 +4788,13 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             }
         } else {
             Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, fcb->adsxattr.Buffer, fcb->adsxattr.Length,
-                               fcb->adshash, (UINT8*)fcb->adsdata.Buffer, fcb->adsdata.Length);
+                               fcb->adshash, (uint8_t*)fcb->adsdata.Buffer, fcb->adsdata.Length);
             if (!NT_SUCCESS(Status)) {
                 ERR("set_xattr returned %08x\n", Status);
                 goto end;
             }
         }
 
-        if (fcb->marked_as_orphan) {
-            Status = insert_tree_item_batch(batchlist, fcb->Vcb, fcb->subvol, BTRFS_ORPHAN_INODE_OBJID, TYPE_ORPHAN_INODE,
-                                            fcb->inode, NULL, 0, Batch_Delete);
-            if (!NT_SUCCESS(Status)) {
-                ERR("insert_tree_item_batch returned %08x\n", Status);
-                goto end;
-            }
-        }
-
         Status = STATUS_SUCCESS;
         goto end;
     }
@@ -4698,6 +4806,15 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             goto end;
         }
 
+        if (fcb->marked_as_orphan) {
+            Status = insert_tree_item_batch(batchlist, fcb->Vcb, fcb->subvol, BTRFS_ORPHAN_INODE_OBJID, TYPE_ORPHAN_INODE,
+                                            fcb->inode, NULL, 0, Batch_Delete);
+            if (!NT_SUCCESS(Status)) {
+                ERR("insert_tree_item_batch returned %08x\n", Status);
+                goto end;
+            }
+        }
+
         Status = STATUS_SUCCESS;
         goto end;
     }
@@ -4708,8 +4825,8 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
 
     if (fcb->extents_changed) {
         LIST_ENTRY* le;
-        BOOL prealloc = FALSE, extents_inline = FALSE;
-        UINT64 last_end;
+        bool prealloc = false, extents_inline = false;
+        uint64_t last_end;
 
         // delete ignored extent items
         le = fcb->extents.Flink;
@@ -4770,18 +4887,18 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
 
                             if (ext->extent_data.compression == BTRFS_COMPRESSION_NONE && ext->csum) {
                                 ULONG len = (ULONG)((ed2->num_bytes + ned2->num_bytes) / fcb->Vcb->superblock.sector_size);
-                                UINT32* csum;
+                                uint32_t* csum;
 
-                                csum = ExAllocatePoolWithTag(NonPagedPool, len * sizeof(UINT32), ALLOC_TAG);
+                                csum = ExAllocatePoolWithTag(NonPagedPool, len * sizeof(uint32_t), ALLOC_TAG);
                                 if (!csum) {
                                     ERR("out of memory\n");
                                     Status = STATUS_INSUFFICIENT_RESOURCES;
                                     goto end;
                                 }
 
-                                RtlCopyMemory(csum, ext->csum, (ULONG)(ed2->num_bytes * sizeof(UINT32) / fcb->Vcb->superblock.sector_size));
+                                RtlCopyMemory(csum, ext->csum, (ULONG)(ed2->num_bytes * sizeof(uint32_t) / fcb->Vcb->superblock.sector_size));
                                 RtlCopyMemory(&csum[ed2->num_bytes / fcb->Vcb->superblock.sector_size], nextext->csum,
-                                              (ULONG)(ned2->num_bytes * sizeof(UINT32) / fcb->Vcb->superblock.sector_size));
+                                              (ULONG)(ned2->num_bytes * sizeof(uint32_t) / fcb->Vcb->superblock.sector_size));
 
                                 ExFreePool(ext->csum);
                                 ext->csum = csum;
@@ -4800,10 +4917,10 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
                             c = get_chunk_from_address(fcb->Vcb, ed2->address);
 
                             if (!c) {
-                                ERR("get_chunk_from_address(%llx) failed\n", ed2->address);
+                                ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
                             } else {
                                 Status = update_changed_extent_ref(fcb->Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, -1,
-                                                                fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, Irp);
+                                                                fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("update_changed_extent_ref returned %08x\n", Status);
                                     goto end;
@@ -4838,7 +4955,7 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             extent* ext = CONTAINING_RECORD(le, extent, list_entry);
             EXTENT_DATA* ed;
 
-            ext->inserted = FALSE;
+            ext->inserted = false;
 
             if (!(fcb->Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_NO_HOLES) && ext->offset > last_end) {
                 Status = insert_sparse_extent(fcb, batchlist, last_end, ext->offset - last_end);
@@ -4865,10 +4982,10 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             }
 
             if (ed->type == EXTENT_TYPE_PREALLOC)
-                prealloc = TRUE;
+                prealloc = true;
 
             if (ed->type == EXTENT_TYPE_INLINE)
-                extents_inline = TRUE;
+                extents_inline = true;
 
             if (!(fcb->Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_NO_HOLES)) {
                 if (ed->type == EXTENT_TYPE_INLINE)
@@ -4899,9 +5016,9 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
         else
             fcb->inode_item.flags |= BTRFS_INODE_PREALLOC;
 
-        fcb->inode_item_changed = TRUE;
+        fcb->inode_item_changed = true;
 
-        fcb->extents_changed = FALSE;
+        fcb->extents_changed = false;
     }
 
     if ((!fcb->created && fcb->inode_item_changed) || cache) {
@@ -4909,7 +5026,7 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
         searchkey.obj_type = TYPE_INODE_ITEM;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(fcb->Vcb, fcb->subvol, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(fcb->Vcb, fcb->subvol, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             goto end;
@@ -4934,7 +5051,7 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
 
                 ii_offset = 0;
             } else {
-                ERR("could not find INODE_ITEM for inode %llx in subvol %llx\n", fcb->inode, fcb->subvol->id);
+                ERR("could not find INODE_ITEM for inode %I64x in subvol %I64x\n", fcb->inode, fcb->subvol->id);
                 Status = STATUS_INTERNAL_ERROR;
                 goto end;
             }
@@ -4959,14 +5076,14 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             searchkey.obj_type = TYPE_INODE_ITEM;
             searchkey.offset = ii_offset;
 
-            Status = find_item(fcb->Vcb, fcb->subvol, &tp, &searchkey, FALSE, Irp);
+            Status = find_item(fcb->Vcb, fcb->subvol, &tp, &searchkey, false, Irp);
             if (!NT_SUCCESS(Status)) {
                 ERR("error - find_item returned %08x\n", Status);
                 goto end;
             }
 
             if (keycmp(tp.item->key, searchkey)) {
-                ERR("could not find INODE_ITEM for inode %llx in subvol %llx\n", fcb->inode, fcb->subvol->id);
+                ERR("could not find INODE_ITEM for inode %I64x in subvol %I64x\n", fcb->inode, fcb->subvol->id);
                 Status = STATUS_INTERNAL_ERROR;
                 goto end;
             } else
@@ -4982,7 +5099,7 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
     } else
         ii_offset = 0;
 
-    fcb->created = FALSE;
+    fcb->created = false;
 
     if (!cache && fcb->inode_item_changed) {
         ii = ExAllocatePoolWithTag(PagedPool, sizeof(INODE_ITEM), ALLOC_TAG);
@@ -5001,13 +5118,13 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             goto end;
         }
 
-        fcb->inode_item_changed = FALSE;
+        fcb->inode_item_changed = false;
     }
 
     if (fcb->sd_dirty) {
         if (!fcb->sd_deleted) {
             Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_NTACL, sizeof(EA_NTACL) - 1,
-                               EA_NTACL_HASH, (UINT8*)fcb->sd, (UINT16)RtlLengthSecurityDescriptor(fcb->sd));
+                               EA_NTACL_HASH, (uint8_t*)fcb->sd, (uint16_t)RtlLengthSecurityDescriptor(fcb->sd));
             if (!NT_SUCCESS(Status)) {
                 ERR("set_xattr returned %08x\n", Status);
                 goto end;
@@ -5020,13 +5137,13 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             }
         }
 
-        fcb->sd_deleted = FALSE;
-        fcb->sd_dirty = FALSE;
+        fcb->sd_deleted = false;
+        fcb->sd_dirty = false;
     }
 
     if (fcb->atts_changed) {
         if (!fcb->atts_deleted) {
-            UINT8 val[16], *val2;
+            uint8_t val[16], *val2;
             ULONG atts = fcb->atts;
 
             TRACE("inserting new DOSATTRIB xattr\n");
@@ -5037,7 +5154,7 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             val2 = &val[sizeof(val) - 1];
 
             do {
-                UINT8 c = atts % 16;
+                uint8_t c = atts % 16;
                 *val2 = c <= 9 ? (c + '0') : (c - 0xa + 'a');
 
                 val2--;
@@ -5049,7 +5166,7 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             *val2 = '0';
 
             Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_DOSATTRIB, sizeof(EA_DOSATTRIB) - 1,
-                               EA_DOSATTRIB_HASH, val2, (UINT16)(val + sizeof(val) - val2));
+                               EA_DOSATTRIB_HASH, val2, (uint16_t)(val + sizeof(val) - val2));
             if (!NT_SUCCESS(Status)) {
                 ERR("set_xattr returned %08x\n", Status);
                 goto end;
@@ -5062,14 +5179,14 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             }
         }
 
-        fcb->atts_changed = FALSE;
-        fcb->atts_deleted = FALSE;
+        fcb->atts_changed = false;
+        fcb->atts_deleted = false;
     }
 
     if (fcb->reparse_xattr_changed) {
         if (fcb->reparse_xattr.Buffer && fcb->reparse_xattr.Length > 0) {
             Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_REPARSE, sizeof(EA_REPARSE) - 1,
-                               EA_REPARSE_HASH, (UINT8*)fcb->reparse_xattr.Buffer, (UINT16)fcb->reparse_xattr.Length);
+                               EA_REPARSE_HASH, (uint8_t*)fcb->reparse_xattr.Buffer, (uint16_t)fcb->reparse_xattr.Length);
             if (!NT_SUCCESS(Status)) {
                 ERR("set_xattr returned %08x\n", Status);
                 goto end;
@@ -5082,13 +5199,13 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             }
         }
 
-        fcb->reparse_xattr_changed = FALSE;
+        fcb->reparse_xattr_changed = false;
     }
 
     if (fcb->ea_changed) {
         if (fcb->ea_xattr.Buffer && fcb->ea_xattr.Length > 0) {
             Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_EA, sizeof(EA_EA) - 1,
-                               EA_EA_HASH, (UINT8*)fcb->ea_xattr.Buffer, (UINT16)fcb->ea_xattr.Length);
+                               EA_EA_HASH, (uint8_t*)fcb->ea_xattr.Buffer, (uint16_t)fcb->ea_xattr.Length);
             if (!NT_SUCCESS(Status)) {
                 ERR("set_xattr returned %08x\n", Status);
                 goto end;
@@ -5101,7 +5218,7 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             }
         }
 
-        fcb->ea_changed = FALSE;
+        fcb->ea_changed = false;
     }
 
     if (fcb->prop_compression_changed) {
@@ -5115,7 +5232,7 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             static const char zlib[] = "zlib";
 
             Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_PROP_COMPRESSION, sizeof(EA_PROP_COMPRESSION) - 1,
-                               EA_PROP_COMPRESSION_HASH, (UINT8*)zlib, sizeof(zlib) - 1);
+                               EA_PROP_COMPRESSION_HASH, (uint8_t*)zlib, sizeof(zlib) - 1);
             if (!NT_SUCCESS(Status)) {
                 ERR("set_xattr returned %08x\n", Status);
                 goto end;
@@ -5124,7 +5241,7 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             static const char lzo[] = "lzo";
 
             Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_PROP_COMPRESSION, sizeof(EA_PROP_COMPRESSION) - 1,
-                               EA_PROP_COMPRESSION_HASH, (UINT8*)lzo, sizeof(lzo) - 1);
+                               EA_PROP_COMPRESSION_HASH, (uint8_t*)lzo, sizeof(lzo) - 1);
             if (!NT_SUCCESS(Status)) {
                 ERR("set_xattr returned %08x\n", Status);
                 goto end;
@@ -5133,14 +5250,14 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             static const char zstd[] = "zstd";
 
             Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_PROP_COMPRESSION, sizeof(EA_PROP_COMPRESSION) - 1,
-                               EA_PROP_COMPRESSION_HASH, (UINT8*)zstd, sizeof(zstd) - 1);
+                               EA_PROP_COMPRESSION_HASH, (uint8_t*)zstd, sizeof(zstd) - 1);
             if (!NT_SUCCESS(Status)) {
                 ERR("set_xattr returned %08x\n", Status);
                 goto end;
             }
         }
 
-        fcb->prop_compression_changed = FALSE;
+        fcb->prop_compression_changed = false;
     }
 
     if (fcb->xattrs_changed) {
@@ -5152,7 +5269,7 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             LIST_ENTRY* le2 = le->Flink;
 
             if (xa->dirty) {
-                UINT32 hash = calc_crc32c(0xfffffffe, (UINT8*)xa->data, xa->namelen);
+                uint32_t hash = calc_crc32c(0xfffffffe, (uint8_t*)xa->data, xa->namelen);
 
                 if (xa->valuelen == 0) {
                     Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, xa->data, xa->namelen, hash);
@@ -5165,20 +5282,20 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
                     ExFreePool(xa);
                 } else {
                     Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, xa->data, xa->namelen,
-                                       hash, (UINT8*)&xa->data[xa->namelen], xa->valuelen);
+                                       hash, (uint8_t*)&xa->data[xa->namelen], xa->valuelen);
                     if (!NT_SUCCESS(Status)) {
                         ERR("set_xattr returned %08x\n", Status);
                         goto end;
                     }
 
-                    xa->dirty = FALSE;
+                    xa->dirty = false;
                 }
             }
 
             le = le2;
         }
 
-        fcb->xattrs_changed = FALSE;
+        fcb->xattrs_changed = false;
     }
 
     if ((fcb->case_sensitive_set && !fcb->case_sensitive)) {
@@ -5189,16 +5306,16 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             goto end;
         }
 
-        fcb->case_sensitive_set = FALSE;
+        fcb->case_sensitive_set = false;
     } else if ((!fcb->case_sensitive_set && fcb->case_sensitive)) {
         Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_CASE_SENSITIVE,
-                           sizeof(EA_CASE_SENSITIVE) - 1, EA_CASE_SENSITIVE_HASH, (UINT8*)"1", 1);
+                           sizeof(EA_CASE_SENSITIVE) - 1, EA_CASE_SENSITIVE_HASH, (uint8_t*)"1", 1);
         if (!NT_SUCCESS(Status)) {
             ERR("set_xattr returned %08x\n", Status);
             goto end;
         }
 
-        fcb->case_sensitive_set = TRUE;
+        fcb->case_sensitive_set = true;
     }
 
     if (fcb->inode_item.st_nlink == 0 && !fcb->marked_as_orphan) { // mark as orphan
@@ -5209,20 +5326,20 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
             goto end;
         }
 
-        fcb->marked_as_orphan = TRUE;
+        fcb->marked_as_orphan = true;
     }
 
     Status = STATUS_SUCCESS;
 
 end:
     if (fcb->dirty) {
-        BOOL lock = FALSE;
+        bool lock = false;
 
-        fcb->dirty = FALSE;
+        fcb->dirty = false;
 
         if (!ExIsResourceAcquiredExclusiveLite(&fcb->Vcb->dirty_fcbs_lock)) {
-            ExAcquireResourceExclusiveLite(&fcb->Vcb->dirty_fcbs_lock, TRUE);
-            lock = TRUE;
+            ExAcquireResourceExclusiveLite(&fcb->Vcb->dirty_fcbs_lock, true);
+            lock = true;
         }
 
         RemoveEntryList(&fcb->list_entry_dirty);
@@ -5234,7 +5351,7 @@ end:
     return Status;
 }
 
-void add_trim_entry_avoid_sb(device_extension* Vcb, device* dev, UINT64 address, UINT64 size) {
+void add_trim_entry_avoid_sb(device_extension* Vcb, device* dev, uint64_t address, uint64_t size) {
     int i;
     ULONG sblen = (ULONG)sector_align(sizeof(superblock), Vcb->superblock.sector_size);
 
@@ -5262,13 +5379,13 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
-    UINT64 i, factor;
+    uint64_t i, factor;
 #ifdef __REACTOS__
-    UINT64 phys_used;
+    uint64_t phys_used;
 #endif
     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];;
 
-    TRACE("dropping chunk %llx\n", c->offset);
+    TRACE("dropping chunk %I64x\n", c->offset);
 
     if (c->chunk_item->type & BLOCK_FLAG_RAID0)
         factor = c->chunk_item->num_stripes;
@@ -5283,7 +5400,7 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
 
     // do TRIM
     if (Vcb->trim && !Vcb->options.no_trim) {
-        UINT64 len = c->chunk_item->size / factor;
+        uint64_t len = c->chunk_item->size / factor;
 
         for (i = 0; i < c->chunk_item->num_stripes; i++) {
             if (c->devices[i] && c->devices[i]->devobj && !c->devices[i]->readonly && c->devices[i]->trim)
@@ -5292,7 +5409,7 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
     }
 
     if (!c->cache) {
-        Status = load_stored_free_space_cache(Vcb, c, TRUE, Irp);
+        Status = load_stored_free_space_cache(Vcb, c, true, Irp);
 
         if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND)
             WARN("load_stored_free_space_cache returned %08x\n", Status);
@@ -5300,7 +5417,7 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
 
     // remove free space cache
     if (c->cache) {
-        c->cache->deleted = TRUE;
+        c->cache->deleted = true;
 
         Status = excise_extents(Vcb, c->cache, 0, c->cache->inode_item.st_size, Irp, rollback);
         if (!NT_SUCCESS(Status)) {
@@ -5308,7 +5425,7 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
             return Status;
         }
 
-        Status = flush_fcb(c->cache, TRUE, batchlist, Irp);
+        Status = flush_fcb(c->cache, true, batchlist, Irp);
 
         free_fcb(c->cache);
 
@@ -5324,7 +5441,7 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
         searchkey.obj_type = 0;
         searchkey.offset = c->offset;
 
-        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
@@ -5355,7 +5472,7 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
             searchkey.obj_type = TYPE_DEV_EXTENT;
             searchkey.offset = cis[i].offset;
 
-            Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, FALSE, Irp);
+            Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, false, Irp);
             if (!NT_SUCCESS(Status)) {
                 ERR("error - find_item returned %08x\n", Status);
                 return Status;
@@ -5380,9 +5497,9 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
                         space_list_add2(&c->devices[i]->space, NULL, cis[i].offset, de->length, NULL, rollback);
                 }
             } else
-                WARN("could not find (%llx,%x,%llx) in dev tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+                WARN("could not find (%I64x,%x,%I64x) in dev tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
         } else {
-            UINT64 len = c->chunk_item->size / factor;
+            uint64_t len = c->chunk_item->size / factor;
 
             c->devices[i]->devitem.bytes_used -= len;
 
@@ -5397,14 +5514,14 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
     // modify DEV_ITEMs in chunk tree
     for (i = 0; i < c->chunk_item->num_stripes; i++) {
         if (c->devices[i]) {
-            UINT64 j;
+            uint64_t j;
             DEV_ITEM* di;
 
             searchkey.obj_id = 1;
             searchkey.obj_type = TYPE_DEV_ITEM;
             searchkey.offset = c->devices[i]->devitem.dev_id;
 
-            Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, FALSE, Irp);
+            Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, false, Irp);
             if (!NT_SUCCESS(Status)) {
                 ERR("error - find_item returned %08x\n", Status);
                 return Status;
@@ -5445,7 +5562,7 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
         searchkey.obj_type = TYPE_CHUNK_ITEM;
         searchkey.offset = c->offset;
 
-        Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
@@ -5459,14 +5576,14 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
                 return Status;
             }
         } else
-            WARN("could not find CHUNK_ITEM for chunk %llx\n", c->offset);
+            WARN("could not find CHUNK_ITEM for chunk %I64x\n", c->offset);
 
         // remove BLOCK_GROUP_ITEM from extent tree
         searchkey.obj_id = c->offset;
         searchkey.obj_type = TYPE_BLOCK_GROUP_ITEM;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
@@ -5480,7 +5597,7 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
                 return Status;
             }
         } else
-            WARN("could not find BLOCK_GROUP_ITEM for chunk %llx\n", c->offset);
+            WARN("could not find BLOCK_GROUP_ITEM for chunk %I64x\n", c->offset);
     }
 
     if (c->chunk_item->type & BLOCK_FLAG_SYSTEM)
@@ -5492,14 +5609,14 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
 
     if (c->chunk_item->type & BLOCK_FLAG_RAID5 || c->chunk_item->type & BLOCK_FLAG_RAID6) {
         LIST_ENTRY* le;
-        BOOL clear_flag = TRUE;
+        bool clear_flag = true;
 
         le = Vcb->chunks.Flink;
         while (le != &Vcb->chunks) {
             chunk* c2 = CONTAINING_RECORD(le, chunk, list_entry);
 
             if (c2->chunk_item->type & BLOCK_FLAG_RAID5 || c2->chunk_item->type & BLOCK_FLAG_RAID6) {
-                clear_flag = FALSE;
+                clear_flag = false;
                 break;
             }
 
@@ -5511,7 +5628,7 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
     }
 
 #ifndef __REACTOS__
-    UINT64 phys_used = chunk_estimate_phys_size(Vcb, c, c->oldused);
+    uint64_t phys_used = chunk_estimate_phys_size(Vcb, c, c->oldused);
 #else
     phys_used = chunk_estimate_phys_size(Vcb, c, c->oldused);
 #endif
@@ -5550,27 +5667,27 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS partial_stripe_read(device_extension* Vcb, chunk* c, partial_stripe* ps, UINT64 startoff, UINT16 parity, ULONG offset, ULONG len) {
+static NTSTATUS partial_stripe_read(device_extension* Vcb, chunk* c, partial_stripe* ps, uint64_t startoff, uint16_t parity, ULONG offset, ULONG len) {
     NTSTATUS Status;
     ULONG sl = (ULONG)(c->chunk_item->stripe_length / Vcb->superblock.sector_size);
     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
 
     while (len > 0) {
         ULONG readlen = min(offset + len, offset + (sl - (offset % sl))) - offset;
-        UINT16 stripe;
+        uint16_t stripe;
 
         stripe = (parity + (offset / sl) + 1) % c->chunk_item->num_stripes;
 
         if (c->devices[stripe]->devobj) {
-            Status = sync_read_phys(c->devices[stripe]->devobj, cis[stripe].offset + startoff + ((offset % sl) * Vcb->superblock.sector_size),
-                                    readlen * Vcb->superblock.sector_size, ps->data + (offset * Vcb->superblock.sector_size), FALSE);
+            Status = sync_read_phys(c->devices[stripe]->devobj, c->devices[stripe]->fileobj, cis[stripe].offset + startoff + ((offset % sl) * Vcb->superblock.sector_size),
+                                    readlen * Vcb->superblock.sector_size, ps->data + (offset * Vcb->superblock.sector_size), false);
             if (!NT_SUCCESS(Status)) {
                 ERR("sync_read_phys returned %08x\n", Status);
                 return Status;
             }
         } else if (c->chunk_item->type & BLOCK_FLAG_RAID5) {
-            UINT16 i;
-            UINT8* scratch;
+            uint16_t i;
+            uint8_t* scratch;
 
             scratch = ExAllocatePoolWithTag(NonPagedPool, readlen * Vcb->superblock.sector_size, ALLOC_TAG);
             if (!scratch) {
@@ -5586,16 +5703,16 @@ static NTSTATUS partial_stripe_read(device_extension* Vcb, chunk* c, partial_str
                     }
 
                     if (i == 0 || (stripe == 0 && i == 1)) {
-                        Status = sync_read_phys(c->devices[i]->devobj, cis[i].offset + startoff + ((offset % sl) * Vcb->superblock.sector_size),
-                                                readlen * Vcb->superblock.sector_size, ps->data + (offset * Vcb->superblock.sector_size), FALSE);
+                        Status = sync_read_phys(c->devices[i]->devobj, c->devices[i]->fileobj, cis[i].offset + startoff + ((offset % sl) * Vcb->superblock.sector_size),
+                                                readlen * Vcb->superblock.sector_size, ps->data + (offset * Vcb->superblock.sector_size), false);
                         if (!NT_SUCCESS(Status)) {
                             ERR("sync_read_phys returned %08x\n", Status);
                             ExFreePool(scratch);
                             return Status;
                         }
                     } else {
-                        Status = sync_read_phys(c->devices[i]->devobj, cis[i].offset + startoff + ((offset % sl) * Vcb->superblock.sector_size),
-                                                readlen * Vcb->superblock.sector_size, scratch, FALSE);
+                        Status = sync_read_phys(c->devices[i]->devobj, c->devices[i]->fileobj, cis[i].offset + startoff + ((offset % sl) * Vcb->superblock.sector_size),
+                                                readlen * Vcb->superblock.sector_size, scratch, false);
                         if (!NT_SUCCESS(Status)) {
                             ERR("sync_read_phys returned %08x\n", Status);
                             ExFreePool(scratch);
@@ -5609,8 +5726,8 @@ static NTSTATUS partial_stripe_read(device_extension* Vcb, chunk* c, partial_str
 
             ExFreePool(scratch);
         } else {
-            UINT8* scratch;
-            UINT16 k, i, logstripe, error_stripe, num_errors = 0;
+            uint8_t* scratch;
+            uint16_t k, i, logstripe, error_stripe, num_errors = 0;
 
             scratch = ExAllocatePoolWithTag(NonPagedPool, (c->chunk_item->num_stripes + 2) * readlen * Vcb->superblock.sector_size, ALLOC_TAG);
             if (!scratch) {
@@ -5622,8 +5739,8 @@ static NTSTATUS partial_stripe_read(device_extension* Vcb, chunk* c, partial_str
             for (k = 0; k < c->chunk_item->num_stripes; k++) {
                 if (i != stripe) {
                     if (c->devices[i]->devobj) {
-                        Status = sync_read_phys(c->devices[i]->devobj, cis[i].offset + startoff + ((offset % sl) * Vcb->superblock.sector_size),
-                                                readlen * Vcb->superblock.sector_size, scratch + (k * readlen * Vcb->superblock.sector_size), FALSE);
+                        Status = sync_read_phys(c->devices[i]->devobj, c->devices[i]->fileobj, cis[i].offset + startoff + ((offset % sl) * Vcb->superblock.sector_size),
+                                                readlen * Vcb->superblock.sector_size, scratch + (k * readlen * Vcb->superblock.sector_size), false);
                         if (!NT_SUCCESS(Status)) {
                             ERR("sync_read_phys returned %08x\n", Status);
                             num_errors++;
@@ -5676,14 +5793,14 @@ static NTSTATUS partial_stripe_read(device_extension* Vcb, chunk* c, partial_str
 
 NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* ps) {
     NTSTATUS Status;
-    UINT16 parity2, stripe, startoffstripe;
-    UINT8* data;
-    UINT64 startoff;
+    uint16_t parity2, stripe, startoffstripe;
+    uint8_t* data;
+    uint64_t startoff;
     ULONG runlength, index, last1;
     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
     LIST_ENTRY* le;
-    UINT16 k, num_data_stripes = c->chunk_item->num_stripes - (c->chunk_item->type & BLOCK_FLAG_RAID5 ? 1 : 2);
-    UINT64 ps_length = num_data_stripes * c->chunk_item->stripe_length;
+    uint16_t k, num_data_stripes = c->chunk_item->num_stripes - (c->chunk_item->type & BLOCK_FLAG_RAID5 ? 1 : 2);
+    uint64_t ps_length = num_data_stripes * c->chunk_item->stripe_length;
     ULONG stripe_length = (ULONG)c->chunk_item->stripe_length;
 
     // FIXME - do writes asynchronously?
@@ -5698,6 +5815,16 @@ NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* p
     last1 = 0;
 
     while (runlength != 0) {
+        if (index >= ps->bmplen)
+            break;
+
+        if (index + runlength >= ps->bmplen) {
+            runlength = ps->bmplen - index;
+
+            if (runlength == 0)
+                break;
+        }
+
         if (index > last1) {
             Status = partial_stripe_read(Vcb, c, ps, startoff, parity2, last1, index - last1);
             if (!NT_SUCCESS(Status)) {
@@ -5725,8 +5852,8 @@ NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* p
         space* s = CONTAINING_RECORD(le, space, list_entry);
 
         if (s->address + s->size > ps->address && s->address < ps->address + ps_length) {
-            UINT64 start = max(ps->address, s->address);
-            UINT64 end = min(ps->address + ps_length, s->address + s->size);
+            uint64_t start = max(ps->address, s->address);
+            uint64_t end = min(ps->address + ps_length, s->address + s->size);
 
             RtlZeroMemory(ps->data + start - ps->address, (ULONG)(end - start));
         } else if (s->address >= ps->address + ps_length)
@@ -5740,8 +5867,8 @@ NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* p
         space* s = CONTAINING_RECORD(le, space, list_entry);
 
         if (s->address + s->size > ps->address && s->address < ps->address + ps_length) {
-            UINT64 start = max(ps->address, s->address);
-            UINT64 end = min(ps->address + ps_length, s->address + s->size);
+            uint64_t start = max(ps->address, s->address);
+            uint64_t end = min(ps->address + ps_length, s->address + s->size);
 
             RtlZeroMemory(ps->data + start - ps->address, (ULONG)(end - start));
         } else if (s->address >= ps->address + ps_length)
@@ -5755,7 +5882,7 @@ NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* p
     data = ps->data;
     for (k = 0; k < num_data_stripes; k++) {
         if (c->devices[stripe]->devobj) {
-            Status = write_data_phys(c->devices[stripe]->devobj, cis[stripe].offset + startoff, data, stripe_length);
+            Status = write_data_phys(c->devices[stripe]->devobj, c->devices[stripe]->fileobj, cis[stripe].offset + startoff, data, stripe_length);
             if (!NT_SUCCESS(Status)) {
                 ERR("write_data_phys returned %08x\n", Status);
                 return Status;
@@ -5769,24 +5896,24 @@ NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* p
     // write parity
     if (c->chunk_item->type & BLOCK_FLAG_RAID5) {
         if (c->devices[parity2]->devobj) {
-            UINT16 i;
+            uint16_t i;
 
             for (i = 1; i < c->chunk_item->num_stripes - 1; i++) {
                 do_xor(ps->data, ps->data + (i * stripe_length), stripe_length);
             }
 
-            Status = write_data_phys(c->devices[parity2]->devobj, cis[parity2].offset + startoff, ps->data, stripe_length);
+            Status = write_data_phys(c->devices[parity2]->devobj, c->devices[parity2]->fileobj, cis[parity2].offset + startoff, ps->data, stripe_length);
             if (!NT_SUCCESS(Status)) {
                 ERR("write_data_phys returned %08x\n", Status);
                 return Status;
             }
         }
     } else {
-        UINT16 parity1 = (parity2 + c->chunk_item->num_stripes - 1) % c->chunk_item->num_stripes;
+        uint16_t parity1 = (parity2 + c->chunk_item->num_stripes - 1) % c->chunk_item->num_stripes;
 
         if (c->devices[parity1]->devobj || c->devices[parity2]->devobj) {
-            UINT8* scratch;
-            UINT16 i;
+            uint8_t* scratch;
+            uint16_t i;
 
             scratch = ExAllocatePoolWithTag(NonPagedPool, stripe_length * 2, ALLOC_TAG);
             if (!scratch) {
@@ -5796,7 +5923,7 @@ NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* p
 
             i = c->chunk_item->num_stripes - 3;
 
-            while (TRUE) {
+            while (true) {
                 if (i == c->chunk_item->num_stripes - 3) {
                     RtlCopyMemory(scratch, ps->data + (i * stripe_length), stripe_length);
                     RtlCopyMemory(scratch + stripe_length, ps->data + (i * stripe_length), stripe_length);
@@ -5814,7 +5941,7 @@ NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* p
             }
 
             if (c->devices[parity1]->devobj) {
-                Status = write_data_phys(c->devices[parity1]->devobj, cis[parity1].offset + startoff, scratch, stripe_length);
+                Status = write_data_phys(c->devices[parity1]->devobj, c->devices[parity1]->fileobj, cis[parity1].offset + startoff, scratch, stripe_length);
                 if (!NT_SUCCESS(Status)) {
                     ERR("write_data_phys returned %08x\n", Status);
                     ExFreePool(scratch);
@@ -5823,7 +5950,8 @@ NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* p
             }
 
             if (c->devices[parity2]->devobj) {
-                Status = write_data_phys(c->devices[parity2]->devobj, cis[parity2].offset + startoff, scratch + stripe_length, stripe_length);
+                Status = write_data_phys(c->devices[parity2]->devobj, c->devices[parity2]->fileobj, cis[parity2].offset + startoff,
+                                         scratch + stripe_length, stripe_length);
                 if (!NT_SUCCESS(Status)) {
                     ERR("write_data_phys returned %08x\n", Status);
                     ExFreePool(scratch);
@@ -5841,9 +5969,9 @@ NTSTATUS flush_partial_stripe(device_extension* Vcb, chunk* c, partial_stripe* p
 static NTSTATUS update_chunks(device_extension* Vcb, LIST_ENTRY* batchlist, PIRP Irp, LIST_ENTRY* rollback) {
     LIST_ENTRY *le, *le2;
     NTSTATUS Status;
-    UINT64 used_minus_cache;
+    uint64_t used_minus_cache;
 
-    ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
     // FIXME - do tree chunks before data chunks
 
@@ -5858,7 +5986,7 @@ static NTSTATUS update_chunks(device_extension* Vcb, LIST_ENTRY* batchlist, PIRP
 
             // flush partial stripes
             if (!Vcb->readonly && (c->chunk_item->type & BLOCK_FLAG_RAID5 || c->chunk_item->type & BLOCK_FLAG_RAID6)) {
-                ExAcquireResourceExclusiveLite(&c->partial_stripes_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&c->partial_stripes_lock, true);
 
                 while (!IsListEmpty(&c->partial_stripes)) {
                     partial_stripe* ps = CONTAINING_RECORD(RemoveHeadList(&c->partial_stripes), partial_stripe, list_entry);
@@ -5889,7 +6017,7 @@ static NTSTATUS update_chunks(device_extension* Vcb, LIST_ENTRY* batchlist, PIRP
             }
 
             if (c->space_changed || c->created) {
-                BOOL created = c->created;
+                bool created = c->created;
 
                 used_minus_cache = c->used;
 
@@ -5951,7 +6079,7 @@ static NTSTATUS update_chunks(device_extension* Vcb, LIST_ENTRY* batchlist, PIRP
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS delete_root_ref(device_extension* Vcb, UINT64 subvolid, UINT64 parsubvolid, UINT64 parinode, PANSI_STRING utf8, PIRP Irp) {
+static NTSTATUS delete_root_ref(device_extension* Vcb, uint64_t subvolid, uint64_t parsubvolid, uint64_t parinode, PANSI_STRING utf8, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
@@ -5960,7 +6088,7 @@ static NTSTATUS delete_root_ref(device_extension* Vcb, UINT64 subvolid, UINT64 p
     searchkey.obj_type = TYPE_ROOT_REF;
     searchkey.offset = subvolid;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
@@ -5968,7 +6096,7 @@ static NTSTATUS delete_root_ref(device_extension* Vcb, UINT64 subvolid, UINT64 p
 
     if (!keycmp(searchkey, tp.item->key)) {
         if (tp.item->size < sizeof(ROOT_REF)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(ROOT_REF));
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(ROOT_REF));
             return STATUS_INTERNAL_ERROR;
         } else {
             ROOT_REF* rr;
@@ -5978,17 +6106,17 @@ static NTSTATUS delete_root_ref(device_extension* Vcb, UINT64 subvolid, UINT64 p
             len = tp.item->size;
 
             do {
-                UINT16 itemlen;
+                uint16_t itemlen;
 
                 if (len < sizeof(ROOT_REF) || len < offsetof(ROOT_REF, name[0]) + rr->n) {
-                    ERR("(%llx,%x,%llx) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                    ERR("(%I64x,%x,%I64x) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
                     break;
                 }
 
-                itemlen = (UINT16)offsetof(ROOT_REF, name[0]) + rr->n;
+                itemlen = (uint16_t)offsetof(ROOT_REF, name[0]) + rr->n;
 
                 if (rr->dir == parinode && rr->n == utf8->Length && RtlCompareMemory(rr->name, utf8->Buffer, rr->n) == rr->n) {
-                    UINT16 newlen = tp.item->size - itemlen;
+                    uint16_t newlen = tp.item->size - itemlen;
 
                     Status = delete_tree_item(Vcb, &tp);
                     if (!NT_SUCCESS(Status)) {
@@ -5997,26 +6125,26 @@ static NTSTATUS delete_root_ref(device_extension* Vcb, UINT64 subvolid, UINT64 p
                     }
 
                     if (newlen == 0) {
-                        TRACE("deleting (%llx,%x,%llx)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                        TRACE("deleting (%I64x,%x,%I64x)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
                     } else {
-                        UINT8 *newrr = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *rroff;
+                        uint8_t *newrr = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *rroff;
 
                         if (!newrr) {
                             ERR("out of memory\n");
                             return STATUS_INSUFFICIENT_RESOURCES;
                         }
 
-                        TRACE("modifying (%llx,%x,%llx)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                        TRACE("modifying (%I64x,%x,%I64x)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
 
-                        if ((UINT8*)rr > tp.item->data) {
-                            RtlCopyMemory(newrr, tp.item->data, (UINT8*)rr - tp.item->data);
-                            rroff = newrr + ((UINT8*)rr - tp.item->data);
+                        if ((uint8_t*)rr > tp.item->data) {
+                            RtlCopyMemory(newrr, tp.item->data, (uint8_t*)rr - tp.item->data);
+                            rroff = newrr + ((uint8_t*)rr - tp.item->data);
                         } else {
                             rroff = newrr;
                         }
 
-                        if ((UINT8*)&rr->name[rr->n] < tp.item->data + tp.item->size)
-                            RtlCopyMemory(rroff, &rr->name[rr->n], tp.item->size - ((UINT8*)&rr->name[rr->n] - tp.item->data));
+                        if ((uint8_t*)&rr->name[rr->n] < tp.item->data + tp.item->size)
+                            RtlCopyMemory(rroff, &rr->name[rr->n], tp.item->size - ((uint8_t*)&rr->name[rr->n] - tp.item->data));
 
                         Status = insert_tree_item(Vcb, Vcb->root_root, tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, newrr, newlen, NULL, Irp);
                         if (!NT_SUCCESS(Status)) {
@@ -6037,7 +6165,7 @@ static NTSTATUS delete_root_ref(device_extension* Vcb, UINT64 subvolid, UINT64 p
             } while (len > 0);
         }
     } else {
-        WARN("could not find ROOT_REF entry for subvol %llx in %llx\n", searchkey.offset, searchkey.obj_id);
+        WARN("could not find ROOT_REF entry for subvol %I64x in %I64x\n", searchkey.offset, searchkey.obj_id);
         return STATUS_NOT_FOUND;
     }
 
@@ -6048,7 +6176,7 @@ static NTSTATUS delete_root_ref(device_extension* Vcb, UINT64 subvolid, UINT64 p
 #pragma warning(push)
 #pragma warning(suppress: 28194)
 #endif
-static NTSTATUS add_root_ref(_In_ device_extension* Vcb, _In_ UINT64 subvolid, _In_ UINT64 parsubvolid, _In_ __drv_aliasesMem ROOT_REF* rr, _In_opt_ PIRP Irp) {
+static NTSTATUS add_root_ref(_In_ device_extension* Vcb, _In_ uint64_t subvolid, _In_ uint64_t parsubvolid, _In_ __drv_aliasesMem ROOT_REF* rr, _In_opt_ PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
@@ -6057,15 +6185,15 @@ static NTSTATUS add_root_ref(_In_ device_extension* Vcb, _In_ UINT64 subvolid, _
     searchkey.obj_type = TYPE_ROOT_REF;
     searchkey.offset = subvolid;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
     }
 
     if (!keycmp(searchkey, tp.item->key)) {
-        UINT16 rrsize = tp.item->size + (UINT16)offsetof(ROOT_REF, name[0]) + rr->n;
-        UINT8* rr2;
+        uint16_t rrsize = tp.item->size + (uint16_t)offsetof(ROOT_REF, name[0]) + rr->n;
+        uint8_t* rr2;
 
         rr2 = ExAllocatePoolWithTag(PagedPool, rrsize, ALLOC_TAG);
         if (!rr2) {
@@ -6093,7 +6221,7 @@ static NTSTATUS add_root_ref(_In_ device_extension* Vcb, _In_ UINT64 subvolid, _
             return Status;
         }
     } else {
-        Status = insert_tree_item(Vcb, Vcb->root_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, rr, (UINT16)offsetof(ROOT_REF, name[0]) + rr->n, NULL, Irp);
+        Status = insert_tree_item(Vcb, Vcb->root_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, rr, (uint16_t)offsetof(ROOT_REF, name[0]) + rr->n, NULL, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("insert_tree_item returned %08x\n", Status);
             ExFreePool(rr);
@@ -6107,18 +6235,18 @@ static NTSTATUS add_root_ref(_In_ device_extension* Vcb, _In_ UINT64 subvolid, _
 #pragma warning(pop)
 #endif
 
-static NTSTATUS update_root_backref(device_extension* Vcb, UINT64 subvolid, UINT64 parsubvolid, PIRP Irp) {
+static NTSTATUS update_root_backref(device_extension* Vcb, uint64_t subvolid, uint64_t parsubvolid, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
-    UINT8* data;
-    UINT16 datalen;
+    uint8_t* data;
+    uint16_t datalen;
     NTSTATUS Status;
 
     searchkey.obj_id = parsubvolid;
     searchkey.obj_type = TYPE_ROOT_REF;
     searchkey.offset = subvolid;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
@@ -6143,7 +6271,7 @@ static NTSTATUS update_root_backref(device_extension* Vcb, UINT64 subvolid, UINT
     searchkey.obj_type = TYPE_ROOT_BACKREF;
     searchkey.offset = parsubvolid;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
 
@@ -6177,7 +6305,7 @@ static NTSTATUS update_root_backref(device_extension* Vcb, UINT64 subvolid, UINT
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS add_root_item_to_cache(device_extension* Vcb, UINT64 root, PIRP Irp) {
+static NTSTATUS add_root_item_to_cache(device_extension* Vcb, uint64_t root, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
@@ -6186,14 +6314,14 @@ static NTSTATUS add_root_item_to_cache(device_extension* Vcb, UINT64 root, PIRP
     searchkey.obj_type = TYPE_ROOT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
     }
 
     if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-        ERR("could not find ROOT_ITEM for tree %llx\n", searchkey.obj_id);
+        ERR("could not find ROOT_ITEM for tree %I64x\n", searchkey.obj_id);
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -6207,7 +6335,7 @@ static NTSTATUS add_root_item_to_cache(device_extension* Vcb, UINT64 root, PIRP
         if (tp.item->size > 0)
             RtlCopyMemory(ri, tp.item->data, tp.item->size);
 
-        RtlZeroMemory(((UINT8*)ri) + tp.item->size, sizeof(ROOT_ITEM) - tp.item->size);
+        RtlZeroMemory(((uint8_t*)ri) + tp.item->size, sizeof(ROOT_ITEM) - tp.item->size);
 
         Status = delete_tree_item(Vcb, &tp);
         if (!NT_SUCCESS(Status)) {
@@ -6223,7 +6351,7 @@ static NTSTATUS add_root_item_to_cache(device_extension* Vcb, UINT64 root, PIRP
             return Status;
         }
     } else {
-        tp.tree->write = TRUE;
+        tp.tree->write = true;
     }
 
     return STATUS_SUCCESS;
@@ -6234,23 +6362,23 @@ static NTSTATUS flush_fileref(file_ref* fileref, LIST_ENTRY* batchlist, PIRP Irp
 
     // if fileref created and then immediately deleted, do nothing
     if (fileref->created && fileref->deleted) {
-        fileref->dirty = FALSE;
+        fileref->dirty = false;
         return STATUS_SUCCESS;
     }
 
     if (fileref->fcb->ads) {
-        fileref->dirty = FALSE;
+        fileref->dirty = false;
         return STATUS_SUCCESS;
     }
 
     if (fileref->created) {
-        UINT16 disize;
+        uint16_t disize;
         DIR_ITEM *di, *di2;
-        UINT32 crc32;
+        uint32_t crc32;
 
-        crc32 = calc_crc32c(0xfffffffe, (UINT8*)fileref->dc->utf8.Buffer, fileref->dc->utf8.Length);
+        crc32 = calc_crc32c(0xfffffffe, (uint8_t*)fileref->dc->utf8.Buffer, fileref->dc->utf8.Length);
 
-        disize = (UINT16)(offsetof(DIR_ITEM, name[0]) + fileref->dc->utf8.Length);
+        disize = (uint16_t)(offsetof(DIR_ITEM, name[0]) + fileref->dc->utf8.Length);
         di = ExAllocatePoolWithTag(PagedPool, disize, ALLOC_TAG);
         if (!di) {
             ERR("out of memory\n");
@@ -6269,7 +6397,7 @@ static NTSTATUS flush_fileref(file_ref* fileref, LIST_ENTRY* batchlist, PIRP Irp
 
         di->transid = fileref->fcb->Vcb->superblock.generation;
         di->m = 0;
-        di->n = (UINT16)fileref->dc->utf8.Length;
+        di->n = (uint16_t)fileref->dc->utf8.Length;
         di->type = fileref->fcb->type;
         RtlCopyMemory(di->name, fileref->dc->utf8.Buffer, fileref->dc->utf8.Length);
 
@@ -6344,15 +6472,15 @@ static NTSTATUS flush_fileref(file_ref* fileref, LIST_ENTRY* batchlist, PIRP Irp
             }
         }
 
-        fileref->created = FALSE;
+        fileref->created = false;
     } else if (fileref->deleted) {
-        UINT32 crc32;
+        uint32_t crc32;
         ANSI_STRING* name;
         DIR_ITEM* di;
 
         name = &fileref->oldutf8;
 
-        crc32 = calc_crc32c(0xfffffffe, (UINT8*)name->Buffer, name->Length);
+        crc32 = calc_crc32c(0xfffffffe, (uint8_t*)name->Buffer, name->Length);
 
         TRACE("deleting %.*S\n", file_desc_fileref(fileref));
 
@@ -6425,16 +6553,16 @@ static NTSTATUS flush_fileref(file_ref* fileref, LIST_ENTRY* batchlist, PIRP Irp
         }
     } else { // rename or change type
         PANSI_STRING oldutf8 = fileref->oldutf8.Buffer ? &fileref->oldutf8 : &fileref->dc->utf8;
-        UINT32 crc32, oldcrc32;
-        UINT16 disize;
+        uint32_t crc32, oldcrc32;
+        uint16_t disize;
         DIR_ITEM *olddi, *di, *di2;
 
-        crc32 = calc_crc32c(0xfffffffe, (UINT8*)fileref->dc->utf8.Buffer, fileref->dc->utf8.Length);
+        crc32 = calc_crc32c(0xfffffffe, (uint8_t*)fileref->dc->utf8.Buffer, fileref->dc->utf8.Length);
 
         if (!fileref->oldutf8.Buffer)
             oldcrc32 = crc32;
         else
-            oldcrc32 = calc_crc32c(0xfffffffe, (UINT8*)fileref->oldutf8.Buffer, fileref->oldutf8.Length);
+            oldcrc32 = calc_crc32c(0xfffffffe, (uint8_t*)fileref->oldutf8.Buffer, fileref->oldutf8.Length);
 
         olddi = ExAllocatePoolWithTag(PagedPool, sizeof(DIR_ITEM) - 1 + oldutf8->Length, ALLOC_TAG);
         if (!olddi) {
@@ -6443,7 +6571,7 @@ static NTSTATUS flush_fileref(file_ref* fileref, LIST_ENTRY* batchlist, PIRP Irp
         }
 
         olddi->m = 0;
-        olddi->n = (UINT16)oldutf8->Length;
+        olddi->n = (uint16_t)oldutf8->Length;
         RtlCopyMemory(olddi->name, oldutf8->Buffer, oldutf8->Length);
 
         // delete DIR_ITEM (0x54)
@@ -6458,7 +6586,7 @@ static NTSTATUS flush_fileref(file_ref* fileref, LIST_ENTRY* batchlist, PIRP Irp
 
         // add DIR_ITEM (0x54)
 
-        disize = (UINT16)(offsetof(DIR_ITEM, name[0]) + fileref->dc->utf8.Length);
+        disize = (uint16_t)(offsetof(DIR_ITEM, name[0]) + fileref->dc->utf8.Length);
         di = ExAllocatePoolWithTag(PagedPool, disize, ALLOC_TAG);
         if (!di) {
             ERR("out of memory\n");
@@ -6486,7 +6614,7 @@ static NTSTATUS flush_fileref(file_ref* fileref, LIST_ENTRY* batchlist, PIRP Irp
 
         di->transid = fileref->fcb->Vcb->superblock.generation;
         di->m = 0;
-        di->n = (UINT16)fileref->dc->utf8.Length;
+        di->n = (uint16_t)fileref->dc->utf8.Length;
         di->type = fileref->fcb->type;
         RtlCopyMemory(di->name, fileref->dc->utf8.Buffer, fileref->dc->utf8.Length);
 
@@ -6613,7 +6741,7 @@ static NTSTATUS flush_fileref(file_ref* fileref, LIST_ENTRY* batchlist, PIRP Irp
         }
     }
 
-    fileref->dirty = FALSE;
+    fileref->dirty = false;
 
     return STATUS_SUCCESS;
 }
@@ -6641,7 +6769,7 @@ static void flush_disk_caches(device_extension* Vcb) {
 
     num = 0;
 
-    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&context.Event, NotificationEvent, false);
 
     context.stripes = ExAllocatePoolWithTag(NonPagedPool, sizeof(ioctl_context_stripe) * context.left, ALLOC_TAG);
     if (!context.stripes) {
@@ -6666,7 +6794,7 @@ static void flush_disk_caches(device_extension* Vcb) {
             stripe->apte.TimeOutValue = 5;
             stripe->apte.CurrentTaskFile[6] = IDE_COMMAND_FLUSH_CACHE;
 
-            stripe->Irp = IoAllocateIrp(dev->devobj->StackSize, FALSE);
+            stripe->Irp = IoAllocateIrp(dev->devobj->StackSize, false);
 
             if (!stripe->Irp) {
                 ERR("IoAllocateIrp failed\n");
@@ -6675,6 +6803,7 @@ static void flush_disk_caches(device_extension* Vcb) {
 
             IrpSp = IoGetNextIrpStackLocation(stripe->Irp);
             IrpSp->MajorFunction = IRP_MJ_DEVICE_CONTROL;
+            IrpSp->FileObject = dev->fileobj;
 
             IrpSp->Parameters.DeviceIoControl.IoControlCode = IOCTL_ATA_PASS_THROUGH;
             IrpSp->Parameters.DeviceIoControl.InputBufferLength = sizeof(ATA_PASS_THROUGH_EX);
@@ -6685,7 +6814,7 @@ static void flush_disk_caches(device_extension* Vcb) {
             stripe->Irp->UserBuffer = &stripe->apte;
             stripe->Irp->UserIosb = &stripe->iosb;
 
-            IoSetCompletionRoutine(stripe->Irp, ioctl_completion, &context, TRUE, TRUE, TRUE);
+            IoSetCompletionRoutine(stripe->Irp, ioctl_completion, &context, true, true, true);
 
             IoCallDriver(dev->devobj, stripe->Irp);
 
@@ -6696,7 +6825,7 @@ nextdev:
         le = le->Flink;
     }
 
-    KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+    KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
 
     ExFreePool(context.stripes);
 }
@@ -6705,14 +6834,14 @@ static NTSTATUS flush_changed_dev_stats(device_extension* Vcb, device* dev, PIRP
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
-    UINT16 statslen;
-    UINT64* stats;
+    uint16_t statslen;
+    uint64_t* stats;
 
     searchkey.obj_id = 0;
     searchkey.obj_type = TYPE_DEV_STATS;
     searchkey.offset = dev->devitem.dev_id;
 
-    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
@@ -6726,7 +6855,7 @@ static NTSTATUS flush_changed_dev_stats(device_extension* Vcb, device* dev, PIRP
         }
     }
 
-    statslen = sizeof(UINT64) * 5;
+    statslen = sizeof(uint64_t) * 5;
     stats = ExAllocatePoolWithTag(PagedPool, statslen, ALLOC_TAG);
     if (!stats) {
         ERR("out of memory\n");
@@ -6757,14 +6886,14 @@ static NTSTATUS flush_subvol(device_extension* Vcb, root* r, PIRP Irp) {
         searchkey.obj_type = TYPE_ROOT_ITEM;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
         }
 
         if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-            ERR("could not find ROOT_ITEM for tree %llx\n", searchkey.obj_id);
+            ERR("could not find ROOT_ITEM for tree %I64x\n", searchkey.obj_id);
             return STATUS_INTERNAL_ERROR;
         }
 
@@ -6798,7 +6927,7 @@ static NTSTATUS flush_subvol(device_extension* Vcb, root* r, PIRP Irp) {
 
             TRACE("uuid root doesn't exist, creating it\n");
 
-            Status = create_root(Vcb, BTRFS_ROOT_UUID, &uuid_root, FALSE, 0, Irp);
+            Status = create_root(Vcb, BTRFS_ROOT_UUID, &uuid_root, false, 0, Irp);
 
             if (!NT_SUCCESS(Status)) {
                 ERR("create_root returned %08x\n", Status);
@@ -6808,28 +6937,28 @@ static NTSTATUS flush_subvol(device_extension* Vcb, root* r, PIRP Irp) {
             Vcb->uuid_root = uuid_root;
         }
 
-        RtlCopyMemory(&searchkey.obj_id, &r->root_item.received_uuid, sizeof(UINT64));
+        RtlCopyMemory(&searchkey.obj_id, &r->root_item.received_uuid, sizeof(uint64_t));
         searchkey.obj_type = TYPE_SUBVOL_REC_UUID;
-        RtlCopyMemory(&searchkey.offset, &r->root_item.received_uuid.uuid[sizeof(UINT64)], sizeof(UINT64));
+        RtlCopyMemory(&searchkey.offset, &r->root_item.received_uuid.uuid[sizeof(uint64_t)], sizeof(uint64_t));
 
-        Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
             return Status;
         }
 
         if (!keycmp(tp.item->key, searchkey)) {
-            if (tp.item->size + sizeof(UINT64) <= Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node)) {
-                UINT64* ids;
+            if (tp.item->size + sizeof(uint64_t) <= Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node)) {
+                uint64_t* ids;
 
-                ids = ExAllocatePoolWithTag(PagedPool, tp.item->size + sizeof(UINT64), ALLOC_TAG);
+                ids = ExAllocatePoolWithTag(PagedPool, tp.item->size + sizeof(uint64_t), ALLOC_TAG);
                 if (!ids) {
                     ERR("out of memory\n");
                     return STATUS_INSUFFICIENT_RESOURCES;
                 }
 
                 RtlCopyMemory(ids, tp.item->data, tp.item->size);
-                RtlCopyMemory((UINT8*)ids + tp.item->size, &r->id, sizeof(UINT64));
+                RtlCopyMemory((uint8_t*)ids + tp.item->size, &r->id, sizeof(uint64_t));
 
                 Status = delete_tree_item(Vcb, &tp);
                 if (!NT_SUCCESS(Status)) {
@@ -6838,7 +6967,7 @@ static NTSTATUS flush_subvol(device_extension* Vcb, root* r, PIRP Irp) {
                     return Status;
                 }
 
-                Status = insert_tree_item(Vcb, Vcb->uuid_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, ids, tp.item->size + sizeof(UINT64), NULL, Irp);
+                Status = insert_tree_item(Vcb, Vcb->uuid_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, ids, tp.item->size + sizeof(uint64_t), NULL, Irp);
                 if (!NT_SUCCESS(Status)) {
                     ERR("insert_tree_item returned %08x\n", Status);
                     ExFreePool(ids);
@@ -6846,9 +6975,9 @@ static NTSTATUS flush_subvol(device_extension* Vcb, root* r, PIRP Irp) {
                 }
             }
         } else {
-            UINT64* root_num;
+            uint64_t* root_num;
 
-            root_num = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64), ALLOC_TAG);
+            root_num = ExAllocatePoolWithTag(PagedPool, sizeof(uint64_t), ALLOC_TAG);
             if (!root_num) {
                 ERR("out of memory\n");
                 return STATUS_INSUFFICIENT_RESOURCES;
@@ -6856,7 +6985,7 @@ static NTSTATUS flush_subvol(device_extension* Vcb, root* r, PIRP Irp) {
 
             *root_num = r->id;
 
-            Status = insert_tree_item(Vcb, Vcb->uuid_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, root_num, sizeof(UINT64), NULL, Irp);
+            Status = insert_tree_item(Vcb, Vcb->uuid_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, root_num, sizeof(uint64_t), NULL, Irp);
             if (!NT_SUCCESS(Status)) {
                 ERR("insert_tree_item returned %08x\n", Status);
                 ExFreePool(root_num);
@@ -6864,16 +6993,16 @@ static NTSTATUS flush_subvol(device_extension* Vcb, root* r, PIRP Irp) {
             }
         }
 
-        r->received = FALSE;
+        r->received = false;
     }
 
-    r->dirty = FALSE;
+    r->dirty = false;
 
     return STATUS_SUCCESS;
 }
 
 static NTSTATUS test_not_full(device_extension* Vcb) {
-    UINT64 reserve, could_alloc, free_space;
+    uint64_t reserve, could_alloc, free_space;
     LIST_ENTRY* le;
 
     // This function ensures we drop into readonly mode if we're about to leave very little
@@ -6893,14 +7022,14 @@ static NTSTATUS test_not_full(device_extension* Vcb) {
     could_alloc = 0;
 
     if (Vcb->metadata_flags & BLOCK_FLAG_RAID5) {
-        UINT64 s1 = 0, s2 = 0, s3 = 0;
+        uint64_t s1 = 0, s2 = 0, s3 = 0;
 
         le = Vcb->devices.Flink;
         while (le != &Vcb->devices) {
             device* dev = CONTAINING_RECORD(le, device, list_entry);
 
             if (!dev->readonly) {
-                UINT64 space = dev->devitem.num_bytes - dev->devitem.bytes_used;
+                uint64_t space = dev->devitem.num_bytes - dev->devitem.bytes_used;
 
                 if (space >= s1) {
                     s3 = s2;
@@ -6918,14 +7047,14 @@ static NTSTATUS test_not_full(device_extension* Vcb) {
 
         could_alloc = s3 * 2;
     } else if (Vcb->metadata_flags & (BLOCK_FLAG_RAID10 | BLOCK_FLAG_RAID6)) {
-        UINT64 s1 = 0, s2 = 0, s3 = 0, s4 = 0;
+        uint64_t s1 = 0, s2 = 0, s3 = 0, s4 = 0;
 
         le = Vcb->devices.Flink;
         while (le != &Vcb->devices) {
             device* dev = CONTAINING_RECORD(le, device, list_entry);
 
             if (!dev->readonly) {
-                UINT64 space = dev->devitem.num_bytes - dev->devitem.bytes_used;
+                uint64_t space = dev->devitem.num_bytes - dev->devitem.bytes_used;
 
                 if (space >= s1) {
                     s4 = s3;
@@ -6948,14 +7077,14 @@ static NTSTATUS test_not_full(device_extension* Vcb) {
 
         could_alloc = s4 * 2;
     } else if (Vcb->metadata_flags & (BLOCK_FLAG_RAID0 | BLOCK_FLAG_RAID1)) {
-        UINT64 s1 = 0, s2 = 0;
+        uint64_t s1 = 0, s2 = 0;
 
         le = Vcb->devices.Flink;
         while (le != &Vcb->devices) {
             device* dev = CONTAINING_RECORD(le, device, list_entry);
 
             if (!dev->readonly) {
-                UINT64 space = dev->devitem.num_bytes - dev->devitem.bytes_used;
+                uint64_t space = dev->devitem.num_bytes - dev->devitem.bytes_used;
 
                 if (space >= s1) {
                     s2 = s1;
@@ -6977,7 +7106,7 @@ static NTSTATUS test_not_full(device_extension* Vcb) {
             device* dev = CONTAINING_RECORD(le, device, list_entry);
 
             if (!dev->readonly) {
-                UINT64 space = (dev->devitem.num_bytes - dev->devitem.bytes_used) / 2;
+                uint64_t space = (dev->devitem.num_bytes - dev->devitem.bytes_used) / 2;
 
                 could_alloc = max(could_alloc, space);
             }
@@ -6990,7 +7119,7 @@ static NTSTATUS test_not_full(device_extension* Vcb) {
             device* dev = CONTAINING_RECORD(le, device, list_entry);
 
             if (!dev->readonly) {
-                UINT64 space = dev->devitem.num_bytes - dev->devitem.bytes_used;
+                uint64_t space = dev->devitem.num_bytes - dev->devitem.bytes_used;
 
                 could_alloc = max(could_alloc, space);
             }
@@ -7035,7 +7164,7 @@ static NTSTATUS check_for_orphans_root(device_extension* Vcb, root* r, PIRP Irp)
     searchkey.obj_type = TYPE_ORPHAN_INODE;
     searchkey.offset = 0;
 
-    Status = find_item(Vcb, r, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, r, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
@@ -7050,9 +7179,9 @@ static NTSTATUS check_for_orphans_root(device_extension* Vcb, root* r, PIRP Irp)
         if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type) {
             fcb* fcb;
 
-            TRACE("removing orphaned inode %llx\n", tp.item->key.offset);
+            TRACE("removing orphaned inode %I64x\n", tp.item->key.offset);
 
-            Status = open_fcb(Vcb, r, tp.item->key.offset, 0, NULL, FALSE, NULL, &fcb, PagedPool, Irp);
+            Status = open_fcb(Vcb, r, tp.item->key.offset, 0, NULL, false, NULL, &fcb, PagedPool, Irp);
             if (!NT_SUCCESS(Status))
                 ERR("open_fcb returned %08x\n", Status);
             else {
@@ -7065,7 +7194,7 @@ static NTSTATUS check_for_orphans_root(device_extension* Vcb, root* r, PIRP Irp)
                         }
                     }
 
-                    fcb->deleted = TRUE;
+                    fcb->deleted = true;
 
                     mark_fcb_dirty(fcb);
                 }
@@ -7080,11 +7209,11 @@ static NTSTATUS check_for_orphans_root(device_extension* Vcb, root* r, PIRP Irp)
             }
         }
 
-        if (find_next_item(Vcb, &tp, &next_tp, FALSE, Irp))
+        if (find_next_item(Vcb, &tp, &next_tp, false, Irp))
             tp = next_tp;
         else
             break;
-    } while (TRUE);
+    } while (true);
 
     Status = STATUS_SUCCESS;
 
@@ -7114,7 +7243,7 @@ static NTSTATUS check_for_orphans(device_extension* Vcb, PIRP Irp) {
                 return Status;
             }
 
-            fr->fcb->subvol->checked_for_orphans = TRUE;
+            fr->fcb->subvol->checked_for_orphans = true;
         }
 
         le = le->Flink;
@@ -7126,11 +7255,11 @@ static NTSTATUS check_for_orphans(device_extension* Vcb, PIRP Irp) {
 static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     LIST_ENTRY *le, batchlist;
-    BOOL cache_changed = FALSE;
+    bool cache_changed = false;
     volume_device_extension* vde;
-    BOOL no_cache = FALSE;
+    bool no_cache = false;
 #ifdef DEBUG_FLUSH_TIMES
-    UINT64 filerefs = 0, fcbs = 0;
+    uint64_t filerefs = 0, fcbs = 0;
     LARGE_INTEGER freq, time1, time2;
 #endif
 #ifdef DEBUG_WRITE_LOOPS
@@ -7151,7 +7280,7 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
         return Status;
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->dirty_filerefs_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->dirty_filerefs_lock, true);
 
     while (!IsListEmpty(&Vcb->dirty_filerefs)) {
         file_ref* fr = CONTAINING_RECORD(RemoveHeadList(&Vcb->dirty_filerefs), file_ref, list_entry_dirty);
@@ -7175,7 +7304,7 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
 #ifdef DEBUG_FLUSH_TIMES
     time2 = KeQueryPerformanceCounter(NULL);
 
-    ERR("flushed %llu filerefs in %llu (freq = %llu)\n", filerefs, time2.QuadPart - time1.QuadPart, freq.QuadPart);
+    ERR("flushed %I64u filerefs in %I64u (freq = %I64u)\n", filerefs, time2.QuadPart - time1.QuadPart, freq.QuadPart);
 
     time1 = KeQueryPerformanceCounter(&freq);
 #endif
@@ -7185,7 +7314,7 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
     // We also process deleted normal files, to avoid any problems
     // caused by inode collisions.
 
-    ExAcquireResourceExclusiveLite(&Vcb->dirty_fcbs_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->dirty_fcbs_lock, true);
 
     le = Vcb->dirty_fcbs.Flink;
     while (le != &Vcb->dirty_fcbs) {
@@ -7193,8 +7322,8 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
         LIST_ENTRY* le2 = le->Flink;
 
         if (fcb->deleted) {
-            ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
-            Status = flush_fcb(fcb, FALSE, &batchlist, Irp);
+            ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
+            Status = flush_fcb(fcb, false, &batchlist, Irp);
             ExReleaseResourceLite(fcb->Header.Resource);
 
             free_fcb(fcb);
@@ -7227,8 +7356,8 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
         LIST_ENTRY* le2 = le->Flink;
 
         if (fcb->subvol != Vcb->root_root) {
-            ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
-            Status = flush_fcb(fcb, FALSE, &batchlist, Irp);
+            ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
+            Status = flush_fcb(fcb, false, &batchlist, Irp);
             ExReleaseResourceLite(fcb->Header.Resource);
             free_fcb(fcb);
 
@@ -7257,7 +7386,7 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
 #ifdef DEBUG_FLUSH_TIMES
     time2 = KeQueryPerformanceCounter(NULL);
 
-    ERR("flushed %llu fcbs in %llu (freq = %llu)\n", filerefs, time2.QuadPart - time1.QuadPart, freq.QuadPart);
+    ERR("flushed %I64u fcbs in %I64u (freq = %I64u)\n", filerefs, time2.QuadPart - time1.QuadPart, freq.QuadPart);
 #endif
 
     // no need to get dirty_subvols_lock here, as we have tree_lock exclusively
@@ -7300,13 +7429,13 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
         searchkey.obj_type = 0;
         searchkey.offset = 0;
 
-        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
         }
 
-        Vcb->root_root->treeholder.tree->write = TRUE;
+        Vcb->root_root->treeholder.tree->write = true;
     }
 
     // make sure we always update the extent tree
@@ -7327,13 +7456,13 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
                     ERR("flush_changed_dev_stats returned %08x\n", Status);
                     return Status;
                 }
-                dev->stats_changed = FALSE;
+                dev->stats_changed = false;
             }
 
             le = le->Flink;
         }
 
-        Vcb->stats_changed = FALSE;
+        Vcb->stats_changed = false;
     }
 
     do {
@@ -7366,8 +7495,8 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
                 Status = allocate_cache(Vcb, &cache_changed, Irp, rollback);
                 if (!NT_SUCCESS(Status)) {
                     WARN("allocate_cache returned %08x\n", Status);
-                    no_cache = TRUE;
-                    cache_changed = FALSE;
+                    no_cache = true;
+                    cache_changed = false;
                 }
             }
         } else {
@@ -7421,7 +7550,7 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
         searchkey.obj_type = TYPE_METADATA_ITEM;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             goto end;
@@ -7432,14 +7561,14 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
             searchkey.obj_type = TYPE_EXTENT_ITEM;
             searchkey.offset = 0xffffffffffffffff;
 
-            Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+            Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
             if (!NT_SUCCESS(Status)) {
                 ERR("error - find_item returned %08x\n", Status);
                 goto end;
             }
 
             if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-                ERR("error - could not find entry in extent tree for tree at %llx\n", t->header.address);
+                ERR("error - could not find entry in extent tree for tree at %I64x\n", t->header.address);
                 Status = STATUS_INTERNAL_ERROR;
                 goto end;
             }
@@ -7465,7 +7594,7 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
     if (vde) {
         pdo_device_extension* pdode = vde->pdode;
 
-        ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+        ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
         le = pdode->children.Flink;
 
@@ -7485,8 +7614,8 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
     while (le != &Vcb->chunks) {
         chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
 
-        c->changed = FALSE;
-        c->space_changed = FALSE;
+        c->changed = false;
+        c->space_changed = false;
 
         le = le->Flink;
     }
@@ -7499,12 +7628,12 @@ static NTSTATUS do_write2(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollback)
     while (le != &Vcb->trees) {
         tree* t = CONTAINING_RECORD(le, tree, list_entry);
 
-        t->write = FALSE;
+        t->write = false;
 
         le = le->Flink;
     }
 
-    Vcb->need_write = FALSE;
+    Vcb->need_write = false;
 
     while (!IsListEmpty(&Vcb->drop_roots)) {
         root* r = CONTAINING_RECORD(RemoveHeadList(&Vcb->drop_roots), root, list_entry);
@@ -7530,7 +7659,7 @@ NTSTATUS do_write(device_extension* Vcb, PIRP Irp) {
 
     if (!NT_SUCCESS(Status)) {
         ERR("do_write2 returned %08x, dropping into readonly mode\n", Status);
-        Vcb->readonly = TRUE;
+        Vcb->readonly = true;
         FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_FORCED_CLOSED);
         do_rollback(Vcb, &rollback);
     } else
@@ -7539,45 +7668,10 @@ NTSTATUS do_write(device_extension* Vcb, PIRP Irp) {
     return Status;
 }
 
-#ifdef DEBUG_STATS
-static void print_stats(device_extension* Vcb) {
-    LARGE_INTEGER freq;
-
-    ERR("READ STATS:\n");
-    ERR("number of reads: %llu\n", Vcb->stats.num_reads);
-    ERR("data read: %llu bytes\n", Vcb->stats.data_read);
-    ERR("total time taken: %llu\n", Vcb->stats.read_total_time);
-    ERR("csum time taken: %llu\n", Vcb->stats.read_csum_time);
-    ERR("disk time taken: %llu\n", Vcb->stats.read_disk_time);
-    ERR("other time taken: %llu\n", Vcb->stats.read_total_time - Vcb->stats.read_csum_time - Vcb->stats.read_disk_time);
-
-    KeQueryPerformanceCounter(&freq);
-
-    ERR("OPEN STATS (freq = %llu):\n", freq.QuadPart);
-    ERR("number of opens: %llu\n", Vcb->stats.num_opens);
-    ERR("total time taken: %llu\n", Vcb->stats.open_total_time);
-    ERR("number of overwrites: %llu\n", Vcb->stats.num_overwrites);
-    ERR("total time taken: %llu\n", Vcb->stats.overwrite_total_time);
-    ERR("number of creates: %llu\n", Vcb->stats.num_creates);
-    ERR("calls to open_fcb: %llu\n", Vcb->stats.open_fcb_calls);
-    ERR("time spent in open_fcb: %llu\n", Vcb->stats.open_fcb_time);
-    ERR("calls to open_fileref_child: %llu\n", Vcb->stats.open_fileref_child_calls);
-    ERR("time spent in open_fileref_child: %llu\n", Vcb->stats.open_fileref_child_time);
-    ERR("time spent waiting for fcb_lock: %llu\n", Vcb->stats.fcb_lock_time);
-    ERR("total time taken: %llu\n", Vcb->stats.create_total_time);
-
-    RtlZeroMemory(&Vcb->stats, sizeof(debug_stats));
-}
-#endif
-
 static void do_flush(device_extension* Vcb) {
     NTSTATUS Status;
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
-
-#ifdef DEBUG_STATS
-    print_stats(Vcb);
-#endif
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     if (Vcb->need_write && !Vcb->readonly)
         Status = do_write(Vcb, NULL);
@@ -7593,11 +7687,7 @@ static void do_flush(device_extension* Vcb) {
 }
 
 _Function_class_(KSTART_ROUTINE)
-#ifdef __REACTOS__
-void NTAPI flush_thread(void* context) {
-#else
-void flush_thread(void* context) {
-#endif
+void __stdcall flush_thread(void* context) {
     DEVICE_OBJECT* devobj = context;
     device_extension* Vcb = devobj->DeviceExtension;
     LARGE_INTEGER due_time;
@@ -7606,12 +7696,12 @@ void flush_thread(void* context) {
 
     KeInitializeTimer(&Vcb->flush_thread_timer);
 
-    due_time.QuadPart = (UINT64)Vcb->options.flush_interval * -10000000;
+    due_time.QuadPart = (uint64_t)Vcb->options.flush_interval * -10000000;
 
     KeSetTimer(&Vcb->flush_thread_timer, due_time, NULL);
 
-    while (TRUE) {
-        KeWaitForSingleObject(&Vcb->flush_thread_timer, Executive, KernelMode, FALSE, NULL);
+    while (true) {
+        KeWaitForSingleObject(&Vcb->flush_thread_timer, Executive, KernelMode, false, NULL);
 
         if (!(devobj->Vpb->Flags & VPB_MOUNTED) || Vcb->removing)
             break;
@@ -7625,7 +7715,7 @@ void flush_thread(void* context) {
     ObDereferenceObject(devobj);
     KeCancelTimer(&Vcb->flush_thread_timer);
 
-    KeSetEvent(&Vcb->flush_thread_finished, 0, FALSE);
+    KeSetEvent(&Vcb->flush_thread_finished, 0, false);
 
     PsTerminateSystemThread(STATUS_SUCCESS);
 }
diff --git a/drivers/filesystems/btrfs/free-space.c b/drivers/filesystems/btrfs/free-space.c
index e74a4a5346f..56f94faec9f 100644
--- a/drivers/filesystems/btrfs/free-space.c
+++ b/drivers/filesystems/btrfs/free-space.c
@@ -21,11 +21,11 @@
 // this be a constant number of sectors, a constant 256 KB, or what?
 #define CACHE_INCREMENTS    64
 
-static NTSTATUS remove_free_space_inode(device_extension* Vcb, UINT64 inode, LIST_ENTRY* batchlist, PIRP Irp, LIST_ENTRY* rollback) {
+static NTSTATUS remove_free_space_inode(device_extension* Vcb, uint64_t inode, LIST_ENTRY* batchlist, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     fcb* fcb;
 
-    Status = open_fcb(Vcb, Vcb->root_root, inode, BTRFS_TYPE_FILE, NULL, FALSE, NULL, &fcb, PagedPool, Irp);
+    Status = open_fcb(Vcb, Vcb->root_root, inode, BTRFS_TYPE_FILE, NULL, false, NULL, &fcb, PagedPool, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("open_fcb returned %08x\n", Status);
         return Status;
@@ -41,9 +41,9 @@ static NTSTATUS remove_free_space_inode(device_extension* Vcb, UINT64 inode, LIS
         }
     }
 
-    fcb->deleted = TRUE;
+    fcb->deleted = true;
 
-    Status = flush_fcb(fcb, FALSE, batchlist, Irp);
+    Status = flush_fcb(fcb, false, batchlist, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("flush_fcb returned %08x\n", Status);
         free_fcb(fcb);
@@ -59,7 +59,7 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI
     KEY searchkey;
     traverse_ptr tp, next_tp;
     NTSTATUS Status;
-    BOOL b;
+    bool b;
     LIST_ENTRY rollback;
 
     InitializeListHead(&rollback);
@@ -68,7 +68,7 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI
     searchkey.obj_type = 0;
     searchkey.offset = 0;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
@@ -89,14 +89,14 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI
                 FREE_SPACE_ITEM* fsi = (FREE_SPACE_ITEM*)tp.item->data;
 
                 if (fsi->key.obj_type != TYPE_INODE_ITEM)
-                    WARN("key (%llx,%x,%llx) does not point to an INODE_ITEM\n", fsi->key.obj_id, fsi->key.obj_type, fsi->key.offset);
+                    WARN("key (%I64x,%x,%I64x) does not point to an INODE_ITEM\n", fsi->key.obj_id, fsi->key.obj_type, fsi->key.offset);
                 else {
                     LIST_ENTRY* le;
 
                     Status = remove_free_space_inode(Vcb, fsi->key.obj_id, batchlist, Irp, &rollback);
 
                     if (!NT_SUCCESS(Status))
-                        ERR("remove_free_space_inode for (%llx,%x,%llx) returned %08x\n", fsi->key.obj_id, fsi->key.obj_type, fsi->key.offset, Status);
+                        ERR("remove_free_space_inode for (%I64x,%x,%I64x) returned %08x\n", fsi->key.obj_id, fsi->key.obj_type, fsi->key.offset, Status);
 
                     le = Vcb->chunks.Flink;
                     while (le != &Vcb->chunks) {
@@ -111,10 +111,10 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI
                     }
                 }
             } else
-                WARN("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_ITEM));
+                WARN("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_ITEM));
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, Irp);
+        b = find_next_item(Vcb, &tp, &next_tp, false, Irp);
         if (b)
             tp = next_tp;
     } while (b);
@@ -131,7 +131,7 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI
         searchkey.obj_type = 0;
         searchkey.offset = 0;
 
-        Status = find_item(Vcb, Vcb->space_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->space_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
             return Status;
@@ -144,7 +144,7 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI
                 return Status;
             }
 
-            b = find_next_item(Vcb, &tp, &next_tp, FALSE, Irp);
+            b = find_next_item(Vcb, &tp, &next_tp, false, Irp);
             if (b)
                 tp = next_tp;
         } while (b);
@@ -154,7 +154,7 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI
     if (Vcb->superblock.compat_ro_flags & BTRFS_COMPAT_RO_FLAGS_FREE_SPACE_CACHE) {
         LIST_ENTRY* le;
 
-        ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+        ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
         le = Vcb->chunks.Flink;
         while (le != &Vcb->chunks) {
@@ -165,14 +165,14 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI
 
                 Status = load_cache_chunk(Vcb, c, NULL);
                 if (!NT_SUCCESS(Status)) {
-                    ERR("load_cache_chunk(%llx) returned %08x\n", c->offset, Status);
+                    ERR("load_cache_chunk(%I64x) returned %08x\n", c->offset, Status);
                     release_chunk_lock(c, Vcb);
                     ExReleaseResourceLite(&Vcb->chunk_lock);
                     return Status;
                 }
 
-                c->changed = TRUE;
-                c->space_changed = TRUE;
+                c->changed = true;
+                c->space_changed = true;
 
                 release_chunk_lock(c, Vcb);
             }
@@ -186,7 +186,7 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI
     return Status;
 }
 
-NTSTATUS add_space_entry(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 offset, UINT64 size) {
+NTSTATUS add_space_entry(LIST_ENTRY* list, LIST_ENTRY* list_size, uint64_t offset, uint64_t size) {
     space* s;
 
     s = ExAllocatePoolWithTag(PagedPool, sizeof(space), ALLOC_TAG);
@@ -254,23 +254,35 @@ size:
     return STATUS_SUCCESS;
 }
 
-static void load_free_space_bitmap(device_extension* Vcb, chunk* c, UINT64 offset, void* data, UINT64* total_space) {
+static void load_free_space_bitmap(device_extension* Vcb, chunk* c, uint64_t offset, void* data, uint64_t* total_space) {
     RTL_BITMAP bmph;
-    UINT32 i, *dwords = data;
+    uint32_t i, len, *dwords = data;
     ULONG runlength, index;
 
     // flip bits
-    for (i = 0; i < Vcb->superblock.sector_size / sizeof(UINT32); i++) {
+    for (i = 0; i < Vcb->superblock.sector_size / sizeof(uint32_t); i++) {
         dwords[i] = ~dwords[i];
     }
 
-    RtlInitializeBitMap(&bmph, data, Vcb->superblock.sector_size * 8);
+    len = Vcb->superblock.sector_size * 8;
+
+    RtlInitializeBitMap(&bmph, data, len);
 
     index = 0;
     runlength = RtlFindFirstRunClear(&bmph, &index);
 
     while (runlength != 0) {
-        UINT64 addr, length;
+        uint64_t addr, length;
+
+        if (index >= len)
+            break;
+
+        if (index + runlength >= len) {
+            runlength = len - index;
+
+            if (runlength == 0)
+                break;
+        }
 
         addr = offset + (index * Vcb->superblock.sector_size);
         length = Vcb->superblock.sector_size * runlength;
@@ -308,24 +320,24 @@ static void order_space_entry(space* s, LIST_ENTRY* list_size) {
 }
 
 typedef struct {
-    UINT64 stripe;
+    uint64_t stripe;
     LIST_ENTRY list_entry;
 } superblock_stripe;
 
-static NTSTATUS add_superblock_stripe(LIST_ENTRY* stripes, UINT64 off, UINT64 len) {
-    UINT64 i;
+static NTSTATUS add_superblock_stripe(LIST_ENTRY* stripes, uint64_t off, uint64_t len) {
+    uint64_t i;
 
     for (i = 0; i < len; i++) {
         LIST_ENTRY* le;
         superblock_stripe* ss;
-        BOOL ignore = FALSE;
+        bool ignore = false;
 
         le = stripes->Flink;
         while (le != stripes) {
             ss = CONTAINING_RECORD(le, superblock_stripe, list_entry);
 
             if (ss->stripe == off + i) {
-                ignore = TRUE;
+                ignore = true;
                 break;
             }
 
@@ -348,12 +360,12 @@ static NTSTATUS add_superblock_stripe(LIST_ENTRY* stripes, UINT64 off, UINT64 le
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS get_superblock_size(chunk* c, UINT64* size) {
+static NTSTATUS get_superblock_size(chunk* c, uint64_t* size) {
     NTSTATUS Status;
     CHUNK_ITEM* ci = c->chunk_item;
     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&ci[1];
-    UINT64 off_start, off_end, space = 0;
-    UINT16 i = 0, j;
+    uint64_t off_start, off_end, space = 0;
+    uint16_t i = 0, j;
     LIST_ENTRY stripes;
 
     InitializeListHead(&stripes);
@@ -380,7 +392,7 @@ static NTSTATUS get_superblock_size(chunk* c, UINT64* size) {
             }
         } else if (ci->type & BLOCK_FLAG_RAID5) {
             for (j = 0; j < ci->num_stripes; j++) {
-                UINT64 stripe_size = ci->size / (ci->num_stripes - 1);
+                uint64_t stripe_size = ci->size / (ci->num_stripes - 1);
 
                 if (cis[j].offset + stripe_size > superblock_addrs[i] && cis[j].offset <= superblock_addrs[i] + sizeof(superblock)) {
                     off_start = superblock_addrs[i] - cis[j].offset;
@@ -398,7 +410,7 @@ static NTSTATUS get_superblock_size(chunk* c, UINT64* size) {
             }
         } else if (ci->type & BLOCK_FLAG_RAID6) {
             for (j = 0; j < ci->num_stripes; j++) {
-                UINT64 stripe_size = ci->size / (ci->num_stripes - 2);
+                uint64_t stripe_size = ci->size / (ci->num_stripes - 2);
 
                 if (cis[j].offset + stripe_size > superblock_addrs[i] && cis[j].offset <= superblock_addrs[i] + sizeof(superblock)) {
                     off_start = superblock_addrs[i] - cis[j].offset;
@@ -450,39 +462,39 @@ end:
     return Status;
 }
 
-NTSTATUS load_stored_free_space_cache(device_extension* Vcb, chunk* c, BOOL load_only, PIRP Irp) {
+NTSTATUS load_stored_free_space_cache(device_extension* Vcb, chunk* c, bool load_only, PIRP Irp) {
     KEY searchkey;
     traverse_ptr tp;
     FREE_SPACE_ITEM* fsi;
-    UINT64 inode, *generation;
-    UINT8* data;
+    uint64_t inode, *generation;
+    uint8_t* data;
     NTSTATUS Status;
-    UINT32 *checksums, crc32, i, num_sectors, num_valid_sectors, size;
+    uint32_t *checksums, crc32, i, num_sectors, num_valid_sectors, size;
     FREE_SPACE_ENTRY* fse;
-    UINT64 num_entries, num_bitmaps, extent_length, bmpnum, off, total_space = 0, superblock_size;
+    uint64_t num_entries, num_bitmaps, extent_length, bmpnum, off, total_space = 0, superblock_size;
     LIST_ENTRY *le, rollback;
 
     // FIXME - does this break if Vcb->superblock.sector_size is not 4096?
 
-    TRACE("(%p, %llx)\n", Vcb, c->offset);
+    TRACE("(%p, %I64x)\n", Vcb, c->offset);
 
     searchkey.obj_id = FREE_SPACE_CACHE_ID;
     searchkey.obj_type = 0;
     searchkey.offset = c->offset;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         return Status;
     }
 
     if (keycmp(tp.item->key, searchkey)) {
-        TRACE("(%llx,%x,%llx) not found\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+        TRACE("(%I64x,%x,%I64x) not found\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
         return STATUS_NOT_FOUND;
     }
 
     if (tp.item->size < sizeof(FREE_SPACE_ITEM)) {
-        WARN("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_ITEM));
+        WARN("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_ITEM));
         return STATUS_NOT_FOUND;
     }
 
@@ -497,7 +509,7 @@ NTSTATUS load_stored_free_space_cache(device_extension* Vcb, chunk* c, BOOL load
     num_entries = fsi->num_entries;
     num_bitmaps = fsi->num_bitmaps;
 
-    Status = open_fcb(Vcb, Vcb->root_root, inode, BTRFS_TYPE_FILE, NULL, FALSE, NULL, &c->cache, PagedPool, Irp);
+    Status = open_fcb(Vcb, Vcb->root_root, inode, BTRFS_TYPE_FILE, NULL, false, NULL, &c->cache, PagedPool, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("open_fcb returned %08x\n", Status);
         return STATUS_NOT_FOUND;
@@ -518,7 +530,7 @@ NTSTATUS load_stored_free_space_cache(device_extension* Vcb, chunk* c, BOOL load
     if (num_entries == 0 && num_bitmaps == 0)
         return STATUS_SUCCESS;
 
-    size = (UINT32)sector_align(c->cache->inode_item.st_size, Vcb->superblock.sector_size);
+    size = (uint32_t)sector_align(c->cache->inode_item.st_size, Vcb->superblock.sector_size);
 
     data = ExAllocatePoolWithTag(PagedPool, size, ALLOC_TAG);
 
@@ -539,7 +551,7 @@ NTSTATUS load_stored_free_space_cache(device_extension* Vcb, chunk* c, BOOL load
         ERR("read_file returned %08x\n", Status);
         ExFreePool(data);
 
-        c->cache->deleted = TRUE;
+        c->cache->deleted = true;
         mark_fcb_dirty(c->cache);
 
         free_fcb(c->cache);
@@ -552,39 +564,39 @@ NTSTATUS load_stored_free_space_cache(device_extension* Vcb, chunk* c, BOOL load
 
     num_sectors = size / Vcb->superblock.sector_size;
 
-    generation = (UINT64*)(data + (num_sectors * sizeof(UINT32)));
+    generation = (uint64_t*)(data + (num_sectors * sizeof(uint32_t)));
 
     if (*generation != fsi->generation) {
-        WARN("free space cache generation for %llx was %llx, expected %llx\n", c->offset, *generation, fsi->generation);
+        WARN("free space cache generation for %I64x was %I64x, expected %I64x\n", c->offset, *generation, fsi->generation);
         goto clearcache;
     }
 
-    extent_length = (num_sectors * sizeof(UINT32)) + sizeof(UINT64) + (num_entries * sizeof(FREE_SPACE_ENTRY));
+    extent_length = (num_sectors * sizeof(uint32_t)) + sizeof(uint64_t) + (num_entries * sizeof(FREE_SPACE_ENTRY));
 
     num_valid_sectors = (ULONG)((sector_align(extent_length, Vcb->superblock.sector_size) / Vcb->superblock.sector_size) + num_bitmaps);
 
     if (num_valid_sectors > num_sectors) {
-        ERR("free space cache for %llx was %llx sectors, expected at least %llx\n", c->offset, num_sectors, num_valid_sectors);
+        ERR("free space cache for %I64x was %I64x sectors, expected at least %I64x\n", c->offset, num_sectors, num_valid_sectors);
         goto clearcache;
     }
 
-    checksums = (UINT32*)data;
+    checksums = (uint32_t*)data;
 
     for (i = 0; i < num_valid_sectors; i++) {
-        if (i * Vcb->superblock.sector_size > sizeof(UINT32) * num_sectors)
+        if (i * Vcb->superblock.sector_size > sizeof(uint32_t) * num_sectors)
             crc32 = ~calc_crc32c(0xffffffff, &data[i * Vcb->superblock.sector_size], Vcb->superblock.sector_size);
-        else if ((i + 1) * Vcb->superblock.sector_size < sizeof(UINT32) * num_sectors)
+        else if ((i + 1) * Vcb->superblock.sector_size < sizeof(uint32_t) * num_sectors)
             crc32 = 0; // FIXME - test this
         else
-            crc32 = ~calc_crc32c(0xffffffff, &data[sizeof(UINT32) * num_sectors], ((i + 1) * Vcb->superblock.sector_size) - (sizeof(UINT32) * num_sectors));
+            crc32 = ~calc_crc32c(0xffffffff, &data[sizeof(uint32_t) * num_sectors], ((i + 1) * Vcb->superblock.sector_size) - (sizeof(uint32_t) * num_sectors));
 
         if (crc32 != checksums[i]) {
-            WARN("checksum %llu was %08x, expected %08x\n", i, crc32, checksums[i]);
+            WARN("checksum %I64u was %08x, expected %08x\n", i, crc32, checksums[i]);
             goto clearcache;
         }
     }
 
-    off = (sizeof(UINT32) * num_sectors) + sizeof(UINT64);
+    off = (sizeof(uint32_t) * num_sectors) + sizeof(uint64_t);
 
     bmpnum = 0;
     for (i = 0; i < num_entries; i++) {
@@ -611,7 +623,7 @@ NTSTATUS load_stored_free_space_cache(device_extension* Vcb, chunk* c, BOOL load
 
     if (num_bitmaps > 0) {
         bmpnum = sector_align(off, Vcb->superblock.sector_size) / Vcb->superblock.sector_size;
-        off = (sizeof(UINT32) * num_sectors) + sizeof(UINT64);
+        off = (sizeof(uint32_t) * num_sectors) + sizeof(uint64_t);
 
         for (i = 0; i < num_entries; i++) {
             if ((off + sizeof(FREE_SPACE_ENTRY)) / Vcb->superblock.sector_size != off / Vcb->superblock.sector_size)
@@ -639,7 +651,7 @@ NTSTATUS load_stored_free_space_cache(device_extension* Vcb, chunk* c, BOOL load
     }
 
     if (c->chunk_item->size - c->used != total_space + superblock_size) {
-        WARN("invalidating cache for chunk %llx: space was %llx, expected %llx\n", c->offset, total_space + superblock_size, c->chunk_item->size - c->used);
+        WARN("invalidating cache for chunk %I64x: space was %I64x, expected %I64x\n", c->offset, total_space + superblock_size, c->chunk_item->size - c->used);
         goto clearcache;
     }
 
@@ -692,7 +704,7 @@ clearcache:
 
     clear_rollback(&rollback);
 
-    c->cache->deleted = TRUE;
+    c->cache->deleted = true;
     mark_fcb_dirty(c->cache);
 
     c->old_cache = c->cache;
@@ -721,7 +733,7 @@ static NTSTATUS load_stored_free_space_tree(device_extension* Vcb, chunk* c, PIR
     ULONG bmplen = 0;
     LIST_ENTRY* le;
 
-    TRACE("(%p, %llx)\n", Vcb, c->offset);
+    TRACE("(%p, %I64x)\n", Vcb, c->offset);
 
     if (!Vcb->space_root)
         return STATUS_NOT_FOUND;
@@ -730,23 +742,23 @@ static NTSTATUS load_stored_free_space_tree(device_extension* Vcb, chunk* c, PIR
     searchkey.obj_type = TYPE_FREE_SPACE_INFO;
     searchkey.offset = c->chunk_item->size;
 
-    Status = find_item(Vcb, Vcb->space_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->space_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
     }
 
     if (keycmp(tp.item->key, searchkey)) {
-        TRACE("(%llx,%x,%llx) not found\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+        TRACE("(%I64x,%x,%I64x) not found\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
         return STATUS_NOT_FOUND;
     }
 
     if (tp.item->size < sizeof(FREE_SPACE_INFO)) {
-        WARN("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_INFO));
+        WARN("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_INFO));
         return STATUS_NOT_FOUND;
     }
 
-    while (find_next_item(Vcb, &tp, &next_tp, FALSE, Irp)) {
+    while (find_next_item(Vcb, &tp, &next_tp, false, Irp)) {
         tp = next_tp;
 
         if (tp.item->key.obj_id >= c->offset + c->chunk_item->size)
@@ -762,15 +774,16 @@ static NTSTATUS load_stored_free_space_tree(device_extension* Vcb, chunk* c, PIR
         } else if (tp.item->key.obj_type == TYPE_FREE_SPACE_BITMAP) {
             ULONG explen, index, runlength;
             RTL_BITMAP bmp;
-            UINT64 lastoff;
+            uint64_t lastoff;
+            ULONG bmpl;
 
             explen = (ULONG)(tp.item->key.offset / (Vcb->superblock.sector_size * 8));
 
             if (tp.item->size < explen) {
-                WARN("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, explen);
+                WARN("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, explen);
                 return STATUS_NOT_FOUND;
             } else if (tp.item->size == 0) {
-                WARN("(%llx,%x,%llx) has size of 0\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                WARN("(%I64x,%x,%I64x) has size of 0\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
                 return STATUS_NOT_FOUND;
             }
 
@@ -789,15 +802,29 @@ static NTSTATUS load_stored_free_space_tree(device_extension* Vcb, chunk* c, PIR
             // We copy the bitmap because it supposedly has to be ULONG-aligned
             RtlCopyMemory(bmparr, tp.item->data, tp.item->size);
 
-            RtlInitializeBitMap(&bmp, bmparr, (ULONG)(tp.item->key.offset / Vcb->superblock.sector_size));
+            bmpl = (ULONG)tp.item->key.offset / Vcb->superblock.sector_size;
+
+            RtlInitializeBitMap(&bmp, bmparr, bmpl);
 
             lastoff = tp.item->key.obj_id;
 
             runlength = RtlFindFirstRunClear(&bmp, &index);
 
             while (runlength != 0) {
-                UINT64 runstart = tp.item->key.obj_id + (index * Vcb->superblock.sector_size);
-                UINT64 runend = runstart + (runlength * Vcb->superblock.sector_size);
+                uint64_t runstart, runend;
+
+                if (index >= bmpl)
+                    break;
+
+                if (index + runlength >= bmpl) {
+                    runlength = bmpl - index;
+
+                    if (runlength == 0)
+                        break;
+                }
+
+                runstart = tp.item->key.obj_id + (index * Vcb->superblock.sector_size);
+                runend = runstart + (runlength * Vcb->superblock.sector_size);
 
                 if (runstart > lastoff) {
                     Status = add_space_entry(&c->space, &c->space_size, lastoff, runstart - lastoff);
@@ -858,8 +885,8 @@ static NTSTATUS load_stored_free_space_tree(device_extension* Vcb, chunk* c, PIR
 static NTSTATUS load_free_space_cache(device_extension* Vcb, chunk* c, PIRP Irp) {
     traverse_ptr tp, next_tp;
     KEY searchkey;
-    UINT64 lastaddr;
-    BOOL b;
+    uint64_t lastaddr;
+    bool b;
     space* s;
     NTSTATUS Status;
 
@@ -871,7 +898,7 @@ static NTSTATUS load_free_space_cache(device_extension* Vcb, chunk* c, PIRP Irp)
             return Status;
         }
     } else if (Vcb->superblock.generation - 1 == Vcb->superblock.cache_generation) {
-        Status = load_stored_free_space_cache(Vcb, c, FALSE, Irp);
+        Status = load_stored_free_space_cache(Vcb, c, false, Irp);
 
         if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND) {
             ERR("load_stored_free_space_cache returned %08x\n", Status);
@@ -881,13 +908,13 @@ static NTSTATUS load_free_space_cache(device_extension* Vcb, chunk* c, PIRP Irp)
         Status = STATUS_NOT_FOUND;
 
     if (Status == STATUS_NOT_FOUND) {
-        TRACE("generating free space cache for chunk %llx\n", c->offset);
+        TRACE("generating free space cache for chunk %I64x\n", c->offset);
 
         searchkey.obj_id = c->offset;
         searchkey.obj_type = TYPE_EXTENT_ITEM;
         searchkey.offset = 0;
 
-        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
@@ -914,7 +941,7 @@ static NTSTATUS load_free_space_cache(device_extension* Vcb, chunk* c, PIRP Irp)
 
                     order_space_entry(s, &c->space_size);
 
-                    TRACE("(%llx,%llx)\n", s->address, s->size);
+                    TRACE("(%I64x,%I64x)\n", s->address, s->size);
                 }
 
                 if (tp.item->key.obj_type == TYPE_METADATA_ITEM)
@@ -923,7 +950,7 @@ static NTSTATUS load_free_space_cache(device_extension* Vcb, chunk* c, PIRP Irp)
                     lastaddr = tp.item->key.obj_id + tp.item->key.offset;
             }
 
-            b = find_next_item(Vcb, &tp, &next_tp, FALSE, Irp);
+            b = find_next_item(Vcb, &tp, &next_tp, false, Irp);
             if (b)
                 tp = next_tp;
         } while (b);
@@ -942,7 +969,7 @@ static NTSTATUS load_free_space_cache(device_extension* Vcb, chunk* c, PIRP Irp)
 
             order_space_entry(s, &c->space_size);
 
-            TRACE("(%llx,%llx)\n", s->address, s->size);
+            TRACE("(%I64x,%I64x)\n", s->address, s->size);
         }
     }
 
@@ -963,16 +990,16 @@ NTSTATUS load_cache_chunk(device_extension* Vcb, chunk* c, PIRP Irp) {
 
     protect_superblocks(c);
 
-    c->cache_loaded = TRUE;
+    c->cache_loaded = true;
 
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS insert_cache_extent(fcb* fcb, UINT64 start, UINT64 length, LIST_ENTRY* rollback) {
+static NTSTATUS insert_cache_extent(fcb* fcb, uint64_t start, uint64_t length, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     LIST_ENTRY* le = fcb->Vcb->chunks.Flink;
     chunk* c;
-    UINT64 flags;
+    uint64_t flags;
 
     flags = fcb->Vcb->data_flags;
 
@@ -983,7 +1010,7 @@ static NTSTATUS insert_cache_extent(fcb* fcb, UINT64 start, UINT64 length, LIST_
             acquire_chunk_lock(c, fcb->Vcb);
 
             if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= length) {
-                if (insert_extent_chunk(fcb->Vcb, fcb, c, start, length, FALSE, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, length, FALSE, 0))
+                if (insert_extent_chunk(fcb->Vcb, fcb, c, start, length, false, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, length, false, 0))
                     return STATUS_SUCCESS;
             }
 
@@ -993,7 +1020,7 @@ static NTSTATUS insert_cache_extent(fcb* fcb, UINT64 start, UINT64 length, LIST_
         le = le->Flink;
     }
 
-    Status = alloc_chunk(fcb->Vcb, flags, &c, FALSE);
+    Status = alloc_chunk(fcb->Vcb, flags, &c, false);
 
     if (!NT_SUCCESS(Status)) {
         ERR("alloc_chunk returned %08x\n", Status);
@@ -1003,7 +1030,7 @@ static NTSTATUS insert_cache_extent(fcb* fcb, UINT64 start, UINT64 length, LIST_
     acquire_chunk_lock(c, fcb->Vcb);
 
     if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= length) {
-        if (insert_extent_chunk(fcb->Vcb, fcb, c, start, length, FALSE, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, length, FALSE, 0))
+        if (insert_extent_chunk(fcb->Vcb, fcb, c, start, length, false, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, length, false, 0))
             return STATUS_SUCCESS;
     }
 
@@ -1012,17 +1039,17 @@ static NTSTATUS insert_cache_extent(fcb* fcb, UINT64 start, UINT64 length, LIST_
     return STATUS_DISK_FULL;
 }
 
-static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* changed, LIST_ENTRY* batchlist, PIRP Irp, LIST_ENTRY* rollback) {
+static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, bool* changed, LIST_ENTRY* batchlist, PIRP Irp, LIST_ENTRY* rollback) {
     LIST_ENTRY* le;
     NTSTATUS Status;
-    UINT64 num_entries, new_cache_size, i;
-    UINT32 num_sectors;
-    BOOL realloc_extents = FALSE;
+    uint64_t num_entries, new_cache_size, i;
+    uint32_t num_sectors;
+    bool realloc_extents = false;
 
     // FIXME - also do bitmaps
     // FIXME - make sure this works when sector_size is not 4096
 
-    *changed = FALSE;
+    *changed = false;
 
     num_entries = 0;
 
@@ -1047,14 +1074,14 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
         }
     }
 
-    new_cache_size = sizeof(UINT64) + (num_entries * sizeof(FREE_SPACE_ENTRY));
+    new_cache_size = sizeof(uint64_t) + (num_entries * sizeof(FREE_SPACE_ENTRY));
 
-    num_sectors = (UINT32)sector_align(new_cache_size, Vcb->superblock.sector_size) / Vcb->superblock.sector_size;
-    num_sectors = (UINT32)sector_align(num_sectors, CACHE_INCREMENTS);
+    num_sectors = (uint32_t)sector_align(new_cache_size, Vcb->superblock.sector_size) / Vcb->superblock.sector_size;
+    num_sectors = (uint32_t)sector_align(num_sectors, CACHE_INCREMENTS);
 
     // adjust for padding
     // FIXME - there must be a more efficient way of doing this
-    new_cache_size = sizeof(UINT64) + (sizeof(UINT32) * num_sectors);
+    new_cache_size = sizeof(uint64_t) + (sizeof(uint32_t) * num_sectors);
     for (i = 0; i < num_entries; i++) {
         if ((new_cache_size / Vcb->superblock.sector_size) != ((new_cache_size + sizeof(FREE_SPACE_ENTRY)) / Vcb->superblock.sector_size))
             new_cache_size = sector_align(new_cache_size, Vcb->superblock.sector_size);
@@ -1064,11 +1091,11 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
 
     new_cache_size = sector_align(new_cache_size, CACHE_INCREMENTS * Vcb->superblock.sector_size);
 
-    TRACE("chunk %llx: cache_size = %llx, new_cache_size = %llx\n", c->offset, c->cache ? c->cache->inode_item.st_size : 0, new_cache_size);
+    TRACE("chunk %I64x: cache_size = %I64x, new_cache_size = %I64x\n", c->offset, c->cache ? c->cache->inode_item.st_size : 0, new_cache_size);
 
     if (c->cache) {
         if (new_cache_size > c->cache->inode_item.st_size)
-            realloc_extents = TRUE;
+            realloc_extents = true;
         else {
             le = c->cache->extents.Flink;
 
@@ -1082,7 +1109,7 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
                         chunk* c2 = get_chunk_from_address(Vcb, ed2->address);
 
                         if (c2 && (c2->readonly || c2->reloc)) {
-                            realloc_extents = TRUE;
+                            realloc_extents = true;
                             break;
                         }
                     }
@@ -1124,7 +1151,7 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
         c->cache->inode = InterlockedIncrement64(&Vcb->root_root->lastinode);
 
         c->cache->type = BTRFS_TYPE_FILE;
-        c->cache->created = TRUE;
+        c->cache->created = true;
 
         // create new free space entry
 
@@ -1140,7 +1167,7 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
         searchkey.obj_type = 0;
         searchkey.offset = c->offset;
 
-        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             ExFreePool(fsi);
@@ -1183,10 +1210,10 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
             return Status;
         }
 
-        c->cache->extents_changed = TRUE;
+        c->cache->extents_changed = true;
         InsertTailList(&Vcb->all_fcbs, &c->cache->list_entry_all);
 
-        Status = flush_fcb(c->cache, TRUE, batchlist, Irp);
+        Status = flush_fcb(c->cache, true, batchlist, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("flush_fcb returned %08x\n", Status);
             free_fcb(c->cache);
@@ -1194,7 +1221,7 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
             return Status;
         }
 
-        *changed = TRUE;
+        *changed = true;
     } else if (realloc_extents) {
         KEY searchkey;
         traverse_ptr tp;
@@ -1207,23 +1234,23 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
         searchkey.obj_type = 0;
         searchkey.offset = c->offset;
 
-        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
         }
 
         if (keycmp(searchkey, tp.item->key)) {
-            ERR("could not find (%llx,%x,%llx) in root_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+            ERR("could not find (%I64x,%x,%I64x) in root_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (tp.item->size < sizeof(FREE_SPACE_ITEM)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_ITEM));
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_ITEM));
             return STATUS_INTERNAL_ERROR;
         }
 
-        tp.tree->write = TRUE;
+        tp.tree->write = true;
 
         // remove existing extents
 
@@ -1240,8 +1267,8 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
                         chunk* c2 = get_chunk_from_address(Vcb, ed2->address);
 
                         if (c2) {
-                            c2->changed = TRUE;
-                            c2->space_changed = TRUE;
+                            c2->changed = true;
+                            c2->space_changed = true;
                         }
                     }
                 }
@@ -1269,13 +1296,13 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
         c->cache->inode_item.st_size = new_cache_size;
         c->cache->inode_item.st_blocks = new_cache_size;
 
-        Status = flush_fcb(c->cache, TRUE, batchlist, Irp);
+        Status = flush_fcb(c->cache, true, batchlist, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("flush_fcb returned %08x\n", Status);
             return Status;
         }
 
-        *changed = TRUE;
+        *changed = true;
     } else {
         KEY searchkey;
         traverse_ptr tp;
@@ -1286,7 +1313,7 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
         searchkey.obj_type = TYPE_INODE_ITEM;
         searchkey.offset = 0;
 
-        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
@@ -1310,37 +1337,37 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
                 return Status;
             }
 
-            *changed = TRUE;
+            *changed = true;
         } else {
             if (tp.item->size < sizeof(INODE_ITEM)) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(INODE_ITEM));
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(INODE_ITEM));
                 return STATUS_INTERNAL_ERROR;
             }
 
-            tp.tree->write = TRUE;
+            tp.tree->write = true;
         }
 
         searchkey.obj_id = FREE_SPACE_CACHE_ID;
         searchkey.obj_type = 0;
         searchkey.offset = c->offset;
 
-        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("error - find_item returned %08x\n", Status);
             return Status;
         }
 
         if (keycmp(searchkey, tp.item->key)) {
-            ERR("could not find (%llx,%x,%llx) in root_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+            ERR("could not find (%I64x,%x,%I64x) in root_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (tp.item->size < sizeof(FREE_SPACE_ITEM)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_ITEM));
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_ITEM));
             return STATUS_INTERNAL_ERROR;
         }
 
-        tp.tree->write = TRUE;
+        tp.tree->write = true;
     }
 
     // FIXME - reduce inode allocation if cache is shrinking. Make sure to avoid infinite write loops
@@ -1348,32 +1375,32 @@ static NTSTATUS allocate_cache_chunk(device_extension* Vcb, chunk* c, BOOL* chan
     return STATUS_SUCCESS;
 }
 
-NTSTATUS allocate_cache(device_extension* Vcb, BOOL* changed, PIRP Irp, LIST_ENTRY* rollback) {
+NTSTATUS allocate_cache(device_extension* Vcb, bool* changed, PIRP Irp, LIST_ENTRY* rollback) {
     LIST_ENTRY *le, batchlist;
     NTSTATUS Status;
 
-    *changed = FALSE;
+    *changed = false;
 
     InitializeListHead(&batchlist);
 
-    ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
     le = Vcb->chunks.Flink;
     while (le != &Vcb->chunks) {
         chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
 
         if (c->space_changed && c->chunk_item->size >= 0x6400000) { // 100MB
-            BOOL b;
+            bool b;
 
             acquire_chunk_lock(c, Vcb);
             Status = allocate_cache_chunk(Vcb, c, &b, &batchlist, Irp, rollback);
             release_chunk_lock(c, Vcb);
 
             if (b)
-                *changed = TRUE;
+                *changed = true;
 
             if (!NT_SUCCESS(Status)) {
-                ERR("allocate_cache_chunk(%llx) returned %08x\n", c->offset, Status);
+                ERR("allocate_cache_chunk(%I64x) returned %08x\n", c->offset, Status);
                 ExReleaseResourceLite(&Vcb->chunk_lock);
                 clear_batch_list(Vcb, &batchlist);
                 return Status;
@@ -1394,7 +1421,7 @@ NTSTATUS allocate_cache(device_extension* Vcb, BOOL* changed, PIRP Irp, LIST_ENT
     return STATUS_SUCCESS;
 }
 
-static void add_rollback_space(LIST_ENTRY* rollback, BOOL add, LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UINT64 length, chunk* c) {
+static void add_rollback_space(LIST_ENTRY* rollback, bool add, LIST_ENTRY* list, LIST_ENTRY* list_size, uint64_t address, uint64_t length, chunk* c) {
     rollback_space* rs;
 
     rs = ExAllocatePoolWithTag(PagedPool, sizeof(rollback_space), ALLOC_TAG);
@@ -1412,7 +1439,7 @@ static void add_rollback_space(LIST_ENTRY* rollback, BOOL add, LIST_ENTRY* list,
     add_rollback(rollback, add ? ROLLBACK_ADD_SPACE : ROLLBACK_SUBTRACT_SPACE, rs);
 }
 
-void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UINT64 length, chunk* c, LIST_ENTRY* rollback) {
+void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, uint64_t address, uint64_t length, chunk* c, LIST_ENTRY* rollback) {
     LIST_ENTRY* le;
     space *s, *s2;
 
@@ -1432,7 +1459,7 @@ void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UI
             InsertTailList(list_size, &s->list_entry_size);
 
         if (rollback)
-            add_rollback_space(rollback, TRUE, list, list_size, address, length, c);
+            add_rollback_space(rollback, true, list, list_size, address, length, c);
 
         return;
     }
@@ -1449,7 +1476,7 @@ void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UI
         if (address <= s2->address && address + length >= s2->address + s2->size) {
             if (address < s2->address) {
                 if (rollback)
-                    add_rollback_space(rollback, TRUE, list, list_size, address, s2->address - address, c);
+                    add_rollback_space(rollback, true, list, list_size, address, s2->address - address, c);
 
                 s2->size += s2->address - address;
                 s2->address = address;
@@ -1474,7 +1501,7 @@ void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UI
 
             if (length > s2->size) {
                 if (rollback)
-                    add_rollback_space(rollback, TRUE, list, list_size, s2->address + s2->size, address + length - s2->address - s2->size, c);
+                    add_rollback_space(rollback, true, list, list_size, s2->address + s2->size, address + length - s2->address - s2->size, c);
 
                 s2->size = length;
 
@@ -1506,7 +1533,7 @@ void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UI
         // new entry overlaps start of old one
         if (address < s2->address && address + length >= s2->address) {
             if (rollback)
-                add_rollback_space(rollback, TRUE, list, list_size, address, s2->address - address, c);
+                add_rollback_space(rollback, true, list, list_size, address, s2->address - address, c);
 
             s2->size += s2->address - address;
             s2->address = address;
@@ -1539,7 +1566,7 @@ void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UI
         // new entry overlaps end of old one
         if (address <= s2->address + s2->size && address + length > s2->address + s2->size) {
             if (rollback)
-                add_rollback_space(rollback, TRUE, list, list_size, address, s2->address + s2->size - address, c);
+                add_rollback_space(rollback, true, list, list_size, address, s2->address + s2->size - address, c);
 
             s2->size = address + length - s2->address;
 
@@ -1577,7 +1604,7 @@ void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UI
             }
 
             if (rollback)
-                add_rollback_space(rollback, TRUE, list, list_size, address, length, c);
+                add_rollback_space(rollback, true, list, list_size, address, length, c);
 
             s->address = address;
             s->size = length;
@@ -1620,7 +1647,7 @@ void space_list_add2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UI
         order_space_entry(s, list_size);
 
     if (rollback)
-        add_rollback_space(rollback, TRUE, list, list_size, address, length, c);
+        add_rollback_space(rollback, true, list, list_size, address, length, c);
 }
 
 static void space_list_merge(LIST_ENTRY* spacelist, LIST_ENTRY* spacelist_size, LIST_ENTRY* deleting) {
@@ -1644,8 +1671,8 @@ static NTSTATUS update_chunk_cache(device_extension* Vcb, chunk* c, BTRFS_TIME*
     traverse_ptr tp;
     FREE_SPACE_ITEM* fsi;
     void* data;
-    UINT64 num_entries, *cachegen, off;
-    UINT32 *checksums, num_sectors, i;
+    uint64_t num_entries, *cachegen, off;
+    uint32_t *checksums, num_sectors, i;
     LIST_ENTRY* le;
 
     space_list_merge(&c->space, &c->space_size, &c->deleting);
@@ -1659,8 +1686,8 @@ static NTSTATUS update_chunk_cache(device_extension* Vcb, chunk* c, BTRFS_TIME*
     RtlZeroMemory(data, (ULONG)c->cache->inode_item.st_size);
 
     num_entries = 0;
-    num_sectors = (UINT32)(c->cache->inode_item.st_size / Vcb->superblock.sector_size);
-    off = (sizeof(UINT32) * num_sectors) + sizeof(UINT64);
+    num_sectors = (uint32_t)(c->cache->inode_item.st_size / Vcb->superblock.sector_size);
+    off = (sizeof(uint32_t) * num_sectors) + sizeof(uint64_t);
 
     le = c->space.Flink;
     while (le != &c->space) {
@@ -1671,7 +1698,7 @@ static NTSTATUS update_chunk_cache(device_extension* Vcb, chunk* c, BTRFS_TIME*
         if ((off + sizeof(FREE_SPACE_ENTRY)) / Vcb->superblock.sector_size != off / Vcb->superblock.sector_size)
             off = sector_align(off, Vcb->superblock.sector_size);
 
-        fse = (FREE_SPACE_ENTRY*)((UINT8*)data + off);
+        fse = (FREE_SPACE_ENTRY*)((uint8_t*)data + off);
 
         fse->offset = s->address;
         fse->size = s->size;
@@ -1690,7 +1717,7 @@ static NTSTATUS update_chunk_cache(device_extension* Vcb, chunk* c, BTRFS_TIME*
     c->cache->inode_item.sequence++;
     c->cache->inode_item.st_ctime = *now;
 
-    Status = flush_fcb(c->cache, TRUE, batchlist, Irp);
+    Status = flush_fcb(c->cache, true, batchlist, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("flush_fcb returned %08x\n", Status);
         goto end;
@@ -1702,20 +1729,20 @@ static NTSTATUS update_chunk_cache(device_extension* Vcb, chunk* c, BTRFS_TIME*
     searchkey.obj_type = 0;
     searchkey.offset = c->offset;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         goto end;
     }
 
     if (keycmp(searchkey, tp.item->key)) {
-        ERR("could not find (%llx,%x,%llx) in root_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+        ERR("could not find (%I64x,%x,%I64x) in root_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
         Status = STATUS_INTERNAL_ERROR;
         goto end;
     }
 
     if (tp.item->size < sizeof(FREE_SPACE_ITEM)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_ITEM));
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(FREE_SPACE_ITEM));
         Status = STATUS_INTERNAL_ERROR;
         goto end;
     }
@@ -1728,27 +1755,27 @@ static NTSTATUS update_chunk_cache(device_extension* Vcb, chunk* c, BTRFS_TIME*
 
     // set cache generation
 
-    cachegen = (UINT64*)((UINT8*)data + (sizeof(UINT32) * num_sectors));
+    cachegen = (uint64_t*)((uint8_t*)data + (sizeof(uint32_t) * num_sectors));
     *cachegen = Vcb->superblock.generation;
 
     // calculate cache checksums
 
-    checksums = (UINT32*)data;
+    checksums = (uint32_t*)data;
 
     // FIXME - if we know sector is fully zeroed, use cached checksum
 
     for (i = 0; i < num_sectors; i++) {
-        if (i * Vcb->superblock.sector_size > sizeof(UINT32) * num_sectors)
-            checksums[i] = ~calc_crc32c(0xffffffff, (UINT8*)data + (i * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
-        else if ((i + 1) * Vcb->superblock.sector_size < sizeof(UINT32) * num_sectors)
+        if (i * Vcb->superblock.sector_size > sizeof(uint32_t) * num_sectors)
+            checksums[i] = ~calc_crc32c(0xffffffff, (uint8_t*)data + (i * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
+        else if ((i + 1) * Vcb->superblock.sector_size < sizeof(uint32_t) * num_sectors)
             checksums[i] = 0; // FIXME - test this
         else
-            checksums[i] = ~calc_crc32c(0xffffffff, (UINT8*)data + (sizeof(UINT32) * num_sectors), ((i + 1) * Vcb->superblock.sector_size) - (sizeof(UINT32) * num_sectors));
+            checksums[i] = ~calc_crc32c(0xffffffff, (uint8_t*)data + (sizeof(uint32_t) * num_sectors), ((i + 1) * Vcb->superblock.sector_size) - (sizeof(uint32_t) * num_sectors));
     }
 
     // write cache
 
-    Status = do_write_file(c->cache, 0, c->cache->inode_item.st_size, data, NULL, FALSE, 0, rollback);
+    Status = do_write_file(c->cache, 0, c->cache->inode_item.st_size, data, NULL, false, 0, rollback);
     if (!NT_SUCCESS(Status)) {
         ERR("do_write_file returned %08x\n", Status);
 
@@ -1838,7 +1865,7 @@ NTSTATUS update_chunk_caches(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollba
             release_chunk_lock(c, Vcb);
 
             if (!NT_SUCCESS(Status)) {
-                ERR("update_chunk_cache(%llx) returned %08x\n", c->offset, Status);
+                ERR("update_chunk_cache(%I64x) returned %08x\n", c->offset, Status);
                 clear_batch_list(Vcb, &batchlist);
                 return Status;
             }
@@ -1858,7 +1885,7 @@ NTSTATUS update_chunk_caches(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollba
         c = CONTAINING_RECORD(le, chunk, list_entry);
 
         if (c->changed && (c->chunk_item->type & BLOCK_FLAG_RAID5 || c->chunk_item->type & BLOCK_FLAG_RAID6)) {
-            ExAcquireResourceExclusiveLite(&c->partial_stripes_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&c->partial_stripes_lock, true);
 
             while (!IsListEmpty(&c->partial_stripes)) {
                 partial_stripe* ps = CONTAINING_RECORD(RemoveHeadList(&c->partial_stripes), partial_stripe, list_entry);
@@ -1895,7 +1922,7 @@ NTSTATUS update_chunk_caches_tree(device_extension* Vcb, PIRP Irp) {
 
     InitializeListHead(&batchlist);
 
-    ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
     le = Vcb->chunks.Flink;
     while (le != &Vcb->chunks) {
@@ -1907,7 +1934,7 @@ NTSTATUS update_chunk_caches_tree(device_extension* Vcb, PIRP Irp) {
             release_chunk_lock(c, Vcb);
 
             if (!NT_SUCCESS(Status)) {
-                ERR("update_chunk_cache_tree(%llx) returned %08x\n", c->offset, Status);
+                ERR("update_chunk_cache_tree(%I64x) returned %08x\n", c->offset, Status);
                 ExReleaseResourceLite(&Vcb->chunk_lock);
                 clear_batch_list(Vcb, &batchlist);
                 return Status;
@@ -1928,16 +1955,16 @@ NTSTATUS update_chunk_caches_tree(device_extension* Vcb, PIRP Irp) {
     return STATUS_SUCCESS;
 }
 
-void space_list_add(chunk* c, UINT64 address, UINT64 length, LIST_ENTRY* rollback) {
-    TRACE("(%p, %llx, %llx, %p)\n", c, address, length, rollback);
+void space_list_add(chunk* c, uint64_t address, uint64_t length, LIST_ENTRY* rollback) {
+    TRACE("(%p, %I64x, %I64x, %p)\n", c, address, length, rollback);
 
-    c->changed = TRUE;
-    c->space_changed = TRUE;
+    c->changed = true;
+    c->space_changed = true;
 
     space_list_add2(&c->deleting, NULL, address, length, c, rollback);
 }
 
-void space_list_subtract2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 address, UINT64 length, chunk* c, LIST_ENTRY* rollback) {
+void space_list_subtract2(LIST_ENTRY* list, LIST_ENTRY* list_size, uint64_t address, uint64_t length, chunk* c, LIST_ENTRY* rollback) {
     LIST_ENTRY *le, *le2;
     space *s, *s2;
 
@@ -1954,7 +1981,7 @@ void space_list_subtract2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 addres
 
         if (s2->address >= address && s2->address + s2->size <= address + length) { // remove entry entirely
             if (rollback)
-                add_rollback_space(rollback, FALSE, list, list_size, s2->address, s2->size, c);
+                add_rollback_space(rollback, false, list, list_size, s2->address, s2->size, c);
 
             RemoveEntryList(&s2->list_entry);
 
@@ -1965,7 +1992,7 @@ void space_list_subtract2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 addres
         } else if (address + length > s2->address && address + length < s2->address + s2->size) {
             if (address > s2->address) { // cut out hole
                 if (rollback)
-                    add_rollback_space(rollback, FALSE, list, list_size, address, length, c);
+                    add_rollback_space(rollback, false, list, list_size, address, length, c);
 
                 s = ExAllocatePoolWithTag(PagedPool, sizeof(space), ALLOC_TAG);
 
@@ -1990,7 +2017,7 @@ void space_list_subtract2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 addres
                 return;
             } else { // remove start of entry
                 if (rollback)
-                    add_rollback_space(rollback, FALSE, list, list_size, s2->address, address + length - s2->address, c);
+                    add_rollback_space(rollback, false, list, list_size, s2->address, address + length - s2->address, c);
 
                 s2->size -= address + length - s2->address;
                 s2->address = address + length;
@@ -2002,7 +2029,7 @@ void space_list_subtract2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 addres
             }
         } else if (address > s2->address && address < s2->address + s2->size) { // remove end of entry
             if (rollback)
-                add_rollback_space(rollback, FALSE, list, list_size, address, s2->address + s2->size - address, c);
+                add_rollback_space(rollback, false, list, list_size, address, s2->address + s2->size - address, c);
 
             s2->size = address - s2->address;
 
@@ -2016,13 +2043,13 @@ void space_list_subtract2(LIST_ENTRY* list, LIST_ENTRY* list_size, UINT64 addres
     }
 }
 
-void space_list_subtract(chunk* c, BOOL deleting, UINT64 address, UINT64 length, LIST_ENTRY* rollback) {
+void space_list_subtract(chunk* c, bool deleting, uint64_t address, uint64_t length, LIST_ENTRY* rollback) {
     LIST_ENTRY* list;
 
     list = deleting ? &c->deleting : &c->space;
 
-    c->changed = TRUE;
-    c->space_changed = TRUE;
+    c->changed = true;
+    c->space_changed = true;
 
     space_list_subtract2(list, deleting ? NULL : &c->space_size, address, length, c, rollback);
 }
diff --git a/drivers/filesystems/btrfs/fsctl.c b/drivers/filesystems/btrfs/fsctl.c
index 90622508cb2..039e828e962 100644
--- a/drivers/filesystems/btrfs/fsctl.c
+++ b/drivers/filesystems/btrfs/fsctl.c
@@ -66,14 +66,14 @@ static NTSTATUS get_file_ids(PFILE_OBJECT FileObject, void* data, ULONG length)
 
     bgfi->subvol = fcb->subvol->id;
     bgfi->inode = fcb->inode;
-    bgfi->top = fcb->Vcb->root_fileref->fcb == fcb ? TRUE : FALSE;
+    bgfi->top = fcb->Vcb->root_fileref->fcb == fcb ? true : false;
 
     return STATUS_SUCCESS;
 }
 
 static void get_uuid(BTRFS_UUID* uuid) {
     LARGE_INTEGER seed;
-    UINT8 i;
+    uint8_t i;
 
     seed = KeQueryPerformanceCounter(NULL);
 
@@ -85,8 +85,8 @@ static void get_uuid(BTRFS_UUID* uuid) {
     }
 }
 
-static NTSTATUS snapshot_tree_copy(device_extension* Vcb, UINT64 addr, root* subvol, UINT64* newaddr, PIRP Irp, LIST_ENTRY* rollback) {
-    UINT8* buf;
+static NTSTATUS snapshot_tree_copy(device_extension* Vcb, uint64_t addr, root* subvol, uint64_t* newaddr, PIRP Irp, LIST_ENTRY* rollback) {
+    uint8_t* buf;
     NTSTATUS Status;
     write_data_context wtc;
     LIST_ENTRY* le;
@@ -103,7 +103,7 @@ static NTSTATUS snapshot_tree_copy(device_extension* Vcb, UINT64 addr, root* sub
     wtc.parity1 = wtc.parity2 = wtc.scratch = NULL;
     wtc.mdl = wtc.parity1_mdl = wtc.parity2_mdl = NULL;
 
-    Status = read_data(Vcb, addr, Vcb->superblock.node_size, NULL, TRUE, buf, NULL, NULL, Irp, 0, FALSE, NormalPagePriority);
+    Status = read_data(Vcb, addr, Vcb->superblock.node_size, NULL, true, buf, NULL, NULL, Irp, 0, false, NormalPagePriority);
     if (!NT_SUCCESS(Status)) {
         ERR("read_data returned %08x\n", Status);
         goto end;
@@ -133,7 +133,7 @@ static NTSTATUS snapshot_tree_copy(device_extension* Vcb, UINT64 addr, root* sub
     if (c)
         c->used += Vcb->superblock.node_size;
     else {
-        ERR("could not find chunk for address %llx\n", t.new_address);
+        ERR("could not find chunk for address %I64x\n", t.new_address);
         Status = STATUS_INTERNAL_ERROR;
         goto end;
     }
@@ -144,12 +144,12 @@ static NTSTATUS snapshot_tree_copy(device_extension* Vcb, UINT64 addr, root* sub
     th->fs_uuid = Vcb->superblock.uuid;
 
     if (th->level == 0) {
-        UINT32 i;
+        uint32_t i;
         leaf_node* ln = (leaf_node*)&th[1];
 
         for (i = 0; i < th->num_items; i++) {
             if (ln[i].key.obj_type == TYPE_EXTENT_DATA && ln[i].size >= sizeof(EXTENT_DATA) && ln[i].offset + ln[i].size <= Vcb->superblock.node_size - sizeof(tree_header)) {
-                EXTENT_DATA* ed = (EXTENT_DATA*)(((UINT8*)&th[1]) + ln[i].offset);
+                EXTENT_DATA* ed = (EXTENT_DATA*)(((uint8_t*)&th[1]) + ln[i].offset);
 
                 if ((ed->type == EXTENT_TYPE_REGULAR || ed->type == EXTENT_TYPE_PREALLOC) && ln[i].size >= sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2)) {
                     EXTENT_DATA2* ed2 = (EXTENT_DATA2*)&ed->data[0];
@@ -166,7 +166,7 @@ static NTSTATUS snapshot_tree_copy(device_extension* Vcb, UINT64 addr, root* sub
             }
         }
     } else {
-        UINT32 i;
+        uint32_t i;
         internal_node* in = (internal_node*)&th[1];
 
         for (i = 0; i < th->num_items; i++) {
@@ -182,20 +182,20 @@ static NTSTATUS snapshot_tree_copy(device_extension* Vcb, UINT64 addr, root* sub
         }
     }
 
-    *((UINT32*)buf) = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+    *((uint32_t*)buf) = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-    KeInitializeEvent(&wtc.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&wtc.Event, NotificationEvent, false);
     InitializeListHead(&wtc.stripes);
     wtc.stripes_left = 0;
 
-    Status = write_data(Vcb, t.new_address, buf, Vcb->superblock.node_size, &wtc, NULL, NULL, FALSE, 0, NormalPagePriority);
+    Status = write_data(Vcb, t.new_address, buf, Vcb->superblock.node_size, &wtc, NULL, NULL, false, 0, NormalPagePriority);
     if (!NT_SUCCESS(Status)) {
         ERR("write_data returned %08x\n", Status);
         goto end;
     }
 
     if (wtc.stripes.Flink != &wtc.stripes) {
-        BOOL need_wait = FALSE;
+        bool need_wait = false;
 
         // launch writes and wait
         le = wtc.stripes.Flink;
@@ -203,7 +203,7 @@ static NTSTATUS snapshot_tree_copy(device_extension* Vcb, UINT64 addr, root* sub
             write_data_stripe* stripe = CONTAINING_RECORD(le, write_data_stripe, list_entry);
 
             if (stripe->status != WriteDataStatus_Ignore) {
-                need_wait = TRUE;
+                need_wait = true;
                 IoCallDriver(stripe->device->devobj, stripe->Irp);
             }
 
@@ -211,7 +211,7 @@ static NTSTATUS snapshot_tree_copy(device_extension* Vcb, UINT64 addr, root* sub
         }
 
         if (need_wait)
-            KeWaitForSingleObject(&wtc.Event, Executive, KernelMode, FALSE, NULL);
+            KeWaitForSingleObject(&wtc.Event, Executive, KernelMode, false, NULL);
 
         le = wtc.stripes.Flink;
         while (le != &wtc.stripes) {
@@ -258,14 +258,14 @@ void flush_subvol_fcbs(root* subvol) {
     }
 }
 
-static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, fcb* subvol_fcb, PANSI_STRING utf8, PUNICODE_STRING name, BOOL readonly, PIRP Irp) {
+static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, fcb* subvol_fcb, PANSI_STRING utf8, PUNICODE_STRING name, bool readonly, PIRP Irp) {
     LIST_ENTRY rollback;
-    UINT64 id;
+    uint64_t id;
     NTSTATUS Status;
     root *r, *subvol = subvol_fcb->subvol;
     KEY searchkey;
     traverse_ptr tp;
-    UINT64 address, *root_num;
+    uint64_t address, *root_num;
     LARGE_INTEGER time;
     BTRFS_TIME now;
     fcb* fcb = parent->FsContext;
@@ -312,7 +312,7 @@ static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, f
     // create new root
 
     id = InterlockedIncrement64(&Vcb->root_root->lastinode);
-    Status = create_root(Vcb, id, &r, TRUE, Vcb->superblock.generation, Irp);
+    Status = create_root(Vcb, id, &r, true, Vcb->superblock.generation, Irp);
 
     if (!NT_SUCCESS(Status)) {
         ERR("create_root returned %08x\n", Status);
@@ -326,7 +326,7 @@ static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, f
 
         TRACE("uuid root doesn't exist, creating it\n");
 
-        Status = create_root(Vcb, BTRFS_ROOT_UUID, &uuid_root, FALSE, 0, Irp);
+        Status = create_root(Vcb, BTRFS_ROOT_UUID, &uuid_root, false, 0, Irp);
 
         if (!NT_SUCCESS(Status)) {
             ERR("create_root returned %08x\n", Status);
@@ -336,7 +336,7 @@ static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, f
         Vcb->uuid_root = uuid_root;
     }
 
-    root_num = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64), ALLOC_TAG);
+    root_num = ExAllocatePoolWithTag(PagedPool, sizeof(uint64_t), ALLOC_TAG);
     if (!root_num) {
         ERR("out of memory\n");
         Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -348,16 +348,16 @@ static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, f
     do {
         get_uuid(&r->root_item.uuid);
 
-        RtlCopyMemory(&searchkey.obj_id, &r->root_item.uuid, sizeof(UINT64));
+        RtlCopyMemory(&searchkey.obj_id, &r->root_item.uuid, sizeof(uint64_t));
         searchkey.obj_type = TYPE_SUBVOL_UUID;
-        RtlCopyMemory(&searchkey.offset, &r->root_item.uuid.uuid[sizeof(UINT64)], sizeof(UINT64));
+        RtlCopyMemory(&searchkey.offset, &r->root_item.uuid.uuid[sizeof(uint64_t)], sizeof(uint64_t));
 
-        Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, false, Irp);
     } while (NT_SUCCESS(Status) && !keycmp(searchkey, tp.item->key));
 
     *root_num = r->id;
 
-    Status = insert_tree_item(Vcb, Vcb->uuid_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, root_num, sizeof(UINT64), NULL, Irp);
+    Status = insert_tree_item(Vcb, Vcb->uuid_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, root_num, sizeof(uint64_t), NULL, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("insert_tree_item returned %08x\n", Status);
         ExFreePool(root_num);
@@ -368,7 +368,7 @@ static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, f
     searchkey.obj_type = TYPE_ROOT_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         goto end;
@@ -410,7 +410,7 @@ static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, f
     // FIXME - do we need to copy over the send and receive fields too?
 
     if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
-        ERR("error - could not find ROOT_ITEM for subvol %llx\n", r->id);
+        ERR("error - could not find ROOT_ITEM for subvol %I64x\n", r->id);
         Status = STATUS_INTERNAL_ERROR;
         goto end;
     }
@@ -432,7 +432,7 @@ static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, f
         goto end;
     }
 
-    Status = open_fcb(Vcb, r, r->root_item.objid, BTRFS_TYPE_DIRECTORY, utf8, FALSE, fcb, &fr->fcb, PagedPool, Irp);
+    Status = open_fcb(Vcb, r, r->root_item.objid, BTRFS_TYPE_DIRECTORY, utf8, false, fcb, &fr->fcb, PagedPool, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("open_fcb returned %08x\n", Status);
         free_fileref(fr);
@@ -441,20 +441,20 @@ static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, f
 
     fr->parent = fileref;
 
-    Status = add_dir_child(fileref->fcb, r->id, TRUE, utf8, name, BTRFS_TYPE_DIRECTORY, &dc);
+    Status = add_dir_child(fileref->fcb, r->id, true, utf8, name, BTRFS_TYPE_DIRECTORY, &dc);
     if (!NT_SUCCESS(Status))
         WARN("add_dir_child returned %08x\n", Status);
 
     fr->dc = dc;
     dc->fileref = fr;
 
-    ExAcquireResourceExclusiveLite(&fileref->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&fileref->fcb->nonpaged->dir_children_lock, true);
     InsertTailList(&fileref->children, &fr->list_entry);
     ExReleaseResourceLite(&fileref->fcb->nonpaged->dir_children_lock);
 
     increase_fileref_refcount(fileref);
 
-    fr->created = TRUE;
+    fr->created = true;
     mark_fileref_dirty(fr);
 
     if (fr->fcb->type == BTRFS_TYPE_DIRECTORY)
@@ -476,7 +476,7 @@ static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, f
     if (!ccb->user_set_write_time)
         fcb->inode_item.st_mtime = now;
 
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
     mark_fcb_dirty(fcb);
 
     fcb->subvol->root_item.ctime = now;
@@ -494,7 +494,7 @@ static NTSTATUS do_create_snapshot(device_extension* Vcb, PFILE_OBJECT parent, f
             extent* ext = CONTAINING_RECORD(le2, extent, list_entry);
 
             if (!ext->ignore)
-                ext->unique = FALSE;
+                ext->unique = false;
 
             le2 = le2->Flink;
         }
@@ -524,7 +524,7 @@ static NTSTATUS create_snapshot(device_extension* Vcb, PFILE_OBJECT FileObject,
     btrfs_create_snapshot* bcs = data;
     fcb* subvol_fcb;
     HANDLE subvolh;
-    BOOL readonly, posix;
+    bool readonly, posix;
     ANSI_STRING utf8;
     UNICODE_STRING nameus;
     ULONG len;
@@ -603,14 +603,14 @@ static NTSTATUS create_snapshot(device_extension* Vcb, PFILE_OBJECT FileObject,
 
     utf8.Buffer = NULL;
 
-    Status = RtlUnicodeToUTF8N(NULL, 0, &len, nameus.Buffer, nameus.Length);
+    Status = utf16_to_utf8(NULL, 0, &len, nameus.Buffer, nameus.Length);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUnicodeToUTF8N failed with error %08x\n", Status);
+        ERR("utf16_to_utf8 failed with error %08x\n", Status);
         return Status;
     }
 
     if (len == 0) {
-        ERR("RtlUnicodeToUTF8N returned a length of 0\n");
+        ERR("utf16_to_utf8 returned a length of 0\n");
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -627,16 +627,16 @@ static NTSTATUS create_snapshot(device_extension* Vcb, PFILE_OBJECT FileObject,
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    Status = RtlUnicodeToUTF8N(utf8.Buffer, len, &len, nameus.Buffer, nameus.Length);
+    Status = utf16_to_utf8(utf8.Buffer, len, &len, nameus.Buffer, nameus.Length);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUnicodeToUTF8N failed with error %08x\n", Status);
+        ERR("utf16_to_utf8 failed with error %08x\n", Status);
         goto end2;
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     // no need for fcb_lock as we have tree_lock exclusively
-    Status = open_fileref(fcb->Vcb, &fr2, &nameus, fileref, FALSE, NULL, NULL, PagedPool, ccb->case_sensitive || posix, Irp);
+    Status = open_fileref(fcb->Vcb, &fr2, &nameus, fileref, false, NULL, NULL, PagedPool, ccb->case_sensitive || posix, Irp);
 
     if (NT_SUCCESS(Status)) {
         if (!fr2->deleted) {
@@ -669,7 +669,7 @@ static NTSTATUS create_snapshot(device_extension* Vcb, PFILE_OBJECT FileObject,
     }
 
     if (subvol_fcb->inode != subvol_fcb->subvol->root_item.objid) {
-        WARN("handle inode was %llx, expected %llx\n", subvol_fcb->inode, subvol_fcb->subvol->root_item.objid);
+        WARN("handle inode was %I64x, expected %I64x\n", subvol_fcb->inode, subvol_fcb->subvol->root_item.objid);
         Status = STATUS_INVALID_PARAMETER;
         goto end;
     }
@@ -705,7 +705,7 @@ static NTSTATUS create_snapshot(device_extension* Vcb, PFILE_OBJECT FileObject,
             while (le2 != &openfcb->extents) {
                 extent* ext = CONTAINING_RECORD(le2, extent, list_entry);
 
-                ext->unique = FALSE;
+                ext->unique = false;
 
                 le2 = le2->Flink;
             }
@@ -719,7 +719,7 @@ static NTSTATUS create_snapshot(device_extension* Vcb, PFILE_OBJECT FileObject,
     if (NT_SUCCESS(Status)) {
         file_ref* fr;
 
-        Status = open_fileref(Vcb, &fr, &nameus, fileref, FALSE, NULL, NULL, PagedPool, FALSE, Irp);
+        Status = open_fileref(Vcb, &fr, &nameus, fileref, false, NULL, NULL, PagedPool, false, Irp);
 
         if (!NT_SUCCESS(Status)) {
             ERR("open_fileref returned %08x\n", Status);
@@ -748,12 +748,12 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     ccb* ccb;
     file_ref* fileref;
     NTSTATUS Status;
-    UINT64 id;
+    uint64_t id;
     root* r = NULL;
     LARGE_INTEGER time;
     BTRFS_TIME now;
     ULONG len;
-    UINT16 irsize;
+    uint16_t irsize;
     UNICODE_STRING nameus;
     ANSI_STRING utf8;
     INODE_REF* ir;
@@ -762,7 +762,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     SECURITY_SUBJECT_CONTEXT subjcont;
     PSID owner;
     BOOLEAN defaulted;
-    UINT64* root_num;
+    uint64_t* root_num;
     file_ref *fr = NULL, *fr2;
     dir_child* dc = NULL;
 
@@ -825,14 +825,14 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
 
     utf8.Buffer = NULL;
 
-    Status = RtlUnicodeToUTF8N(NULL, 0, &len, nameus.Buffer, nameus.Length);
+    Status = utf16_to_utf8(NULL, 0, &len, nameus.Buffer, nameus.Length);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUnicodeToUTF8N failed with error %08x\n", Status);
+        ERR("utf16_to_utf8 failed with error %08x\n", Status);
         return Status;
     }
 
     if (len == 0) {
-        ERR("RtlUnicodeToUTF8N returned a length of 0\n");
+        ERR("utf16_to_utf8 returned a length of 0\n");
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -849,19 +849,19 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    Status = RtlUnicodeToUTF8N(utf8.Buffer, len, &len, nameus.Buffer, nameus.Length);
+    Status = utf16_to_utf8(utf8.Buffer, len, &len, nameus.Buffer, nameus.Length);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUnicodeToUTF8N failed with error %08x\n", Status);
+        ERR("utf16_to_utf8 failed with error %08x\n", Status);
         goto end2;
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     KeQuerySystemTime(&time);
     win_time_to_unix(time, &now);
 
     // no need for fcb_lock as we have tree_lock exclusively
-    Status = open_fileref(fcb->Vcb, &fr2, &nameus, fileref, FALSE, NULL, NULL, PagedPool, ccb->case_sensitive || bcs->posix, Irp);
+    Status = open_fileref(fcb->Vcb, &fr2, &nameus, fileref, false, NULL, NULL, PagedPool, ccb->case_sensitive || bcs->posix, Irp);
 
     if (NT_SUCCESS(Status)) {
         if (!fr2->deleted) {
@@ -877,21 +877,21 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     }
 
     id = InterlockedIncrement64(&Vcb->root_root->lastinode);
-    Status = create_root(Vcb, id, &r, FALSE, 0, Irp);
+    Status = create_root(Vcb, id, &r, false, 0, Irp);
 
     if (!NT_SUCCESS(Status)) {
         ERR("create_root returned %08x\n", Status);
         goto end;
     }
 
-    TRACE("created root %llx\n", id);
+    TRACE("created root %I64x\n", id);
 
     if (!Vcb->uuid_root) {
         root* uuid_root;
 
         TRACE("uuid root doesn't exist, creating it\n");
 
-        Status = create_root(Vcb, BTRFS_ROOT_UUID, &uuid_root, FALSE, 0, Irp);
+        Status = create_root(Vcb, BTRFS_ROOT_UUID, &uuid_root, false, 0, Irp);
 
         if (!NT_SUCCESS(Status)) {
             ERR("create_root returned %08x\n", Status);
@@ -901,7 +901,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
         Vcb->uuid_root = uuid_root;
     }
 
-    root_num = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64), ALLOC_TAG);
+    root_num = ExAllocatePoolWithTag(PagedPool, sizeof(uint64_t), ALLOC_TAG);
     if (!root_num) {
         ERR("out of memory\n");
         Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -913,16 +913,16 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     do {
         get_uuid(&r->root_item.uuid);
 
-        RtlCopyMemory(&searchkey.obj_id, &r->root_item.uuid, sizeof(UINT64));
+        RtlCopyMemory(&searchkey.obj_id, &r->root_item.uuid, sizeof(uint64_t));
         searchkey.obj_type = TYPE_SUBVOL_UUID;
-        RtlCopyMemory(&searchkey.offset, &r->root_item.uuid.uuid[sizeof(UINT64)], sizeof(UINT64));
+        RtlCopyMemory(&searchkey.offset, &r->root_item.uuid.uuid[sizeof(uint64_t)], sizeof(uint64_t));
 
-        Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
+        Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, false, Irp);
     } while (NT_SUCCESS(Status) && !keycmp(searchkey, tp.item->key));
 
     *root_num = r->id;
 
-    Status = insert_tree_item(Vcb, Vcb->uuid_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, root_num, sizeof(UINT64), NULL, Irp);
+    Status = insert_tree_item(Vcb, Vcb->uuid_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, root_num, sizeof(uint64_t), NULL, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("insert_tree_item returned %08x\n", Status);
         ExFreePool(root_num);
@@ -964,18 +964,18 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     rootfcb->inode_item.generation = Vcb->superblock.generation;
     rootfcb->inode_item.transid = Vcb->superblock.generation;
     rootfcb->inode_item.st_nlink = 1;
-    rootfcb->inode_item.st_mode = __S_IFDIR | inherit_mode(fileref->fcb, TRUE);
+    rootfcb->inode_item.st_mode = __S_IFDIR | inherit_mode(fileref->fcb, true);
     rootfcb->inode_item.st_atime = rootfcb->inode_item.st_ctime = rootfcb->inode_item.st_mtime = rootfcb->inode_item.otime = now;
     rootfcb->inode_item.st_gid = GID_NOBODY;
 
-    rootfcb->atts = get_file_attributes(Vcb, rootfcb->subvol, rootfcb->inode, rootfcb->type, FALSE, TRUE, Irp);
+    rootfcb->atts = get_file_attributes(Vcb, rootfcb->subvol, rootfcb->inode, rootfcb->type, false, true, Irp);
 
     if (r->root_item.flags & BTRFS_SUBVOL_READONLY)
         rootfcb->atts |= FILE_ATTRIBUTE_READONLY;
 
     SeCaptureSubjectContext(&subjcont);
 
-    Status = SeAssignSecurity(fcb->sd, NULL, (void**)&rootfcb->sd, TRUE, &subjcont, IoGetFileObjectGenericMapping(), PagedPool);
+    Status = SeAssignSecurity(fcb->sd, NULL, (void**)&rootfcb->sd, true, &subjcont, IoGetFileObjectGenericMapping(), PagedPool);
 
     if (!NT_SUCCESS(Status)) {
         ERR("SeAssignSecurity returned %08x\n", Status);
@@ -992,7 +992,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     if (!NT_SUCCESS(Status)) {
         ERR("RtlGetOwnerSecurityDescriptor returned %08x\n", Status);
         rootfcb->inode_item.st_uid = UID_NOBODY;
-        rootfcb->sd_dirty = TRUE;
+        rootfcb->sd_dirty = true;
     } else {
         rootfcb->inode_item.st_uid = sid_to_uid(owner);
         rootfcb->sd_dirty = rootfcb->inode_item.st_uid == UID_NOBODY;
@@ -1000,7 +1000,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
 
     find_gid(rootfcb, fileref->fcb, &subjcont);
 
-    rootfcb->inode_item_changed = TRUE;
+    rootfcb->inode_item_changed = true;
 
     acquire_fcb_lock_exclusive(Vcb);
     InsertTailList(&r->fcbs, &rootfcb->list_entry);
@@ -1013,7 +1013,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     rootfcb->Header.FileSize.QuadPart = 0;
     rootfcb->Header.ValidDataLength.QuadPart = 0;
 
-    rootfcb->created = TRUE;
+    rootfcb->created = true;
 
     if (fileref->fcb->inode_item.flags & BTRFS_INODE_COMPRESS)
         rootfcb->inode_item.flags |= BTRFS_INODE_COMPRESS;
@@ -1025,7 +1025,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
 
     // add INODE_REF
 
-    irsize = (UINT16)(offsetof(INODE_REF, name[0]) + sizeof(DOTDOT) - 1);
+    irsize = (uint16_t)(offsetof(INODE_REF, name[0]) + sizeof(DOTDOT) - 1);
     ir = ExAllocatePoolWithTag(PagedPool, irsize, ALLOC_TAG);
     if (!ir) {
         ERR("out of memory\n");
@@ -1062,7 +1062,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
 
     fr->parent = fileref;
 
-    Status = add_dir_child(fileref->fcb, r->id, TRUE, &utf8, &nameus, BTRFS_TYPE_DIRECTORY, &dc);
+    Status = add_dir_child(fileref->fcb, r->id, true, &utf8, &nameus, BTRFS_TYPE_DIRECTORY, &dc);
     if (!NT_SUCCESS(Status))
         WARN("add_dir_child returned %08x\n", Status);
 
@@ -1089,7 +1089,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
 
     RtlZeroMemory(fr->fcb->hash_ptrs_uc, sizeof(LIST_ENTRY*) * 256);
 
-    ExAcquireResourceExclusiveLite(&fileref->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&fileref->fcb->nonpaged->dir_children_lock, true);
     InsertTailList(&fileref->children, &fr->list_entry);
     ExReleaseResourceLite(&fileref->fcb->nonpaged->dir_children_lock);
 
@@ -1098,7 +1098,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     if (fr->fcb->type == BTRFS_TYPE_DIRECTORY)
         fr->fcb->fileref = fr;
 
-    fr->created = TRUE;
+    fr->created = true;
     mark_fileref_dirty(fr);
 
     // change fcb->subvol's ROOT_ITEM
@@ -1118,7 +1118,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     if (!ccb->user_set_write_time)
         fcb->inode_item.st_mtime = now;
 
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
     mark_fcb_dirty(fcb);
 
     fr->fcb->subvol->parent = fcb->subvol->id;
@@ -1128,10 +1128,10 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
 end:
     if (!NT_SUCCESS(Status)) {
         if (fr) {
-            fr->deleted = TRUE;
+            fr->deleted = true;
             mark_fileref_dirty(fr);
         } else if (rootfcb) {
-            rootfcb->deleted = TRUE;
+            rootfcb->deleted = true;
             mark_fcb_dirty(rootfcb);
         }
 
@@ -1156,12 +1156,12 @@ end2:
 }
 
 static NTSTATUS get_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length) {
-    btrfs_inode_info2* bii = data;
+    btrfs_inode_info* bii = data;
     fcb* fcb;
     ccb* ccb;
-    BOOL old_style;
+    bool old_style;
 
-    if (length < sizeof(btrfs_inode_info))
+    if (length < offsetof(btrfs_inode_info, disk_size_zstd))
         return STATUS_BUFFER_OVERFLOW;
 
     if (!FileObject)
@@ -1185,13 +1185,13 @@ static NTSTATUS get_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length
     if (fcb->ads)
         fcb = ccb->fileref->parent->fcb;
 
-    old_style = length < sizeof(btrfs_inode_info2);
+    old_style = length < offsetof(btrfs_inode_info, sparse_size) + sizeof(((btrfs_inode_info*)NULL)->sparse_size);
 
-    ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
     bii->subvol = fcb->subvol->id;
     bii->inode = fcb->inode;
-    bii->top = fcb->Vcb->root_fileref->fcb == fcb ? TRUE : FALSE;
+    bii->top = fcb->Vcb->root_fileref->fcb == fcb ? true : false;
     bii->type = fcb->type;
     bii->st_uid = fcb->inode_item.st_uid;
     bii->st_gid = fcb->inode_item.st_gid;
@@ -1215,9 +1215,9 @@ static NTSTATUS get_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length
     }
 
     if (fcb->type != BTRFS_TYPE_DIRECTORY) {
-        UINT64 last_end = 0;
+        uint64_t last_end = 0;
         LIST_ENTRY* le;
-        BOOL extents_inline = FALSE;
+        bool extents_inline = false;
 
         le = fcb->extents.Flink;
         while (le != &fcb->extents) {
@@ -1228,9 +1228,9 @@ static NTSTATUS get_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length
                     bii->sparse_size += ext->offset - last_end;
 
                 if (ext->extent_data.type == EXTENT_TYPE_INLINE) {
-                    bii->inline_length += ext->datalen - (UINT16)offsetof(EXTENT_DATA, data[0]);
+                    bii->inline_length += ext->datalen - (uint16_t)offsetof(EXTENT_DATA, data[0]);
                     last_end = ext->offset + ext->extent_data.decoded_size;
-                    extents_inline = TRUE;
+                    extents_inline = true;
                 } else {
                     EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ext->extent_data.data;
 
@@ -1265,6 +1265,32 @@ static NTSTATUS get_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length
 
         if (!extents_inline && !old_style && sector_align(fcb->inode_item.st_size, fcb->Vcb->superblock.sector_size) > last_end)
             bii->sparse_size += sector_align(fcb->inode_item.st_size, fcb->Vcb->superblock.sector_size) - last_end;
+
+        if (length >= offsetof(btrfs_inode_info, num_extents) + sizeof(((btrfs_inode_info*)NULL)->num_extents)) {
+            EXTENT_DATA2* last_ed2 = NULL;
+
+            le = fcb->extents.Flink;
+
+            bii->num_extents = 0;
+
+            while (le != &fcb->extents) {
+                extent* ext = CONTAINING_RECORD(le, extent, list_entry);
+
+                if (!ext->ignore && ext->extent_data.type != EXTENT_TYPE_INLINE) {
+                    EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ext->extent_data.data;
+
+                    if (ed2->size != 0) {
+                        if (!last_ed2 || ed2->offset != last_ed2->offset + last_ed2->num_bytes)
+                            bii->num_extents++;
+
+                        last_ed2 = ed2;
+                    } else
+                        last_ed2 = NULL;
+                }
+
+                le = le->Flink;
+            }
+        }
     }
 
     switch (fcb->prop_compression) {
@@ -1333,7 +1359,7 @@ static NTSTATUS set_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length
         return STATUS_ACCESS_DENIED;
     }
 
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (bsii->flags_changed) {
         if (fcb->type != BTRFS_TYPE_DIRECTORY && fcb->inode_item.st_size > 0 &&
@@ -1348,11 +1374,11 @@ static NTSTATUS set_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length
         if (fcb->inode_item.flags & BTRFS_INODE_NODATACOW)
             fcb->inode_item.flags |= BTRFS_INODE_NODATASUM;
         else
-            fcb->inode_item.flags &= ~(UINT64)BTRFS_INODE_NODATASUM;
+            fcb->inode_item.flags &= ~(uint64_t)BTRFS_INODE_NODATASUM;
     }
 
     if (bsii->mode_changed) {
-        UINT32 allowed = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH |
+        uint32_t allowed = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH |
                          S_ISGID | S_ISVTX;
 
         if (ccb->access & WRITE_OWNER)
@@ -1365,8 +1391,8 @@ static NTSTATUS set_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length
     if (bsii->uid_changed && fcb->inode_item.st_uid != bsii->st_uid) {
         fcb->inode_item.st_uid = bsii->st_uid;
 
-        fcb->sd_dirty = TRUE;
-        fcb->sd_deleted = FALSE;
+        fcb->sd_dirty = true;
+        fcb->sd_deleted = false;
     }
 
     if (bsii->gid_changed)
@@ -1391,11 +1417,11 @@ static NTSTATUS set_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length
             break;
         }
 
-        fcb->prop_compression_changed = TRUE;
+        fcb->prop_compression_changed = true;
     }
 
     if (bsii->flags_changed || bsii->mode_changed || bsii->uid_changed || bsii->gid_changed || bsii->compression_type_changed) {
-        fcb->inode_item_changed = TRUE;
+        fcb->inode_item_changed = true;
         mark_fcb_dirty(fcb);
     }
 
@@ -1412,7 +1438,7 @@ static NTSTATUS get_devices(device_extension* Vcb, void* data, ULONG length) {
     NTSTATUS Status;
     LIST_ENTRY* le;
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
     le = Vcb->devices.Flink;
     while (le != &Vcb->devices) {
@@ -1428,25 +1454,25 @@ static NTSTATUS get_devices(device_extension* Vcb, void* data, ULONG length) {
             dev = data;
         else {
             dev->next_entry = sizeof(btrfs_device) - sizeof(WCHAR) + dev->namelen;
-            dev = (btrfs_device*)((UINT8*)dev + dev->next_entry);
+            dev = (btrfs_device*)((uint8_t*)dev + dev->next_entry);
         }
 
         structlen = length - offsetof(btrfs_device, namelen);
 
         if (dev2->devobj) {
-            Status = dev_ioctl(dev2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &dev->namelen, structlen, TRUE, NULL);
+            Status = dev_ioctl(dev2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &dev->namelen, structlen, true, NULL);
             if (!NT_SUCCESS(Status))
                 goto end;
 
-            dev->missing = FALSE;
+            dev->missing = false;
         } else {
             dev->namelen = 0;
-            dev->missing = TRUE;
+            dev->missing = true;
         }
 
         dev->next_entry = 0;
         dev->dev_id = dev2->devitem.dev_id;
-        dev->readonly = (Vcb->readonly || dev2->readonly) ? TRUE : FALSE;
+        dev->readonly = (Vcb->readonly || dev2->readonly) ? true : false;
         dev->device_number = dev2->disk_num;
         dev->partition_number = dev2->part_num;
         dev->size = dev2->devitem.num_bytes;
@@ -1454,7 +1480,7 @@ static NTSTATUS get_devices(device_extension* Vcb, void* data, ULONG length) {
         if (dev2->devobj) {
             GET_LENGTH_INFORMATION gli;
 
-            Status = dev_ioctl(dev2->devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli), TRUE, NULL);
+            Status = dev_ioctl(dev2->devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli), true, NULL);
             if (!NT_SUCCESS(Status))
                 goto end;
 
@@ -1462,7 +1488,7 @@ static NTSTATUS get_devices(device_extension* Vcb, void* data, ULONG length) {
         } else
             dev->max_size = dev->size;
 
-        RtlCopyMemory(dev->stats, dev2->stats, sizeof(UINT64) * 5);
+        RtlCopyMemory(dev->stats, dev2->stats, sizeof(uint64_t) * 5);
 
         length -= sizeof(btrfs_device) - sizeof(WCHAR) + dev->namelen;
 
@@ -1485,7 +1511,7 @@ static NTSTATUS get_usage(device_extension* Vcb, void* data, ULONG length, PIRP
         return STATUS_BUFFER_OVERFLOW;
 
     if (!Vcb->chunk_usage_found) {
-        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
         if (!Vcb->chunk_usage_found)
             Status = find_chunk_usage(Vcb, Irp);
@@ -1502,38 +1528,38 @@ static NTSTATUS get_usage(device_extension* Vcb, void* data, ULONG length, PIRP
 
     length -= offsetof(btrfs_usage, devices);
 
-    ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
     le = Vcb->chunks.Flink;
     while (le != &Vcb->chunks) {
-        BOOL addnew = FALSE;
+        bool addnew = false;
 
         chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
 
         if (!lastbue) // first entry
-            addnew = TRUE;
+            addnew = true;
         else {
             btrfs_usage* bue = usage;
 
-            addnew = TRUE;
+            addnew = true;
 
-            while (TRUE) {
+            while (true) {
                 if (bue->type == c->chunk_item->type) {
-                    addnew = FALSE;
+                    addnew = false;
                     break;
                 }
 
                 if (bue->next_entry == 0)
                     break;
                 else
-                    bue = (btrfs_usage*)((UINT8*)bue + bue->next_entry);
+                    bue = (btrfs_usage*)((uint8_t*)bue + bue->next_entry);
             }
         }
 
         if (addnew) {
             btrfs_usage* bue;
             LIST_ENTRY* le2;
-            UINT64 factor;
+            uint64_t factor;
 
             if (!lastbue) {
                 bue = usage;
@@ -1547,7 +1573,7 @@ static NTSTATUS get_usage(device_extension* Vcb, void* data, ULONG length, PIRP
 
                 lastbue->next_entry = offsetof(btrfs_usage, devices) + (ULONG)(lastbue->num_devices * sizeof(btrfs_usage_device));
 
-                bue = (btrfs_usage*)((UINT8*)lastbue + lastbue->next_entry);
+                bue = (btrfs_usage*)((uint8_t*)lastbue + lastbue->next_entry);
             }
 
             bue->next_entry = 0;
@@ -1572,9 +1598,9 @@ static NTSTATUS get_usage(device_extension* Vcb, void* data, ULONG length, PIRP
                 chunk* c2 = CONTAINING_RECORD(le2, chunk, list_entry);
 
                 if (c2->chunk_item->type == c->chunk_item->type) {
-                    UINT16 i;
+                    uint16_t i;
                     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c2->chunk_item[1];
-                    UINT64 stripesize;
+                    uint64_t stripesize;
 
                     bue->size += c2->chunk_item->size;
                     bue->used += c2->used;
@@ -1582,13 +1608,13 @@ static NTSTATUS get_usage(device_extension* Vcb, void* data, ULONG length, PIRP
                     stripesize = c2->chunk_item->size / factor;
 
                     for (i = 0; i < c2->chunk_item->num_stripes; i++) {
-                        UINT64 j;
-                        BOOL found = FALSE;
+                        uint64_t j;
+                        bool found = false;
 
                         for (j = 0; j < bue->num_devices; j++) {
                             if (bue->devices[j].dev_id == cis[i].dev_id) {
                                 bue->devices[j].alloc += stripesize;
-                                found = TRUE;
+                                found = true;
                                 break;
                             }
                         }
@@ -1629,24 +1655,24 @@ static NTSTATUS is_volume_mounted(device_extension* Vcb, PIRP Irp) {
     NTSTATUS Status;
     ULONG cc;
     IO_STATUS_BLOCK iosb;
-    BOOL verify = FALSE;
+    bool verify = false;
     LIST_ENTRY* le;
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
     le = Vcb->devices.Flink;
     while (le != &Vcb->devices) {
         device* dev = CONTAINING_RECORD(le, device, list_entry);
 
         if (dev->devobj && dev->removable) {
-            Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, &cc, sizeof(ULONG), FALSE, &iosb);
+            Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, &cc, sizeof(ULONG), false, &iosb);
 
             if (iosb.Information != sizeof(ULONG))
                 cc = 0;
 
             if (Status == STATUS_VERIFY_REQUIRED || (NT_SUCCESS(Status) && cc != dev->change_count)) {
                 dev->devobj->Flags |= DO_VERIFY_VOLUME;
-                verify = TRUE;
+                verify = true;
             }
 
             if (NT_SUCCESS(Status) && iosb.Information == sizeof(ULONG))
@@ -1693,7 +1719,7 @@ static NTSTATUS fs_get_statistics(void* buffer, DWORD buflen, ULONG_PTR* retlen)
 static NTSTATUS set_sparse(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG length, PIRP Irp) {
     FILE_SET_SPARSE_BUFFER* fssb = data;
     NTSTATUS Status;
-    BOOL set;
+    bool set;
     fcb* fcb;
     ccb* ccb = FileObject->FsContext2;
     file_ref* fileref = ccb ? ccb->fileref : NULL;
@@ -1733,8 +1759,8 @@ static NTSTATUS set_sparse(device_extension* Vcb, PFILE_OBJECT FileObject, void*
         fcb = fileref->fcb;
     }
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (fcb->type != BTRFS_TYPE_FILE) {
         WARN("FileObject did not point to a file\n");
@@ -1745,19 +1771,19 @@ static NTSTATUS set_sparse(device_extension* Vcb, PFILE_OBJECT FileObject, void*
     if (fssb)
         set = fssb->SetSparse;
     else
-        set = TRUE;
+        set = true;
 
     if (set) {
         fcb->atts |= FILE_ATTRIBUTE_SPARSE_FILE;
-        fcb->atts_changed = TRUE;
+        fcb->atts_changed = true;
     } else {
         ULONG defda;
 
         fcb->atts &= ~FILE_ATTRIBUTE_SPARSE_FILE;
-        fcb->atts_changed = TRUE;
+        fcb->atts_changed = true;
 
         defda = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type,
-                                    fileref && fileref->dc && fileref->dc->name.Length >= sizeof(WCHAR) && fileref->dc->name.Buffer[0] == '.', TRUE, Irp);
+                                    fileref && fileref->dc && fileref->dc->name.Length >= sizeof(WCHAR) && fileref->dc->name.Buffer[0] == '.', true, Irp);
 
         fcb->atts_deleted = defda == fcb->atts;
     }
@@ -1774,12 +1800,12 @@ end:
     return Status;
 }
 
-static NTSTATUS zero_data(device_extension* Vcb, fcb* fcb, UINT64 start, UINT64 length, PIRP Irp, LIST_ENTRY* rollback) {
+static NTSTATUS zero_data(device_extension* Vcb, fcb* fcb, uint64_t start, uint64_t length, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
-    BOOL make_inline, compress;
-    UINT64 start_data, end_data;
+    bool make_inline, compress;
+    uint64_t start_data, end_data;
     ULONG buf_head;
-    UINT8* data;
+    uint8_t* data;
 
     make_inline = fcb->inode_item.st_size <= Vcb->options.max_inline || fcb_is_inline(fcb);
 
@@ -1791,12 +1817,12 @@ static NTSTATUS zero_data(device_extension* Vcb, fcb* fcb, UINT64 start, UINT64
         end_data = fcb->inode_item.st_size;
         buf_head = (ULONG)offsetof(EXTENT_DATA, data[0]);
     } else if (compress) {
-        start_data = start & ~(UINT64)(COMPRESSED_EXTENT_SIZE - 1);
+        start_data = start & ~(uint64_t)(COMPRESSED_EXTENT_SIZE - 1);
         end_data = min(sector_align(start + length, COMPRESSED_EXTENT_SIZE),
                        sector_align(fcb->inode_item.st_size, Vcb->superblock.sector_size));
         buf_head = 0;
     } else {
-        start_data = start & ~(UINT64)(Vcb->superblock.sector_size - 1);
+        start_data = start & ~(uint64_t)(Vcb->superblock.sector_size - 1);
         end_data = sector_align(start + length, Vcb->superblock.sector_size);
         buf_head = 0;
     }
@@ -1822,7 +1848,7 @@ static NTSTATUS zero_data(device_extension* Vcb, fcb* fcb, UINT64 start, UINT64
     RtlZeroMemory(data + buf_head + start - start_data, (ULONG)length);
 
     if (make_inline) {
-        UINT16 edsize;
+        uint16_t edsize;
         EXTENT_DATA* ed = (EXTENT_DATA*)data;
 
         Status = excise_extents(Vcb, fcb, 0, sector_align(end_data, Vcb->superblock.sector_size), Irp, rollback);
@@ -1832,7 +1858,7 @@ static NTSTATUS zero_data(device_extension* Vcb, fcb* fcb, UINT64 start, UINT64
             return Status;
         }
 
-        edsize = (UINT16)(offsetof(EXTENT_DATA, data[0]) + end_data);
+        edsize = (uint16_t)(offsetof(EXTENT_DATA, data[0]) + end_data);
 
         ed->generation = Vcb->superblock.generation;
         ed->decoded_size = end_data;
@@ -1841,7 +1867,7 @@ static NTSTATUS zero_data(device_extension* Vcb, fcb* fcb, UINT64 start, UINT64
         ed->encoding = BTRFS_ENCODING_NONE;
         ed->type = EXTENT_TYPE_INLINE;
 
-        Status = add_extent_to_fcb(fcb, 0, ed, edsize, FALSE, NULL, rollback);
+        Status = add_extent_to_fcb(fcb, 0, ed, edsize, false, NULL, rollback);
         if (!NT_SUCCESS(Status)) {
             ERR("add_extent_to_fcb returned %08x\n", Status);
             ExFreePool(data);
@@ -1861,7 +1887,7 @@ static NTSTATUS zero_data(device_extension* Vcb, fcb* fcb, UINT64 start, UINT64
             return Status;
         }
     } else {
-        Status = do_write_file(fcb, start_data, end_data, data, Irp, FALSE, 0, rollback);
+        Status = do_write_file(fcb, start_data, end_data, data, Irp, false, 0, rollback);
 
         ExFreePool(data);
 
@@ -1883,7 +1909,7 @@ static NTSTATUS set_zero_data(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     LIST_ENTRY rollback, *le;
     LARGE_INTEGER time;
     BTRFS_TIME now;
-    UINT64 start, end;
+    uint64_t start, end;
     extent* ext;
     IO_STATUS_BLOCK iosb;
 
@@ -1896,7 +1922,7 @@ static NTSTATUS set_zero_data(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     }
 
     if (fzdi->BeyondFinalZero.QuadPart <= fzdi->FileOffset.QuadPart) {
-        WARN("BeyondFinalZero was less than or equal to FileOffset (%llx <= %llx)\n", fzdi->BeyondFinalZero.QuadPart, fzdi->FileOffset.QuadPart);
+        WARN("BeyondFinalZero was less than or equal to FileOffset (%I64x <= %I64x)\n", fzdi->BeyondFinalZero.QuadPart, fzdi->FileOffset.QuadPart);
         return STATUS_INVALID_PARAMETER;
     }
 
@@ -1928,10 +1954,10 @@ static NTSTATUS set_zero_data(device_extension* Vcb, PFILE_OBJECT FileObject, vo
 
     InitializeListHead(&rollback);
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
-    CcFlushCache(&fcb->nonpaged->segment_object, NULL, 0, &iosb);
+    CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, &iosb);
 
     if (fcb->type != BTRFS_TYPE_FILE) {
         WARN("FileObject did not point to a file\n");
@@ -1945,7 +1971,7 @@ static NTSTATUS set_zero_data(device_extension* Vcb, PFILE_OBJECT FileObject, vo
         goto end;
     }
 
-    if ((UINT64)fzdi->FileOffset.QuadPart >= fcb->inode_item.st_size) {
+    if ((uint64_t)fzdi->FileOffset.QuadPart >= fcb->inode_item.st_size) {
         Status = STATUS_SUCCESS;
         goto end;
     }
@@ -1977,7 +2003,7 @@ static NTSTATUS set_zero_data(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     } else {
         start = sector_align(fzdi->FileOffset.QuadPart, Vcb->superblock.sector_size);
 
-        if ((UINT64)fzdi->BeyondFinalZero.QuadPart > fcb->inode_item.st_size)
+        if ((uint64_t)fzdi->BeyondFinalZero.QuadPart > fcb->inode_item.st_size)
             end = sector_align(fcb->inode_item.st_size, Vcb->superblock.sector_size);
         else
             end = (fzdi->BeyondFinalZero.QuadPart / Vcb->superblock.sector_size) * Vcb->superblock.sector_size;
@@ -1989,7 +2015,7 @@ static NTSTATUS set_zero_data(device_extension* Vcb, PFILE_OBJECT FileObject, vo
                 goto end;
             }
         } else {
-            if (start > (UINT64)fzdi->FileOffset.QuadPart) {
+            if (start > (uint64_t)fzdi->FileOffset.QuadPart) {
                 Status = zero_data(Vcb, fcb, fzdi->FileOffset.QuadPart, start - fzdi->FileOffset.QuadPart, Irp, &rollback);
                 if (!NT_SUCCESS(Status)) {
                     ERR("zero_data returned %08x\n", Status);
@@ -1997,7 +2023,7 @@ static NTSTATUS set_zero_data(device_extension* Vcb, PFILE_OBJECT FileObject, vo
                 }
             }
 
-            if (end < (UINT64)fzdi->BeyondFinalZero.QuadPart) {
+            if (end < (uint64_t)fzdi->BeyondFinalZero.QuadPart) {
                 Status = zero_data(Vcb, fcb, end, fzdi->BeyondFinalZero.QuadPart - end, Irp, &rollback);
                 if (!NT_SUCCESS(Status)) {
                     ERR("zero_data returned %08x\n", Status);
@@ -2015,7 +2041,7 @@ static NTSTATUS set_zero_data(device_extension* Vcb, PFILE_OBJECT FileObject, vo
         }
     }
 
-    CcPurgeCacheSection(&fcb->nonpaged->segment_object, &fzdi->FileOffset, (ULONG)(fzdi->BeyondFinalZero.QuadPart - fzdi->FileOffset.QuadPart), FALSE);
+    CcPurgeCacheSection(FileObject->SectionObjectPointer, &fzdi->FileOffset, (ULONG)(fzdi->BeyondFinalZero.QuadPart - fzdi->FileOffset.QuadPart), false);
 
     KeQuerySystemTime(&time);
     win_time_to_unix(time, &now);
@@ -2029,8 +2055,8 @@ static NTSTATUS set_zero_data(device_extension* Vcb, PFILE_OBJECT FileObject, vo
     if (!ccb->user_set_write_time)
         fcb->inode_item.st_mtime = now;
 
-    fcb->extents_changed = TRUE;
-    fcb->inode_item_changed = TRUE;
+    fcb->extents_changed = true;
+    fcb->inode_item_changed = true;
     mark_fcb_dirty(fcb);
 
     send_notification_fcb(fileref, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_ACTION_MODIFIED, NULL);
@@ -2058,7 +2084,7 @@ static NTSTATUS query_ranges(PFILE_OBJECT FileObject, FILE_ALLOCATED_RANGE_BUFFE
     LIST_ENTRY* le;
     FILE_ALLOCATED_RANGE_BUFFER* ranges = outbuf;
     ULONG i = 0;
-    UINT64 last_start, last_end;
+    uint64_t last_start, last_end;
 
     TRACE("FSCTL_QUERY_ALLOCATED_RANGES\n");
 
@@ -2077,7 +2103,7 @@ static NTSTATUS query_ranges(PFILE_OBJECT FileObject, FILE_ALLOCATED_RANGE_BUFFE
         return STATUS_INVALID_PARAMETER;
     }
 
-    ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
     // If file is not marked as sparse, claim the whole thing as an allocated range
 
@@ -2107,7 +2133,7 @@ static NTSTATUS query_ranges(PFILE_OBJECT FileObject, FILE_ALLOCATED_RANGE_BUFFE
 
         if (!ext->ignore) {
             EXTENT_DATA2* ed2 = (ext->extent_data.type == EXTENT_TYPE_REGULAR || ext->extent_data.type == EXTENT_TYPE_PREALLOC) ? (EXTENT_DATA2*)ext->extent_data.data : NULL;
-            UINT64 len = ed2 ? ed2->num_bytes : ext->extent_data.decoded_size;
+            uint64_t len = ed2 ? ed2->num_bytes : ext->extent_data.decoded_size;
 
             if (ext->offset > last_end) { // first extent after a hole
                 if (last_end > last_start) {
@@ -2171,10 +2197,10 @@ static NTSTATUS get_object_id(device_extension* Vcb, PFILE_OBJECT FileObject, FI
         return STATUS_INVALID_PARAMETER;
     }
 
-    ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
-    RtlCopyMemory(&buf->ObjectId[0], &fcb->inode, sizeof(UINT64));
-    RtlCopyMemory(&buf->ObjectId[sizeof(UINT64)], &fcb->subvol->id, sizeof(UINT64));
+    RtlCopyMemory(&buf->ObjectId[0], &fcb->inode, sizeof(uint64_t));
+    RtlCopyMemory(&buf->ObjectId[sizeof(uint64_t)], &fcb->subvol->id, sizeof(uint64_t));
 
     ExReleaseResourceLite(fcb->Header.Resource);
 
@@ -2204,7 +2230,7 @@ static NTSTATUS lock_volume(device_extension* Vcb, PIRP Irp) {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     NTSTATUS Status;
     KIRQL irql;
-    BOOL lock_paused_balance = FALSE;
+    bool lock_paused_balance = false;
 
     TRACE("FSCTL_LOCK_VOLUME\n");
 
@@ -2225,7 +2251,7 @@ static NTSTATUS lock_volume(device_extension* Vcb, PIRP Irp) {
     if (Vcb->locked)
         return STATUS_SUCCESS;
 
-    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, true);
 
     if (Vcb->root_fileref && Vcb->root_fileref->fcb && (Vcb->root_fileref->open_count > 0 || has_open_children(Vcb->root_fileref))) {
         Status = STATUS_ACCESS_DENIED;
@@ -2236,14 +2262,14 @@ static NTSTATUS lock_volume(device_extension* Vcb, PIRP Irp) {
     ExReleaseResourceLite(&Vcb->fileref_lock);
 
     if (Vcb->balance.thread && KeReadStateEvent(&Vcb->balance.event)) {
-        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
         KeClearEvent(&Vcb->balance.event);
         ExReleaseResourceLite(&Vcb->tree_lock);
 
-        lock_paused_balance = TRUE;
+        lock_paused_balance = true;
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     flush_fcb_caches(Vcb);
 
@@ -2265,7 +2291,7 @@ static NTSTATUS lock_volume(device_extension* Vcb, PIRP Irp) {
 
     if (!(Vcb->Vpb->Flags & VPB_LOCKED)) {
         Vcb->Vpb->Flags |= VPB_LOCKED;
-        Vcb->locked = TRUE;
+        Vcb->locked = true;
         Vcb->locked_fileobj = IrpSp->FileObject;
         Vcb->lock_paused_balance = lock_paused_balance;
     } else {
@@ -2273,7 +2299,7 @@ static NTSTATUS lock_volume(device_extension* Vcb, PIRP Irp) {
         IoReleaseVpbSpinLock(irql);
 
         if (lock_paused_balance)
-            KeSetEvent(&Vcb->balance.event, 0, FALSE);
+            KeSetEvent(&Vcb->balance.event, 0, false);
 
         goto end;
     }
@@ -2294,14 +2320,14 @@ void do_unlock_volume(device_extension* Vcb) {
 
     IoAcquireVpbSpinLock(&irql);
 
-    Vcb->locked = FALSE;
+    Vcb->locked = false;
     Vcb->Vpb->Flags &= ~VPB_LOCKED;
     Vcb->locked_fileobj = NULL;
 
     IoReleaseVpbSpinLock(irql);
 
     if (Vcb->lock_paused_balance)
-        KeSetEvent(&Vcb->balance.event, 0, FALSE);
+        KeSetEvent(&Vcb->balance.event, 0, false);
 }
 
 static NTSTATUS unlock_volume(device_extension* Vcb, PIRP Irp) {
@@ -2337,10 +2363,10 @@ static NTSTATUS invalidate_volumes(PIRP Irp) {
 
 #if defined(_WIN64)
     if (IoIs32bitProcess(Irp)) {
-        if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof(UINT32))
+        if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof(uint32_t))
             return STATUS_INVALID_PARAMETER;
 
-        h = (HANDLE)LongToHandle((*(PUINT32)Irp->AssociatedIrp.SystemBuffer));
+        h = (HANDLE)LongToHandle((*(uint32_t*)Irp->AssociatedIrp.SystemBuffer));
     } else {
 #endif
         if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof(HANDLE))
@@ -2360,7 +2386,7 @@ static NTSTATUS invalidate_volumes(PIRP Irp) {
 
     devobj = fileobj->DeviceObject;
 
-    ExAcquireResourceSharedLite(&global_loading_lock, TRUE);
+    ExAcquireResourceSharedLite(&global_loading_lock, true);
 
     le = VcbList.Flink;
 
@@ -2371,7 +2397,7 @@ static NTSTATUS invalidate_volumes(PIRP Irp) {
             if (Vcb->Vpb == devobj->Vpb) {
                 KIRQL irql;
                 PVPB newvpb;
-                BOOL free_newvpb = FALSE;
+                bool free_newvpb = false;
 
                 newvpb = ExAllocatePoolWithTag(NonPagedPool, sizeof(VPB), ALLOC_TAG);
                 if (!newvpb) {
@@ -2382,15 +2408,15 @@ static NTSTATUS invalidate_volumes(PIRP Irp) {
 
                 RtlZeroMemory(newvpb, sizeof(VPB));
 
-                ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
-                Vcb->removing = TRUE;
+                Vcb->removing = true;
 
                 ExReleaseResourceLite(&Vcb->tree_lock);
 
                 CcWaitForCurrentLazyWriterActivity();
 
-                ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
                 flush_fcb_caches(Vcb);
 
@@ -2422,7 +2448,7 @@ static NTSTATUS invalidate_volumes(PIRP Irp) {
 
                     devobj->Vpb = newvpb;
                 } else
-                    free_newvpb = TRUE;
+                    free_newvpb = true;
 
                 IoReleaseVpbSpinLock(irql);
 
@@ -2524,9 +2550,9 @@ static void update_volumes(device_extension* Vcb) {
     volume_device_extension* vde = Vcb->vde;
     pdo_device_extension* pdode = vde->pdode;
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-    ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
 
     le = pdode->children.Flink;
     while (le != &pdode->children) {
@@ -2550,7 +2576,7 @@ static NTSTATUS dismount_volume(device_extension* Vcb, PIRP Irp) {
     if (!(Vcb->Vpb->Flags & VPB_MOUNTED))
         return STATUS_SUCCESS;
 
-    if (Vcb->disallow_dismount) {
+    if (Vcb->disallow_dismount || Vcb->page_file_count != 0) {
         WARN("attempting to dismount boot volume or one containing a pagefile\n");
         return STATUS_ACCESS_DENIED;
     }
@@ -2560,7 +2586,7 @@ static NTSTATUS dismount_volume(device_extension* Vcb, PIRP Irp) {
         WARN("FsRtlNotifyVolumeEvent returned %08x\n", Status);
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     if (!Vcb->locked) {
         flush_fcb_caches(Vcb);
@@ -2575,7 +2601,7 @@ static NTSTATUS dismount_volume(device_extension* Vcb, PIRP Irp) {
 
     free_trees(Vcb);
 
-    Vcb->removing = TRUE;
+    Vcb->removing = true;
 
     if (Vcb->vde) {
         update_volumes(Vcb);
@@ -2587,11 +2613,11 @@ static NTSTATUS dismount_volume(device_extension* Vcb, PIRP Irp) {
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS is_device_part_of_mounted_btrfs_raid(PDEVICE_OBJECT devobj) {
+static NTSTATUS is_device_part_of_mounted_btrfs_raid(PDEVICE_OBJECT devobj, PFILE_OBJECT fileobj) {
     NTSTATUS Status;
     ULONG to_read;
     superblock* sb;
-    UINT32 crc32;
+    uint32_t crc32;
     BTRFS_UUID fsuuid, devuuid;
     LIST_ENTRY* le;
 
@@ -2603,7 +2629,7 @@ static NTSTATUS is_device_part_of_mounted_btrfs_raid(PDEVICE_OBJECT devobj) {
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    Status = sync_read_phys(devobj, superblock_addrs[0], to_read, (UINT8*)sb, TRUE);
+    Status = sync_read_phys(devobj, fileobj, superblock_addrs[0], to_read, (uint8_t*)sb, true);
     if (!NT_SUCCESS(Status)) {
         ERR("sync_read_phys returned %08x\n", Status);
         ExFreePool(sb);
@@ -2616,9 +2642,9 @@ static NTSTATUS is_device_part_of_mounted_btrfs_raid(PDEVICE_OBJECT devobj) {
         return STATUS_SUCCESS;
     }
 
-    crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
+    crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
 
-    if (crc32 != *((UINT32*)sb->checksum)) {
+    if (crc32 != *((uint32_t*)sb->checksum)) {
         TRACE("device has Btrfs magic, but invalid superblock checksum\n");
         ExFreePool(sb);
         return STATUS_SUCCESS;
@@ -2629,7 +2655,7 @@ static NTSTATUS is_device_part_of_mounted_btrfs_raid(PDEVICE_OBJECT devobj) {
 
     ExFreePool(sb);
 
-    ExAcquireResourceSharedLite(&global_loading_lock, TRUE);
+    ExAcquireResourceSharedLite(&global_loading_lock, true);
 
     le = VcbList.Flink;
 
@@ -2639,7 +2665,7 @@ static NTSTATUS is_device_part_of_mounted_btrfs_raid(PDEVICE_OBJECT devobj) {
         if (RtlCompareMemory(&Vcb->superblock.uuid, &fsuuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
             LIST_ENTRY* le2;
 
-            ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
             if (Vcb->superblock.num_devices > 1) {
                 le2 = Vcb->devices.Flink;
@@ -2683,7 +2709,7 @@ void trim_whole_device(device* dev) {
     dmdsa.DataSetRangesOffset = 0;
     dmdsa.DataSetRangesLength = 0;
 
-    Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES, &dmdsa, sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), NULL, 0, TRUE, NULL);
+    Status = dev_ioctl(dev->devobj, IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES, &dmdsa, sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), NULL, 0, true, NULL);
     if (!NT_SUCCESS(Status))
         WARN("IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES returned %08x\n", Status);
 }
@@ -2697,9 +2723,9 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
     LIST_ENTRY* le;
     device* dev;
     DEV_ITEM* di;
-    UINT64 dev_id, size;
-    UINT8* mb;
-    UINT64* stats;
+    uint64_t dev_id, size;
+    uint8_t* mb;
+    uint64_t* stats;
     UNICODE_STRING mmdevpath, pnp_name, pnp_name2;
     volume_child* vc;
     PDEVICE_OBJECT mountmgr;
@@ -2726,10 +2752,10 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
 
 #if defined(_WIN64)
     if (IoIs32bitProcess(Irp)) {
-        if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof(UINT32))
+        if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof(uint32_t))
             return STATUS_INVALID_PARAMETER;
 
-        h = (HANDLE)LongToHandle((*(PUINT32)Irp->AssociatedIrp.SystemBuffer));
+        h = (HANDLE)LongToHandle((*(uint32_t*)Irp->AssociatedIrp.SystemBuffer));
     } else {
 #endif
         if (IrpSp->Parameters.FileSystemControl.InputBufferLength != sizeof(HANDLE))
@@ -2760,14 +2786,14 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
     if (RtlCompareMemory(pnp_guid, &GUID_DEVINTERFACE_DISK, sizeof(GUID)) == sizeof(GUID) && DeviceObject->AttachedDevice)
         DeviceObject = DeviceObject->AttachedDevice;
 
-    Status = dev_ioctl(DeviceObject, IOCTL_DISK_IS_WRITABLE, NULL, 0, NULL, 0, TRUE, NULL);
+    Status = dev_ioctl(DeviceObject, IOCTL_DISK_IS_WRITABLE, NULL, 0, NULL, 0, true, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("IOCTL_DISK_IS_WRITABLE returned %08x\n", Status);
         ObDereferenceObject(fileobj);
         return Status;
     }
 
-    Status = is_device_part_of_mounted_btrfs_raid(DeviceObject);
+    Status = is_device_part_of_mounted_btrfs_raid(DeviceObject, fileobj);
     if (!NT_SUCCESS(Status)) {
         ERR("is_device_part_of_mounted_btrfs_raid returned %08x\n", Status);
         ObDereferenceObject(fileobj);
@@ -2794,7 +2820,7 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
                 goto end2;
             }
 
-            Status = dev_ioctl(DeviceObject, IOCTL_DISK_GET_DRIVE_LAYOUT_EX, NULL, 0, dli, dlisize, TRUE, NULL);
+            Status = dev_ioctl(DeviceObject, IOCTL_DISK_GET_DRIVE_LAYOUT_EX, NULL, 0, dli, dlisize, true, NULL);
         } while (Status == STATUS_BUFFER_TOO_SMALL);
 
         if (NT_SUCCESS(Status) && dli->PartitionCount > 0) {
@@ -2808,7 +2834,7 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
     }
 
     Status = dev_ioctl(DeviceObject, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0,
-                       &sdn, sizeof(STORAGE_DEVICE_NUMBER), TRUE, NULL);
+                       &sdn, sizeof(STORAGE_DEVICE_NUMBER), true, NULL);
     if (NT_SUCCESS(Status)) {
         if (sdn.DeviceType != FILE_DEVICE_DISK) { // FIXME - accept floppies and CDs?
             WARN("device was not disk\n");
@@ -2821,7 +2847,7 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
     }
 
     Status = dev_ioctl(DeviceObject, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
-                        &gli, sizeof(gli), TRUE, NULL);
+                        &gli, sizeof(gli), true, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("error reading length information: %08x\n", Status);
         ObDereferenceObject(fileobj);
@@ -2831,14 +2857,14 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
     size = gli.Length.QuadPart;
 
     if (size < 0x100000) {
-        ERR("device was not large enough to hold FS (%llx bytes, need at least 1 MB)\n", size);
+        ERR("device was not large enough to hold FS (%I64x bytes, need at least 1 MB)\n", size);
         ObDereferenceObject(fileobj);
         return STATUS_INTERNAL_ERROR;
     }
 
     volume_removal(drvobj, &pnp_name);
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     if (Vcb->need_write)
         Status = do_write(Vcb, Irp);
@@ -2862,8 +2888,9 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
     RtlZeroMemory(dev, sizeof(device));
 
     dev->devobj = DeviceObject;
-    dev->seeding = FALSE;
-    init_device(Vcb, dev, TRUE);
+    dev->fileobj = fileobj;
+    dev->seeding = false;
+    init_device(Vcb, dev, true);
 
     InitializeListHead(&dev->space);
 
@@ -2920,20 +2947,20 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
     }
 
     // add stats entry to dev tree
-    stats = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64) * 5, ALLOC_TAG);
+    stats = ExAllocatePoolWithTag(PagedPool, sizeof(uint64_t) * 5, ALLOC_TAG);
     if (!stats) {
         ERR("out of memory\n");
         Status = STATUS_INSUFFICIENT_RESOURCES;
         goto end;
     }
 
-    RtlZeroMemory(stats, sizeof(UINT64) * 5);
+    RtlZeroMemory(stats, sizeof(uint64_t) * 5);
 
     searchkey.obj_id = 0;
     searchkey.obj_type = TYPE_DEV_STATS;
     searchkey.offset = di->dev_id;
 
-    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, false, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         ExFreePool(stats);
@@ -2949,7 +2976,7 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
         }
     }
 
-    Status = insert_tree_item(Vcb, Vcb->dev_root, 0, TYPE_DEV_STATS, di->dev_id, stats, sizeof(UINT64) * 5, NULL, Irp);
+    Status = insert_tree_item(Vcb, Vcb->dev_root, 0, TYPE_DEV_STATS, di->dev_id, stats, sizeof(uint64_t) * 5, NULL, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("insert_tree_item returned %08x\n", Status);
         ExFreePool(stats);
@@ -2969,7 +2996,7 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
 
     RtlZeroMemory(mb, 0x100000);
 
-    Status = write_data_phys(DeviceObject, 0, mb, 0x100000);
+    Status = write_data_phys(DeviceObject, fileobj, 0, mb, 0x100000);
     if (!NT_SUCCESS(Status)) {
         ERR("write_data_phys returned %08x\n", Status);
         ExFreePool(mb);
@@ -3025,12 +3052,12 @@ static NTSTATUS add_device(device_extension* Vcb, PIRP Irp, KPROCESSOR_MODE proc
     }
 
     vc->size = size;
-    vc->seeding = FALSE;
+    vc->seeding = false;
     vc->disk_num = sdn.DeviceNumber;
     vc->part_num = sdn.PartitionNumber;
-    vc->had_drive_letter = FALSE;
+    vc->had_drive_letter = false;
 
-    ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
     InsertTailList(&pdode->children, &vc->list_entry);
     pdode->num_children++;
     pdode->children_loaded++;
@@ -3103,7 +3130,7 @@ static NTSTATUS allow_extended_dasd_io(device_extension* Vcb, PFILE_OBJECT FileO
     if (!ccb)
         return STATUS_INVALID_PARAMETER;
 
-    ccb->allow_extended_dasd_io = TRUE;
+    ccb->allow_extended_dasd_io = true;
 
     return STATUS_SUCCESS;
 }
@@ -3118,11 +3145,11 @@ static NTSTATUS query_uuid(device_extension* Vcb, void* data, ULONG length) {
 }
 
 static NTSTATUS reset_stats(device_extension* Vcb, void* data, ULONG length, KPROCESSOR_MODE processor_mode) {
-    UINT64 devid;
+    uint64_t devid;
     NTSTATUS Status;
     LIST_ENTRY* le;
 
-    if (length < sizeof(UINT64))
+    if (length < sizeof(uint64_t))
         return STATUS_INVALID_PARAMETER;
 
     if (Vcb->readonly)
@@ -3131,9 +3158,9 @@ static NTSTATUS reset_stats(device_extension* Vcb, void* data, ULONG length, KPR
     if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), processor_mode))
         return STATUS_PRIVILEGE_NOT_HELD;
 
-    devid = *((UINT64*)data);
+    devid = *((uint64_t*)data);
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
     le = Vcb->devices.Flink;
 
@@ -3141,10 +3168,10 @@ static NTSTATUS reset_stats(device_extension* Vcb, void* data, ULONG length, KPR
         device* dev = CONTAINING_RECORD(le, device, list_entry);
 
         if (dev->devitem.dev_id == devid) {
-            RtlZeroMemory(dev->stats, sizeof(UINT64) * 5);
-            dev->stats_changed = TRUE;
-            Vcb->stats_changed = TRUE;
-            Vcb->need_write = TRUE;
+            RtlZeroMemory(dev->stats, sizeof(uint64_t) * 5);
+            dev->stats_changed = true;
+            Vcb->stats_changed = true;
+            Vcb->need_write = true;
             Status = STATUS_SUCCESS;
             goto end;
         }
@@ -3152,7 +3179,7 @@ static NTSTATUS reset_stats(device_extension* Vcb, void* data, ULONG length, KPR
         le = le->Flink;
     }
 
-    WARN("device %llx not found\n", devid);
+    WARN("device %I64x not found\n", devid);
     Status = STATUS_INVALID_PARAMETER;
 
 end:
@@ -3197,7 +3224,7 @@ static NTSTATUS set_integrity_information(PFILE_OBJECT FileObject, void* data, U
     return STATUS_SUCCESS;
 }
 
-BOOL fcb_is_inline(fcb* fcb) {
+bool fcb_is_inline(fcb* fcb) {
     LIST_ENTRY* le;
 
     le = fcb->extents.Flink;
@@ -3210,7 +3237,7 @@ BOOL fcb_is_inline(fcb* fcb) {
         le = le->Flink;
     }
 
-    return FALSE;
+    return false;
 }
 
 static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen, PIRP Irp) {
@@ -3219,11 +3246,11 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
     ccb *ccb = FileObject ? FileObject->FsContext2 : NULL, *sourceccb;
     NTSTATUS Status;
     PFILE_OBJECT sourcefo;
-    UINT64 sourcelen, nbytes = 0;
+    uint64_t sourcelen, nbytes = 0;
     LIST_ENTRY rollback, *le, newexts;
     LARGE_INTEGER time;
     BTRFS_TIME now;
-    BOOL make_inline;
+    bool make_inline;
 
     if (!ded || datalen < sizeof(DUPLICATE_EXTENTS_DATA))
         return STATUS_BUFFER_TOO_SMALL;
@@ -3293,7 +3320,7 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
 
     sourcelen = sourcefcb->ads ? sourcefcb->adsdata.Length : sourcefcb->inode_item.st_size;
 
-    if (sector_align(sourcelen, Vcb->superblock.sector_size) < (UINT64)ded->SourceFileOffset.QuadPart + (UINT64)ded->ByteCount.QuadPart) {
+    if (sector_align(sourcelen, Vcb->superblock.sector_size) < (uint64_t)ded->SourceFileOffset.QuadPart + (uint64_t)ded->ByteCount.QuadPart) {
         ObDereferenceObject(sourcefo);
         return STATUS_NOT_SUPPORTED;
     }
@@ -3315,12 +3342,12 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
     InitializeListHead(&rollback);
     InitializeListHead(&newexts);
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (fcb != sourcefcb)
-        ExAcquireResourceSharedLite(sourcefcb->Header.Resource, TRUE);
+        ExAcquireResourceSharedLite(sourcefcb->Header.Resource, true);
 
     if (!FsRtlFastCheckLockForWrite(&fcb->lock, &ded->TargetFileOffset, &ded->ByteCount, 0, FileObject, PsGetCurrentProcess())) {
         Status = STATUS_FILE_LOCK_CONFLICT;
@@ -3332,10 +3359,10 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
         goto end;
     }
 
-    make_inline = fcb->ads ? FALSE : (fcb->inode_item.st_size <= Vcb->options.max_inline || fcb_is_inline(fcb));
+    make_inline = fcb->ads ? false : (fcb->inode_item.st_size <= Vcb->options.max_inline || fcb_is_inline(fcb));
 
     if (fcb->ads || sourcefcb->ads || make_inline || fcb_is_inline(sourcefcb)) {
-        UINT8* data2;
+        uint8_t* data2;
         ULONG bytes_read, dataoff, datalen2;
 
         if (make_inline) {
@@ -3391,7 +3418,7 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
         if (fcb->ads)
             RtlCopyMemory(&fcb->adsdata.Buffer[ded->TargetFileOffset.QuadPart], data2, (USHORT)min(ded->ByteCount.QuadPart, fcb->adsdata.Length - ded->TargetFileOffset.QuadPart));
         else if (make_inline) {
-            UINT16 edsize;
+            uint16_t edsize;
             EXTENT_DATA* ed;
 
             Status = excise_extents(Vcb, fcb, 0, sector_align(fcb->inode_item.st_size, Vcb->superblock.sector_size), Irp, &rollback);
@@ -3401,7 +3428,7 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
                 goto end;
             }
 
-            edsize = (UINT16)(offsetof(EXTENT_DATA, data[0]) + datalen2);
+            edsize = (uint16_t)(offsetof(EXTENT_DATA, data[0]) + datalen2);
 
             ed = ExAllocatePoolWithTag(PagedPool, edsize, ALLOC_TAG);
             if (!ed) {
@@ -3420,7 +3447,7 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
 
             RtlCopyMemory(ed->data, data2, datalen2);
 
-            Status = add_extent_to_fcb(fcb, 0, ed, edsize, FALSE, NULL, &rollback);
+            Status = add_extent_to_fcb(fcb, 0, ed, edsize, false, NULL, &rollback);
             if (!NT_SUCCESS(Status)) {
                 ERR("add_extent_to_fcb returned %08x\n", Status);
                 ExFreePool(data2);
@@ -3429,9 +3456,9 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
 
             fcb->inode_item.st_blocks += datalen2;
         } else {
-            UINT64 start = ded->TargetFileOffset.QuadPart - (ded->TargetFileOffset.QuadPart % Vcb->superblock.sector_size);
+            uint64_t start = ded->TargetFileOffset.QuadPart - (ded->TargetFileOffset.QuadPart % Vcb->superblock.sector_size);
 
-            Status = do_write_file(fcb, start, start + datalen2, data2, Irp, FALSE, 0, &rollback);
+            Status = do_write_file(fcb, start, start + datalen2, data2, Irp, false, 0, &rollback);
             if (!NT_SUCCESS(Status)) {
                 ERR("do_write_file returned %08x\n", Status);
                 ExFreePool(data2);
@@ -3448,7 +3475,7 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
             extent* ext = CONTAINING_RECORD(le, extent, list_entry);
 
             if (!ext->ignore) {
-                if (ext->offset >= (UINT64)ded->SourceFileOffset.QuadPart + (UINT64)ded->ByteCount.QuadPart)
+                if (ext->offset >= (uint64_t)ded->SourceFileOffset.QuadPart + (uint64_t)ded->ByteCount.QuadPart)
                     break;
 
                 if (ext->extent_data.type != EXTENT_TYPE_INLINE) {
@@ -3459,7 +3486,7 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
 
                     ed2s = (EXTENT_DATA2*)ext->extent_data.data;
 
-                    if (ext->offset + ed2s->num_bytes <= (UINT64)ded->SourceFileOffset.QuadPart) {
+                    if (ext->offset + ed2s->num_bytes <= (uint64_t)ded->SourceFileOffset.QuadPart) {
                         le = le->Flink;
                         continue;
                     }
@@ -3471,15 +3498,15 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
                         goto end;
                     }
 
-                    if (ext->offset < (UINT64)ded->SourceFileOffset.QuadPart)
+                    if (ext->offset < (uint64_t)ded->SourceFileOffset.QuadPart)
                         ext2->offset = ded->TargetFileOffset.QuadPart;
                     else
                         ext2->offset = ext->offset - ded->SourceFileOffset.QuadPart + ded->TargetFileOffset.QuadPart;
 
                     ext2->datalen = sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
-                    ext2->unique = FALSE;
-                    ext2->ignore = FALSE;
-                    ext2->inserted = TRUE;
+                    ext2->unique = false;
+                    ext2->ignore = false;
+                    ext2->inserted = true;
 
                     ext2->extent_data.generation = Vcb->superblock.generation;
                     ext2->extent_data.decoded_size = ext->extent_data.decoded_size;
@@ -3493,9 +3520,9 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
                     ed2d->address = ed2s->address;
                     ed2d->size = ed2s->size;
 
-                    if (ext->offset < (UINT64)ded->SourceFileOffset.QuadPart) {
+                    if (ext->offset < (uint64_t)ded->SourceFileOffset.QuadPart) {
                         ed2d->offset = ed2s->offset + ded->SourceFileOffset.QuadPart - ext->offset;
-                        ed2d->num_bytes = min((UINT64)ded->ByteCount.QuadPart, ed2s->num_bytes + ext->offset - ded->SourceFileOffset.QuadPart);
+                        ed2d->num_bytes = min((uint64_t)ded->ByteCount.QuadPart, ed2s->num_bytes + ext->offset - ded->SourceFileOffset.QuadPart);
                     } else {
                         ed2d->offset = ed2s->offset;
                         ed2d->num_bytes = min(ded->SourceFileOffset.QuadPart + ded->ByteCount.QuadPart - ext->offset, ed2s->num_bytes);
@@ -3503,7 +3530,7 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
 
                     if (ext->csum) {
                         if (ext->extent_data.compression == BTRFS_COMPRESSION_NONE) {
-                            ext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2d->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+                            ext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2d->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                             if (!ext2->csum) {
                                 ERR("out of memory\n");
                                 Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -3512,9 +3539,9 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
                             }
 
                             RtlCopyMemory(ext2->csum, &ext->csum[(ed2d->offset - ed2s->offset) / Vcb->superblock.sector_size],
-                                          (ULONG)(ed2d->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                          (ULONG)(ed2d->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size));
                         } else {
-                            ext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2d->size * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+                            ext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2d->size * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                             if (!ext2->csum) {
                                 ERR("out of memory\n");
                                 Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -3522,7 +3549,7 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
                                 goto end;
                             }
 
-                            RtlCopyMemory(ext2->csum, ext->csum, (ULONG)(ed2s->size * sizeof(UINT32) / Vcb->superblock.sector_size));
+                            RtlCopyMemory(ext2->csum, ext->csum, (ULONG)(ed2s->size * sizeof(uint32_t) / Vcb->superblock.sector_size));
                         }
                     } else
                         ext2->csum = NULL;
@@ -3531,13 +3558,13 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
 
                     c = get_chunk_from_address(Vcb, ed2s->address);
                     if (!c) {
-                        ERR("get_chunk_from_address(%llx) failed\n", ed2s->address);
+                        ERR("get_chunk_from_address(%I64x) failed\n", ed2s->address);
                         Status = STATUS_INTERNAL_ERROR;
                         goto end;
                     }
 
                     Status = update_changed_extent_ref(Vcb, c, ed2s->address, ed2s->size, fcb->subvol->id, fcb->inode, ext2->offset - ed2d->offset,
-                                                    1, fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, Irp);
+                                                    1, fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
                     if (!NT_SUCCESS(Status)) {
                         ERR("update_changed_extent_ref returned %08x\n", Status);
                         goto end;
@@ -3579,7 +3606,7 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
                         EXTENT_DATA2* ed2d = (EXTENT_DATA2*)ext2->extent_data.data;
 
                         if (ed2d->address == ed2s->address && ed2d->size == ed2s->size) {
-                            ext->unique = FALSE;
+                            ext->unique = false;
                             break;
                         }
                     }
@@ -3609,7 +3636,7 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
         if (!ccb->user_set_change_time)
             ccb->fileref->parent->fcb->inode_item.st_ctime = now;
 
-        ccb->fileref->parent->fcb->inode_item_changed = TRUE;
+        ccb->fileref->parent->fcb->inode_item_changed = true;
         mark_fcb_dirty(ccb->fileref->parent->fcb);
     } else {
         fcb->inode_item.st_blocks += nbytes;
@@ -3623,14 +3650,14 @@ static NTSTATUS duplicate_extents(device_extension* Vcb, PFILE_OBJECT FileObject
             send_notification_fcb(ccb->fileref, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_ACTION_MODIFIED, NULL);
         }
 
-        fcb->inode_item_changed = TRUE;
-        fcb->extents_changed = TRUE;
+        fcb->inode_item_changed = true;
+        fcb->extents_changed = true;
     }
 
     mark_fcb_dirty(fcb);
 
-    if (fcb->nonpaged->segment_object.DataSectionObject)
-        CcPurgeCacheSection(&fcb->nonpaged->segment_object, &ded->TargetFileOffset, (ULONG)ded->ByteCount.QuadPart, FALSE);
+    if (FileObject->SectionObjectPointer->DataSectionObject)
+        CcPurgeCacheSection(FileObject->SectionObjectPointer, &ded->TargetFileOffset, (ULONG)ded->ByteCount.QuadPart, false);
 
     Status = STATUS_SUCCESS;
 
@@ -3660,7 +3687,7 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
     file_ref *parfileref, *fileref;
     UNICODE_STRING name;
     root* subvol;
-    UINT64 inode;
+    uint64_t inode;
     dir_child* dc;
     LARGE_INTEGER time;
     BTRFS_TIME now;
@@ -3726,14 +3753,14 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
     if (bmn->name[0] == '.' && (bmn->namelen == sizeof(WCHAR) || (bmn->namelen == 2 * sizeof(WCHAR) && bmn->name[1] == '.')))
         return STATUS_OBJECT_NAME_INVALID;
 
-    Status = RtlUnicodeToUTF8N(NULL, 0, &len, bmn->name, bmn->namelen);
+    Status = utf16_to_utf8(NULL, 0, &len, bmn->name, bmn->namelen);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUnicodeToUTF8N return %08x\n", Status);
+        ERR("utf16_to_utf8 return %08x\n", Status);
         return Status;
     }
 
     if (len == 0) {
-        ERR("RtlUnicodeToUTF8N returned a length of 0\n");
+        ERR("utf16_to_utf8 returned a length of 0\n");
         return STATUS_INTERNAL_ERROR;
     }
 
@@ -3750,9 +3777,9 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    Status = RtlUnicodeToUTF8N(utf8.Buffer, len, &len, bmn->name, bmn->namelen);
+    Status = utf16_to_utf8(utf8.Buffer, len, &len, bmn->name, bmn->namelen);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUnicodeToUTF8N failed with error %08x\n", Status);
+        ERR("utf16_to_utf8 failed with error %08x\n", Status);
         ExFreePool(utf8.Buffer);
         return Status;
     }
@@ -3760,7 +3787,7 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
     name.Length = name.MaximumLength = bmn->namelen;
     name.Buffer = bmn->name;
 
-    Status = find_file_in_dir(&name, parfcb, &subvol, &inode, &dc, TRUE);
+    Status = find_file_in_dir(&name, parfcb, &subvol, &inode, &dc, true);
     if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND) {
         ERR("find_file_in_dir returned %08x\n", Status);
         goto end;
@@ -3838,7 +3865,7 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
     fcb->prop_compression = parfcb->prop_compression;
     fcb->prop_compression_changed = fcb->prop_compression != PropCompression_None;
 
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
 
     fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
     fcb->Header.AllocationSize.QuadPart = 0;
@@ -3853,7 +3880,7 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
     if (bmn->type == BTRFS_TYPE_DIRECTORY)
         fcb->atts |= FILE_ATTRIBUTE_DIRECTORY;
 
-    fcb->atts_changed = FALSE;
+    fcb->atts_changed = false;
 
     InterlockedIncrement(&parfcb->refcount);
     fcb->subvol = parfcb->subvol;
@@ -3872,7 +3899,7 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
     Status = RtlGetOwnerSecurityDescriptor(fcb->sd, &owner, &defaulted);
     if (!NT_SUCCESS(Status)) {
         WARN("RtlGetOwnerSecurityDescriptor returned %08x\n", Status);
-        fcb->sd_dirty = TRUE;
+        fcb->sd_dirty = true;
     } else {
         fcb->inode_item.st_uid = sid_to_uid(owner);
         fcb->sd_dirty = fcb->inode_item.st_uid == UID_NOBODY;
@@ -3880,14 +3907,14 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
 
     find_gid(fcb, parfcb, &subjcont);
 
-    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, true);
     acquire_fcb_lock_exclusive(Vcb);
 
     if (bmn->inode == 0) {
         inode = InterlockedIncrement64(&parfcb->subvol->lastinode);
         lastle = parfcb->subvol->fcbs.Blink;
     } else {
-        if (bmn->inode > (UINT64)parfcb->subvol->lastinode) {
+        if (bmn->inode > (uint64_t)parfcb->subvol->lastinode) {
             inode = parfcb->subvol->lastinode = bmn->inode;
             lastle = parfcb->subvol->fcbs.Blink;
         } else {
@@ -3932,8 +3959,8 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
 
     fileref->fcb = fcb;
 
-    fcb->created = TRUE;
-    fileref->created = TRUE;
+    fcb->created = true;
+    fileref->created = true;
 
     fcb->subvol->root_item.ctransid = Vcb->superblock.generation;
     fcb->subvol->root_item.ctime = now;
@@ -3943,14 +3970,14 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
     mark_fcb_dirty(fcb);
     mark_fileref_dirty(fileref);
 
-    Status = add_dir_child(fileref->parent->fcb, fcb->inode, FALSE, &utf8, &name, fcb->type, &dc);
+    Status = add_dir_child(fileref->parent->fcb, fcb->inode, false, &utf8, &name, fcb->type, &dc);
     if (!NT_SUCCESS(Status))
         WARN("add_dir_child returned %08x\n", Status);
 
     fileref->dc = dc;
     dc->fileref = fileref;
 
-    ExAcquireResourceExclusiveLite(&parfileref->fcb->nonpaged->dir_children_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&parfileref->fcb->nonpaged->dir_children_lock, true);
     InsertTailList(&parfileref->children, &fileref->list_entry);
     ExReleaseResourceLite(&parfileref->fcb->nonpaged->dir_children_lock);
 
@@ -3990,7 +4017,7 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
     if (bmn->type == BTRFS_TYPE_DIRECTORY)
         fileref->fcb->fileref = fileref;
 
-    ExAcquireResourceExclusiveLite(parfcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(parfcb->Header.Resource, true);
     parfcb->inode_item.st_size += utf8.Length * 2;
     parfcb->inode_item.transid = Vcb->superblock.generation;
     parfcb->inode_item.sequence++;
@@ -4007,7 +4034,7 @@ static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data
     release_fcb_lock(Vcb);
     ExReleaseResourceLite(&Vcb->fileref_lock);
 
-    parfcb->inode_item_changed = TRUE;
+    parfcb->inode_item_changed = true;
     mark_fcb_dirty(parfcb);
 
     send_notification_fileref(fileref, bmn->type == BTRFS_TYPE_DIRECTORY ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME, FILE_ACTION_ADDED, NULL);
@@ -4026,14 +4053,14 @@ end:
 
 static void mark_subvol_dirty(device_extension* Vcb, root* r) {
     if (!r->dirty) {
-        r->dirty = TRUE;
+        r->dirty = true;
 
-        ExAcquireResourceExclusiveLite(&Vcb->dirty_subvols_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&Vcb->dirty_subvols_lock, true);
         InsertTailList(&Vcb->dirty_subvols, &r->list_entry_dirty);
         ExReleaseResourceLite(&Vcb->dirty_subvols_lock);
     }
 
-    Vcb->need_write = TRUE;
+    Vcb->need_write = true;
 }
 
 static NTSTATUS recvd_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen, KPROCESSOR_MODE processor_mode) {
@@ -4059,7 +4086,7 @@ static NTSTATUS recvd_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, voi
     if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), processor_mode))
         return STATUS_PRIVILEGE_NOT_HELD;
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
     if (fcb->subvol->root_item.rtransid != 0) {
         WARN("subvol already has received information set\n");
@@ -4075,7 +4102,7 @@ static NTSTATUS recvd_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, voi
     fcb->subvol->root_item.rtransid = Vcb->superblock.generation;
     fcb->subvol->root_item.rtime = now;
 
-    fcb->subvol->received = TRUE;
+    fcb->subvol->received = true;
     mark_subvol_dirty(Vcb, fcb->subvol);
 
     Status = STATUS_SUCCESS;
@@ -4107,7 +4134,7 @@ static NTSTATUS fsctl_get_xattrs(device_extension* Vcb, PFILE_OBJECT FileObject,
         return STATUS_ACCESS_DENIED;
     }
 
-    ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
     le = fcb->xattrs.Flink;
     while (le != &fcb->xattrs) {
@@ -4191,9 +4218,9 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
         return STATUS_ACCESS_DENIED;
     }
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (bsxa->namelen == sizeof(EA_NTACL) - 1 && RtlCompareMemory(bsxa->data, EA_NTACL, sizeof(EA_NTACL) - 1) == sizeof(EA_NTACL) - 1) {
         if ((!(ccb->access & WRITE_DAC) || !(ccb->access & WRITE_OWNER)) && Irp->RequestorMode == UserMode) {
@@ -4222,11 +4249,11 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
         } else if (fcb->sd)
             fcb->sd = NULL;
 
-        fcb->sd_dirty = TRUE;
+        fcb->sd_dirty = true;
 
         if (!fcb->sd) {
-            fcb_get_sd(fcb, ccb->fileref->parent->fcb, FALSE, Irp);
-            fcb->sd_deleted = TRUE;
+            fcb_get_sd(fcb, ccb->fileref->parent->fcb, false, Irp);
+            fcb->sd_deleted = true;
         }
 
         mark_fcb_dirty(fcb);
@@ -4251,15 +4278,15 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
                     fcb->atts &= ~FILE_ATTRIBUTE_READONLY;
             }
 
-            fcb->atts_deleted = FALSE;
+            fcb->atts_deleted = false;
         } else {
-            BOOL hidden = ccb->fileref && ccb->fileref->dc && ccb->fileref->dc->utf8.Buffer && ccb->fileref->dc->utf8.Buffer[0] == '.';
+            bool hidden = ccb->fileref && ccb->fileref->dc && ccb->fileref->dc->utf8.Buffer && ccb->fileref->dc->utf8.Buffer[0] == '.';
 
-            fcb->atts = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type, hidden, TRUE, Irp);
-            fcb->atts_deleted = TRUE;
+            fcb->atts = get_file_attributes(Vcb, fcb->subvol, fcb->inode, fcb->type, hidden, true, Irp);
+            fcb->atts_deleted = true;
         }
 
-        fcb->atts_changed = TRUE;
+        fcb->atts_changed = true;
         mark_fcb_dirty(fcb);
 
         Status = STATUS_SUCCESS;
@@ -4283,7 +4310,7 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
             fcb->reparse_xattr.Length = fcb->reparse_xattr.MaximumLength = bsxa->valuelen;
         }
 
-        fcb->reparse_xattr_changed = TRUE;
+        fcb->reparse_xattr_changed = true;
         mark_fcb_dirty(fcb);
 
         Status = STATUS_SUCCESS;
@@ -4334,19 +4361,19 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
                     if (eainfo->NextEntryOffset == 0)
                         break;
 
-                    eainfo = (FILE_FULL_EA_INFORMATION*)(((UINT8*)eainfo) + eainfo->NextEntryOffset);
-                } while (TRUE);
+                    eainfo = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)eainfo) + eainfo->NextEntryOffset);
+                } while (true);
             }
         }
 
-        fcb->ea_changed = TRUE;
+        fcb->ea_changed = true;
         mark_fcb_dirty(fcb);
 
         Status = STATUS_SUCCESS;
         goto end;
     } else if (bsxa->namelen == sizeof(EA_CASE_SENSITIVE) - 1 && RtlCompareMemory(bsxa->data, EA_CASE_SENSITIVE, sizeof(EA_CASE_SENSITIVE) - 1) == sizeof(EA_CASE_SENSITIVE) - 1) {
         if (bsxa->valuelen > 0 && bsxa->data[bsxa->namelen] == '1') {
-            fcb->case_sensitive = TRUE;
+            fcb->case_sensitive = true;
             mark_fcb_dirty(fcb);
         }
 
@@ -4368,10 +4395,10 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
 
         if (fcb->prop_compression != PropCompression_None) {
             fcb->inode_item.flags |= BTRFS_INODE_COMPRESS;
-            fcb->inode_item_changed = TRUE;
+            fcb->inode_item_changed = true;
         }
 
-        fcb->prop_compression_changed = TRUE;
+        fcb->prop_compression_changed = true;
         mark_fcb_dirty(fcb);
 
         Status = STATUS_SUCCESS;
@@ -4404,12 +4431,12 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
 
     xa->namelen = bsxa->namelen;
     xa->valuelen = bsxa->valuelen;
-    xa->dirty = TRUE;
+    xa->dirty = true;
     RtlCopyMemory(xa->data, bsxa->data, bsxa->namelen + bsxa->valuelen);
 
     InsertTailList(&fcb->xattrs, &xa->list_entry);
 
-    fcb->xattrs_changed = TRUE;
+    fcb->xattrs_changed = true;
     mark_fcb_dirty(fcb);
 
     Status = STATUS_SUCCESS;
@@ -4446,12 +4473,12 @@ static NTSTATUS reserve_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, P
         return STATUS_INVALID_PARAMETER;
 
     fcb->subvol->reserved = PsGetCurrentProcess();
-    ccb->reserving = TRUE;
+    ccb->reserving = true;
 
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS get_subvol_path(device_extension* Vcb, UINT64 id, WCHAR* out, ULONG outlen, PIRP Irp) {
+static NTSTATUS get_subvol_path(device_extension* Vcb, uint64_t id, WCHAR* out, ULONG outlen, PIRP Irp) {
     LIST_ENTRY* le;
     root* r = NULL;
     NTSTATUS Status;
@@ -4471,11 +4498,11 @@ static NTSTATUS get_subvol_path(device_extension* Vcb, UINT64 id, WCHAR* out, UL
     }
 
     if (!r) {
-        ERR("couldn't find subvol %llx\n", id);
+        ERR("couldn't find subvol %I64x\n", id);
         return STATUS_INTERNAL_ERROR;
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, true);
 
     Status = open_fileref_by_inode(Vcb, r, r->root_item.objid, &fr, Irp);
     if (!NT_SUCCESS(Status)) {
@@ -4519,7 +4546,7 @@ static NTSTATUS find_subvol(device_extension* Vcb, void* in, ULONG inlen, void*
 
     bfs = (btrfs_find_subvol*)in;
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
     if (!Vcb->uuid_root) {
         ERR("couldn't find uuid root\n");
@@ -4527,19 +4554,19 @@ static NTSTATUS find_subvol(device_extension* Vcb, void* in, ULONG inlen, void*
         goto end;
     }
 
-    RtlCopyMemory(&searchkey.obj_id, &bfs->uuid, sizeof(UINT64));
+    RtlCopyMemory(&searchkey.obj_id, &bfs->uuid, sizeof(uint64_t));
     searchkey.obj_type = TYPE_SUBVOL_UUID;
-    RtlCopyMemory(&searchkey.offset, &bfs->uuid.uuid[sizeof(UINT64)], sizeof(UINT64));
+    RtlCopyMemory(&searchkey.offset, &bfs->uuid.uuid[sizeof(uint64_t)], sizeof(uint64_t));
 
-    Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, false, Irp);
 
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         goto end;
     }
 
-    if (!keycmp(searchkey, tp.item->key) && tp.item->size >= sizeof(UINT64)) {
-        UINT64* id = (UINT64*)tp.item->data;
+    if (!keycmp(searchkey, tp.item->key) && tp.item->size >= sizeof(uint64_t)) {
+        uint64_t* id = (uint64_t*)tp.item->data;
 
         if (bfs->ctransid != 0) {
             KEY searchkey2;
@@ -4549,7 +4576,7 @@ static NTSTATUS find_subvol(device_extension* Vcb, void* in, ULONG inlen, void*
             searchkey2.obj_type = TYPE_ROOT_ITEM;
             searchkey2.offset = 0xffffffffffffffff;
 
-            Status = find_item(Vcb, Vcb->root_root, &tp2, &searchkey2, FALSE, Irp);
+            Status = find_item(Vcb, Vcb->root_root, &tp2, &searchkey2, false, Irp);
             if (!NT_SUCCESS(Status)) {
                 ERR("find_item returned %08x\n", Status);
                 goto end;
@@ -4560,13 +4587,13 @@ static NTSTATUS find_subvol(device_extension* Vcb, void* in, ULONG inlen, void*
                 ROOT_ITEM* ri = (ROOT_ITEM*)tp2.item->data;
 
                 if (ri->ctransid == bfs->ctransid) {
-                    TRACE("found subvol %llx\n", *id);
+                    TRACE("found subvol %I64x\n", *id);
                     Status = get_subvol_path(Vcb, *id, out, outlen, Irp);
                     goto end;
                 }
             }
         } else {
-            TRACE("found subvol %llx\n", *id);
+            TRACE("found subvol %I64x\n", *id);
             Status = get_subvol_path(Vcb, *id, out, outlen, Irp);
             goto end;
         }
@@ -4574,18 +4601,18 @@ static NTSTATUS find_subvol(device_extension* Vcb, void* in, ULONG inlen, void*
 
     searchkey.obj_type = TYPE_SUBVOL_REC_UUID;
 
-    Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, FALSE, Irp);
+    Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, false, Irp);
 
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         goto end;
     }
 
-    if (!keycmp(searchkey, tp.item->key) && tp.item->size >= sizeof(UINT64)) {
-        UINT64* ids = (UINT64*)tp.item->data;
+    if (!keycmp(searchkey, tp.item->key) && tp.item->size >= sizeof(uint64_t)) {
+        uint64_t* ids = (uint64_t*)tp.item->data;
         ULONG i;
 
-        for (i = 0; i < tp.item->size / sizeof(UINT64); i++) {
+        for (i = 0; i < tp.item->size / sizeof(uint64_t); i++) {
             if (bfs->ctransid != 0) {
                 KEY searchkey2;
                 traverse_ptr tp2;
@@ -4594,7 +4621,7 @@ static NTSTATUS find_subvol(device_extension* Vcb, void* in, ULONG inlen, void*
                 searchkey2.obj_type = TYPE_ROOT_ITEM;
                 searchkey2.offset = 0xffffffffffffffff;
 
-                Status = find_item(Vcb, Vcb->root_root, &tp2, &searchkey2, FALSE, Irp);
+                Status = find_item(Vcb, Vcb->root_root, &tp2, &searchkey2, false, Irp);
                 if (!NT_SUCCESS(Status)) {
                     ERR("find_item returned %08x\n", Status);
                     goto end;
@@ -4605,13 +4632,13 @@ static NTSTATUS find_subvol(device_extension* Vcb, void* in, ULONG inlen, void*
                     ROOT_ITEM* ri = (ROOT_ITEM*)tp2.item->data;
 
                     if (ri->ctransid == bfs->ctransid) {
-                        TRACE("found subvol %llx\n", ids[i]);
+                        TRACE("found subvol %I64x\n", ids[i]);
                         Status = get_subvol_path(Vcb, ids[i], out, outlen, Irp);
                         goto end;
                     }
                 }
             } else {
-                TRACE("found subvol %llx\n", ids[i]);
+                TRACE("found subvol %I64x\n", ids[i]);
                 Status = get_subvol_path(Vcb, ids[i], out, outlen, Irp);
                 goto end;
             }
@@ -4643,7 +4670,7 @@ static NTSTATUS resize_device(device_extension* Vcb, void* data, ULONG len, PIRP
     if (Vcb->readonly)
         return STATUS_MEDIA_WRITE_PROTECTED;
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     le = Vcb->devices.Flink;
     while (le != &Vcb->devices) {
@@ -4658,7 +4685,7 @@ static NTSTATUS resize_device(device_extension* Vcb, void* data, ULONG len, PIRP
     }
 
     if (!dev) {
-        ERR("could not find device %llx\n", br->device);
+        ERR("could not find device %I64x\n", br->device);
         Status = STATUS_INVALID_PARAMETER;
         goto end;
     }
@@ -4682,15 +4709,15 @@ static NTSTATUS resize_device(device_extension* Vcb, void* data, ULONG len, PIRP
     }
 
     if (br->size > 0 && dev->devitem.num_bytes > br->size) { // shrink device
-        BOOL need_balance = TRUE;
-        UINT64 old_size, delta;
+        bool need_balance = true;
+        uint64_t old_size, delta;
 
         le = dev->space.Flink;
         while (le != &dev->space) {
             space* s = CONTAINING_RECORD(le, space, list_entry);
 
             if (s->address <= br->size && s->address + s->size >= dev->devitem.num_bytes) {
-                need_balance = FALSE;
+                need_balance = false;
                 break;
             }
 
@@ -4717,8 +4744,8 @@ static NTSTATUS resize_device(device_extension* Vcb, void* data, ULONG len, PIRP
                 Vcb->balance.opts[i].drange_end = dev->devitem.num_bytes;
             }
 
-            Vcb->balance.paused = FALSE;
-            Vcb->balance.shrinking = TRUE;
+            Vcb->balance.paused = false;
+            Vcb->balance.shrinking = true;
             Vcb->balance.status = STATUS_SUCCESS;
             KeInitializeEvent(&Vcb->balance.event, NotificationEvent, !Vcb->balance.paused);
 
@@ -4750,10 +4777,10 @@ static NTSTATUS resize_device(device_extension* Vcb, void* data, ULONG len, PIRP
         Vcb->superblock.total_bytes -= delta;
     } else { // extend device
         GET_LENGTH_INFORMATION gli;
-        UINT64 old_size, delta;
+        uint64_t old_size, delta;
 
         Status = dev_ioctl(dev->devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
-                           &gli, sizeof(gli), TRUE, NULL);
+                           &gli, sizeof(gli), true, NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("IOCTL_DISK_GET_LENGTH_INFO returned %08x\n", Status);
             goto end;
@@ -4773,8 +4800,8 @@ static NTSTATUS resize_device(device_extension* Vcb, void* data, ULONG len, PIRP
                 Status = STATUS_INTERNAL_ERROR;
                 goto end;
             }
-        } else if ((UINT64)gli.Length.QuadPart < br->size) {
-            ERR("device was %llx bytes, trying to extend to %llx\n", gli.Length.QuadPart, br->size);
+        } else if ((uint64_t)gli.Length.QuadPart < br->size) {
+            ERR("device was %I64x bytes, trying to extend to %I64x\n", gli.Length.QuadPart, br->size);
             Status = STATUS_INVALID_PARAMETER;
             goto end;
         }
@@ -4797,7 +4824,7 @@ static NTSTATUS resize_device(device_extension* Vcb, void* data, ULONG len, PIRP
     }
 
     Status = STATUS_SUCCESS;
-    Vcb->need_write = TRUE;
+    Vcb->need_write = true;
 
 end:
     ExReleaseResourceLite(&Vcb->tree_lock);
@@ -4808,7 +4835,7 @@ end:
     return Status;
 }
 
-NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp, UINT32 type) {
+NTSTATUS fsctl_request(PDEVICE_OBJECT DeviceObject, PIRP* Pirp, uint32_t type) {
     PIRP Irp = *Pirp;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     NTSTATUS Status;
diff --git a/drivers/filesystems/btrfs/fsrtl.c b/drivers/filesystems/btrfs/fsrtl.c
new file mode 100644
index 00000000000..8654d84e5ae
--- /dev/null
+++ b/drivers/filesystems/btrfs/fsrtl.c
@@ -0,0 +1,126 @@
+/*
+ * PROJECT:         ReactOS Kernel - Vista+ APIs
+ * LICENSE:         LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
+ * FILE:            lib/drivers/ntoskrnl_vista/fsrtl.c
+ * PURPOSE:         FsRtl functions of Vista+
+ * PROGRAMMERS:     Pierre Schweitzer <pierre@reactos.org>
+ */
+
+#include <ntifs.h>
+#include <ntdef.h>
+
+FORCEINLINE
+BOOLEAN
+IsNullGuid(IN PGUID Guid)
+{
+    if (Guid->Data1 == 0 && Guid->Data2 == 0 && Guid->Data3 == 0 &&
+        ((ULONG *)Guid->Data4)[0] == 0 && ((ULONG *)Guid->Data4)[1] == 0)
+    {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+FORCEINLINE
+BOOLEAN
+IsEven(IN USHORT Digit)
+{
+    return ((Digit & 1) != 1);
+}
+
+NTSTATUS compat_FsRtlValidateReparsePointBuffer(IN ULONG BufferLength, IN PREPARSE_DATA_BUFFER ReparseBuffer)
+{
+    USHORT DataLength;
+    ULONG ReparseTag;
+    PREPARSE_GUID_DATA_BUFFER GuidBuffer;
+
+    /* Validate data size range */
+    if (BufferLength < REPARSE_DATA_BUFFER_HEADER_SIZE || BufferLength > MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
+    {
+        return STATUS_IO_REPARSE_DATA_INVALID;
+    }
+
+    GuidBuffer = (PREPARSE_GUID_DATA_BUFFER)ReparseBuffer;
+    DataLength = ReparseBuffer->ReparseDataLength;
+    ReparseTag = ReparseBuffer->ReparseTag;
+
+    /* Validate size consistency */
+    if (DataLength + REPARSE_DATA_BUFFER_HEADER_SIZE != BufferLength && DataLength + REPARSE_GUID_DATA_BUFFER_HEADER_SIZE != BufferLength)
+    {
+        return STATUS_IO_REPARSE_DATA_INVALID;
+    }
+
+    /* REPARSE_DATA_BUFFER is reserved for MS tags */
+    if (DataLength + REPARSE_DATA_BUFFER_HEADER_SIZE == BufferLength && !IsReparseTagMicrosoft(ReparseTag))
+    {
+        return STATUS_IO_REPARSE_DATA_INVALID;
+    }
+
+    /* If that a GUID data buffer, its GUID cannot be null, and it cannot contain a MS tag */
+    if (DataLength + REPARSE_GUID_DATA_BUFFER_HEADER_SIZE == BufferLength && ((!IsReparseTagMicrosoft(ReparseTag)
+        && IsNullGuid(&GuidBuffer->ReparseGuid)) || (ReparseTag == IO_REPARSE_TAG_MOUNT_POINT || ReparseTag == IO_REPARSE_TAG_SYMLINK)))
+    {
+        return STATUS_IO_REPARSE_DATA_INVALID;
+    }
+
+    /* Check the data for MS non reserved tags */
+    if (!(ReparseTag & 0xFFF0000) && ReparseTag != IO_REPARSE_TAG_RESERVED_ZERO && ReparseTag != IO_REPARSE_TAG_RESERVED_ONE)
+    {
+        /* If that's a mount point, validate the MountPointReparseBuffer branch */
+        if (ReparseTag == IO_REPARSE_TAG_MOUNT_POINT)
+        {
+            /* We need information */
+            if (DataLength >= REPARSE_DATA_BUFFER_HEADER_SIZE)
+            {
+                /* Substitue must be the first in row */
+                if (!ReparseBuffer->MountPointReparseBuffer.SubstituteNameOffset)
+                {
+                    /* Substitude must be null-terminated */
+                    if (ReparseBuffer->MountPointReparseBuffer.PrintNameOffset == ReparseBuffer->MountPointReparseBuffer.SubstituteNameLength + sizeof(UNICODE_NULL))
+                    {
+                        /* There must just be the Offset/Length fields + buffer + 2 null chars */
+                        if (DataLength == ReparseBuffer->MountPointReparseBuffer.PrintNameLength + ReparseBuffer->MountPointReparseBuffer.SubstituteNameLength + (FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer.PathBuffer) - FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer.SubstituteNameOffset)) + 2 * sizeof(UNICODE_NULL))
+                        {
+                            return STATUS_SUCCESS;
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+#define FIELDS_SIZE (FIELD_OFFSET(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) - FIELD_OFFSET(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.SubstituteNameOffset))
+
+            /* If that's not a symlink, accept the MS tag as it */
+            if (ReparseTag != IO_REPARSE_TAG_SYMLINK)
+            {
+                return STATUS_SUCCESS;
+            }
+
+            /* We need information */
+            if (DataLength >= FIELDS_SIZE)
+            {
+                /* Validate lengths */
+                if (ReparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength && ReparseBuffer->SymbolicLinkReparseBuffer.PrintNameLength)
+                {
+                    /* Validate unicode strings */
+                    if (IsEven(ReparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength) && IsEven(ReparseBuffer->SymbolicLinkReparseBuffer.PrintNameLength) &&
+                        IsEven(ReparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameOffset) && IsEven(ReparseBuffer->SymbolicLinkReparseBuffer.PrintNameOffset))
+                    {
+                        if ((DataLength + REPARSE_DATA_BUFFER_HEADER_SIZE >= ReparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameOffset + ReparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength + FIELDS_SIZE + REPARSE_DATA_BUFFER_HEADER_SIZE)
+                            && (DataLength + REPARSE_DATA_BUFFER_HEADER_SIZE >= ReparseBuffer->SymbolicLinkReparseBuffer.PrintNameLength + ReparseBuffer->SymbolicLinkReparseBuffer.PrintNameOffset + FIELDS_SIZE + REPARSE_DATA_BUFFER_HEADER_SIZE))
+                        {
+                            return STATUS_SUCCESS;
+                        }
+                    }
+                }
+            }
+#undef FIELDS_SIZE
+        }
+
+        return STATUS_IO_REPARSE_DATA_INVALID;
+    }
+
+    return STATUS_IO_REPARSE_TAG_INVALID;
+}
diff --git a/drivers/filesystems/btrfs/galois.c b/drivers/filesystems/btrfs/galois.c
index baa26fc78fe..f50d3289c00 100644
--- a/drivers/filesystems/btrfs/galois.c
+++ b/drivers/filesystems/btrfs/galois.c
@@ -17,7 +17,7 @@
 
 #include "btrfs_drv.h"
 
-static const UINT8 glog[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
+static const uint8_t glog[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
                              0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9, 0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
                              0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35, 0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
                              0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0, 0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
@@ -34,7 +34,7 @@ static const UINT8 glog[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1
                              0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5, 0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
                              0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83, 0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01};
 
-static const UINT8 gilog[] = {0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
+static const uint8_t gilog[] = {0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
                               0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81, 0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
                               0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21, 0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
                               0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9, 0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
@@ -52,7 +52,7 @@ static const UINT8 gilog[] = {0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x
                               0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8, 0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf};
 
 // divides the bytes in data by 2^div
-void galois_divpower(UINT8* data, UINT8 div, UINT32 len) {
+void galois_divpower(uint8_t* data, uint8_t div, uint32_t len) {
     while (len > 0) {
         if (data[0] != 0) {
             if (gilog[data[0]] <= div)
@@ -66,18 +66,18 @@ void galois_divpower(UINT8* data, UINT8 div, UINT32 len) {
     }
 }
 
-UINT8 gpow2(UINT8 e) {
+uint8_t gpow2(uint8_t e) {
     return glog[e%255];
 }
 
-UINT8 gmul(UINT8 a, UINT8 b) {
+uint8_t gmul(uint8_t a, uint8_t b) {
     if (a == 0 || b == 0)
         return 0;
     else
         return glog[(gilog[a] + gilog[b]) % 255];
 }
 
-UINT8 gdiv(UINT8 a, UINT8 b) {
+uint8_t gdiv(uint8_t a, uint8_t b) {
     if (b == 0) {
         return 0xff; // shouldn't happen
     } else if (a == 0) {
@@ -95,41 +95,41 @@ UINT8 gdiv(UINT8 a, UINT8 b) {
 // https://www.kernel.org/pub/linux/kernel/people/hpa/raid6.pdf
 
 #ifdef _AMD64_
-__inline static UINT64 galois_double_mask64(UINT64 v) {
+__inline static uint64_t galois_double_mask64(uint64_t v) {
     v &= 0x8080808080808080;
     return (v << 1) - (v >> 7);
 }
 #else
-__inline static UINT32 galois_double_mask32(UINT32 v) {
+__inline static uint32_t galois_double_mask32(uint32_t v) {
     v &= 0x80808080;
     return (v << 1) - (v >> 7);
 }
 #endif
 
-void galois_double(UINT8* data, UINT32 len) {
+void galois_double(uint8_t* data, uint32_t len) {
     // FIXME - SIMD?
 
 #ifdef _AMD64_
-    while (len > sizeof(UINT64)) {
-        UINT64 v = *((UINT64*)data), vv;
+    while (len > sizeof(uint64_t)) {
+        uint64_t v = *((uint64_t*)data), vv;
 
         vv = (v << 1) & 0xfefefefefefefefe;
         vv ^= galois_double_mask64(v) & 0x1d1d1d1d1d1d1d1d;
-        *((UINT64*)data) = vv;
+        *((uint64_t*)data) = vv;
 
-        data += sizeof(UINT64);
-        len -= sizeof(UINT64);
+        data += sizeof(uint64_t);
+        len -= sizeof(uint64_t);
     }
 #else
-    while (len > sizeof(UINT32)) {
-        UINT32 v = *((UINT32*)data), vv;
+    while (len > sizeof(uint32_t)) {
+        uint32_t v = *((uint32_t*)data), vv;
 
         vv = (v << 1) & 0xfefefefe;
         vv ^= galois_double_mask32(v) & 0x1d1d1d1d;
-        *((UINT32*)data) = vv;
+        *((uint32_t*)data) = vv;
 
-        data += sizeof(UINT32);
-        len -= sizeof(UINT32);
+        data += sizeof(uint32_t);
+        len -= sizeof(uint32_t);
     }
 #endif
 
diff --git a/drivers/filesystems/btrfs/pnp.c b/drivers/filesystems/btrfs/pnp.c
index e122f72e13a..2b012ed002c 100644
--- a/drivers/filesystems/btrfs/pnp.c
+++ b/drivers/filesystems/btrfs/pnp.c
@@ -38,11 +38,7 @@ extern ERESOURCE pdo_list_lock;
 extern LIST_ENTRY pdo_list;
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI pnp_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#else
-static NTSTATUS pnp_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#endif
+static NTSTATUS __stdcall pnp_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
     pnp_stripe* stripe = conptr;
     pnp_context* context = (pnp_context*)stripe->context;
 
@@ -53,7 +49,7 @@ static NTSTATUS pnp_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conp
     InterlockedDecrement(&context->left);
 
     if (context->left == 0)
-        KeSetEvent(&context->Event, 0, FALSE);
+        KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
@@ -65,7 +61,7 @@ static NTSTATUS send_disks_pnp_message(device_extension* Vcb, UCHAR minor) {
     LIST_ENTRY* le;
 
     RtlZeroMemory(&context, sizeof(pnp_context));
-    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&context.Event, NotificationEvent, false);
 
     num_devices = (ULONG)min(0xffffffff, Vcb->superblock.num_devices);
 
@@ -87,10 +83,10 @@ static NTSTATUS send_disks_pnp_message(device_extension* Vcb, UCHAR minor) {
         if (dev->devobj) {
             context.stripes[i].context = (struct pnp_context*)&context;
 
-            context.stripes[i].Irp = IoAllocateIrp(dev->devobj->StackSize, FALSE);
+            context.stripes[i].Irp = IoAllocateIrp(dev->devobj->StackSize, false);
 
             if (!context.stripes[i].Irp) {
-                UINT64 j;
+                uint64_t j;
 
                 ERR("IoAllocateIrp failed\n");
 
@@ -107,10 +103,11 @@ static NTSTATUS send_disks_pnp_message(device_extension* Vcb, UCHAR minor) {
             IrpSp = IoGetNextIrpStackLocation(context.stripes[i].Irp);
             IrpSp->MajorFunction = IRP_MJ_PNP;
             IrpSp->MinorFunction = minor;
+            IrpSp->FileObject = dev->fileobj;
 
             context.stripes[i].Irp->UserIosb = &context.stripes[i].iosb;
 
-            IoSetCompletionRoutine(context.stripes[i].Irp, pnp_completion, &context.stripes[i], TRUE, TRUE, TRUE);
+            IoSetCompletionRoutine(context.stripes[i].Irp, pnp_completion, &context.stripes[i], true, true, true);
 
             context.stripes[i].Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
             context.stripes[i].dev = dev;
@@ -132,7 +129,7 @@ static NTSTATUS send_disks_pnp_message(device_extension* Vcb, UCHAR minor) {
         }
     }
 
-    KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+    KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
 
     Status = STATUS_SUCCESS;
 
@@ -159,9 +156,9 @@ static NTSTATUS pnp_cancel_remove_device(PDEVICE_OBJECT DeviceObject) {
     device_extension* Vcb = DeviceObject->DeviceExtension;
     NTSTATUS Status;
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
-    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, true);
 
     if (Vcb->root_fileref && Vcb->root_fileref->fcb && (Vcb->root_fileref->open_count > 0 || has_open_children(Vcb->root_fileref))) {
         Status = STATUS_ACCESS_DENIED;
@@ -185,7 +182,7 @@ NTSTATUS pnp_query_remove_device(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
     device_extension* Vcb = DeviceObject->DeviceExtension;
     NTSTATUS Status;
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     if (Vcb->root_fileref && Vcb->root_fileref->fcb && (Vcb->root_fileref->open_count > 0 || has_open_children(Vcb->root_fileref))) {
         Status = STATUS_ACCESS_DENIED;
@@ -198,7 +195,7 @@ NTSTATUS pnp_query_remove_device(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
         goto end;
     }
 
-    Vcb->removing = TRUE;
+    Vcb->removing = true;
 
     if (Vcb->need_write && !Vcb->readonly) {
         Status = do_write(Vcb, Irp);
@@ -223,7 +220,7 @@ static NTSTATUS pnp_remove_device(PDEVICE_OBJECT DeviceObject) {
     device_extension* Vcb = DeviceObject->DeviceExtension;
     NTSTATUS Status;
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
     Status = send_disks_pnp_message(Vcb, IRP_MN_REMOVE_DEVICE);
 
@@ -241,8 +238,8 @@ static NTSTATUS pnp_remove_device(PDEVICE_OBJECT DeviceObject) {
         if (Vcb->vde)
             Vcb->vde->mounted_device = NULL;
 
-        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
-        Vcb->removing = TRUE;
+        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
+        Vcb->removing = true;
         ExReleaseResourceLite(&Vcb->tree_lock);
 
         if (Vcb->open_files == 0)
@@ -258,12 +255,12 @@ NTSTATUS pnp_surprise_removal(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
     TRACE("(%p, %p)\n", DeviceObject, Irp);
 
     if (DeviceObject->Vpb->Flags & VPB_MOUNTED) {
-        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
         if (Vcb->vde)
             Vcb->vde->mounted_device = NULL;
 
-        Vcb->removing = TRUE;
+        Vcb->removing = true;
 
         ExReleaseResourceLite(&Vcb->tree_lock);
 
@@ -274,14 +271,14 @@ NTSTATUS pnp_surprise_removal(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
     return STATUS_SUCCESS;
 }
 
-static void bus_query_capabilities(PIRP Irp) {
+static NTSTATUS bus_query_capabilities(PIRP Irp) {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     PDEVICE_CAPABILITIES dc = IrpSp->Parameters.DeviceCapabilities.Capabilities;
 
-    dc->UniqueID = TRUE;
-    dc->SilentInstall = TRUE;
+    dc->UniqueID = true;
+    dc->SilentInstall = true;
 
-    Irp->IoStatus.Status = STATUS_SUCCESS;
+    return STATUS_SUCCESS;
 }
 
 static NTSTATUS bus_query_device_relations(PIRP Irp) {
@@ -291,7 +288,7 @@ static NTSTATUS bus_query_device_relations(PIRP Irp) {
     ULONG drsize, i;
     DEVICE_RELATIONS* dr;
 
-    ExAcquireResourceSharedLite(&pdo_list_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdo_list_lock, true);
 
     num_children = 0;
 
@@ -332,9 +329,6 @@ static NTSTATUS bus_query_device_relations(PIRP Irp) {
 end:
     ExReleaseResourceLite(&pdo_list_lock);
 
-    Irp->IoStatus.Status = Status;
-    IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
     return Status;
 }
 
@@ -356,38 +350,45 @@ static NTSTATUS bus_query_hardware_ids(PIRP Irp) {
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS bus_pnp(control_device_extension* cde, PIRP Irp) {
+static NTSTATUS bus_pnp(bus_device_extension* bde, PIRP Irp) {
+    NTSTATUS Status = Irp->IoStatus.Status;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
+    bool handled = false;
 
     switch (IrpSp->MinorFunction) {
         case IRP_MN_QUERY_CAPABILITIES:
-            bus_query_capabilities(Irp);
+            Status = bus_query_capabilities(Irp);
+            handled = true;
             break;
 
         case IRP_MN_QUERY_DEVICE_RELATIONS:
             if (IrpSp->Parameters.QueryDeviceRelations.Type != BusRelations || no_pnp)
                 break;
 
-            return bus_query_device_relations(Irp);
+            Status = bus_query_device_relations(Irp);
+            handled = true;
+            break;
 
         case IRP_MN_QUERY_ID:
-        {
-            NTSTATUS Status;
-
             if (IrpSp->Parameters.QueryId.IdType != BusQueryHardwareIDs)
                 break;
 
             Status = bus_query_hardware_ids(Irp);
+            handled = true;
+            break;
+    }
 
-            Irp->IoStatus.Status = Status;
-            IoCompleteRequest(Irp, IO_NO_INCREMENT);
+    if (!NT_SUCCESS(Status) && handled) {
+        Irp->IoStatus.Status = Status;
+        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
-            return Status;
-        }
+        return Status;
     }
 
+    Irp->IoStatus.Status = Status;
+
     IoSkipCurrentIrpStackLocation(Irp);
-    return IoCallDriver(cde->attached_device, Irp);
+    return IoCallDriver(bde->attached_device, Irp);
 }
 
 static NTSTATUS pdo_query_device_id(pdo_device_extension* pdode, PIRP Irp) {
@@ -460,6 +461,84 @@ static NTSTATUS pdo_query_id(pdo_device_extension* pdode, PIRP Irp) {
     return Irp->IoStatus.Status;
 }
 
+typedef struct {
+    IO_STATUS_BLOCK iosb;
+    KEVENT Event;
+    NTSTATUS Status;
+} device_usage_context;
+
+_Function_class_(IO_COMPLETION_ROUTINE)
+static NTSTATUS __stdcall device_usage_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
+    device_usage_context* context = conptr;
+
+    UNUSED(DeviceObject);
+
+    context->Status = Irp->IoStatus.Status;
+
+    KeSetEvent(&context->Event, 0, false);
+
+    return STATUS_MORE_PROCESSING_REQUIRED;
+}
+
+static NTSTATUS pdo_device_usage_notification(pdo_device_extension* pdode, PIRP Irp) {
+    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
+    LIST_ENTRY* le;
+
+    TRACE("(%p, %p)\n", pdode, Irp);
+
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
+
+    le = pdode->children.Flink;
+
+    while (le != &pdode->children) {
+        volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
+
+        if (vc->devobj) {
+            PIRP Irp2;
+            PIO_STACK_LOCATION IrpSp2;
+            device_usage_context context;
+
+            Irp2 = IoAllocateIrp(vc->devobj->StackSize, false);
+            if (!Irp2) {
+                ERR("out of memory\n");
+                ExReleaseResourceLite(&pdode->child_lock);
+                return STATUS_INSUFFICIENT_RESOURCES;
+            }
+
+            IrpSp2 = IoGetNextIrpStackLocation(Irp2);
+            IrpSp2->MajorFunction = IRP_MJ_PNP;
+            IrpSp2->MinorFunction = IRP_MN_DEVICE_USAGE_NOTIFICATION;
+            IrpSp2->Parameters.UsageNotification = IrpSp->Parameters.UsageNotification;
+            IrpSp2->FileObject = vc->fileobj;
+
+            context.iosb.Status = STATUS_SUCCESS;
+            Irp2->UserIosb = &context.iosb;
+
+            KeInitializeEvent(&context.Event, NotificationEvent, false);
+            Irp2->UserEvent = &context.Event;
+
+            IoSetCompletionRoutine(Irp2, device_usage_completion, &context, true, true, true);
+
+            context.Status = IoCallDriver(vc->devobj, Irp2);
+
+            if (context.Status == STATUS_PENDING)
+                KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
+
+            if (!NT_SUCCESS(context.Status)) {
+                ERR("IoCallDriver returned %08x\n", context.Status);
+                ExReleaseResourceLite(&pdode->child_lock);
+                return context.Status;
+            }
+        }
+
+        le = le->Flink;
+    }
+
+    ExReleaseResourceLite(&pdode->child_lock);
+
+    return STATUS_SUCCESS;
+}
+
 static NTSTATUS pdo_pnp(PDEVICE_OBJECT pdo, PIRP Irp) {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     pdo_device_extension* pdode = pdo->DeviceExtension;
@@ -476,30 +555,55 @@ static NTSTATUS pdo_pnp(PDEVICE_OBJECT pdo, PIRP Irp) {
 
         case IRP_MN_QUERY_REMOVE_DEVICE:
             return STATUS_UNSUCCESSFUL;
+
+        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
+            return pdo_device_usage_notification(pdode, Irp);
+
     }
 
     return Irp->IoStatus.Status;
 }
 
+static NTSTATUS pnp_device_usage_notification(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
+    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
+    device_extension* Vcb = DeviceObject->DeviceExtension;
+
+    if (IrpSp->Parameters.UsageNotification.InPath) {
+        switch (IrpSp->Parameters.UsageNotification.Type) {
+            case DeviceUsageTypePaging:
+            case DeviceUsageTypeHibernation:
+            case DeviceUsageTypeDumpFile:
+                IoAdjustPagingPathCount(&Vcb->page_file_count, IrpSp->Parameters.UsageNotification.InPath);
+                break;
+
+            default:
+                break;
+        }
+    }
+
+    IoSkipCurrentIrpStackLocation(Irp);
+    return IoCallDriver(Vcb->Vpb->RealDevice, Irp);
+}
+
 _Dispatch_type_(IRP_MJ_PNP)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_pnp(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
+NTSTATUS __stdcall drv_pnp(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     device_extension* Vcb = DeviceObject->DeviceExtension;
     NTSTATUS Status;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
     top_level = is_top_level(Irp);
 
-    if (Vcb && Vcb->type == VCB_TYPE_CONTROL) {
+    if (Vcb && Vcb->type == VCB_TYPE_BUS) {
         Status = bus_pnp(DeviceObject->DeviceExtension, Irp);
         goto exit;
     } else if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
         volume_device_extension* vde = DeviceObject->DeviceExtension;
         IoSkipCurrentIrpStackLocation(Irp);
-        Status = IoCallDriver(vde->pdo, Irp);
+        Status = IoCallDriver(vde->attached_device, Irp);
         goto exit;
     } else if (Vcb && Vcb->type == VCB_TYPE_PDO) {
         Status = pdo_pnp(DeviceObject, Irp);
@@ -528,6 +632,10 @@ NTSTATUS NTAPI drv_pnp(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
             Status = pnp_surprise_removal(DeviceObject, Irp);
             break;
 
+        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
+            Status = pnp_device_usage_notification(DeviceObject, Irp);
+            goto exit;
+
         default:
             TRACE("passing minor function 0x%x on\n", IrpSp->MinorFunction);
 
diff --git a/drivers/filesystems/btrfs/read.c b/drivers/filesystems/btrfs/read.c
index 1abfbf48f61..5934821beb2 100644
--- a/drivers/filesystems/btrfs/read.c
+++ b/drivers/filesystems/btrfs/read.c
@@ -29,45 +29,41 @@ struct read_data_context;
 
 typedef struct {
     struct read_data_context* context;
-    UINT16 stripenum;
-    BOOL rewrite;
+    uint16_t stripenum;
+    bool rewrite;
     PIRP Irp;
     IO_STATUS_BLOCK iosb;
     enum read_data_status status;
     PMDL mdl;
-    UINT64 stripestart;
-    UINT64 stripeend;
+    uint64_t stripestart;
+    uint64_t stripeend;
 } read_data_stripe;
 
 typedef struct {
     KEVENT Event;
     NTSTATUS Status;
     chunk* c;
-    UINT64 address;
-    UINT32 buflen;
+    uint64_t address;
+    uint32_t buflen;
     LONG num_stripes, stripes_left;
-    UINT64 type;
-    UINT32 sector_size;
-    UINT16 firstoff, startoffstripe, sectors_per_stripe;
-    UINT32* csum;
-    BOOL tree;
+    uint64_t type;
+    uint32_t sector_size;
+    uint16_t firstoff, startoffstripe, sectors_per_stripe;
+    uint32_t* csum;
+    bool tree;
     read_data_stripe* stripes;
-    UINT8* va;
+    uint8_t* va;
 } read_data_context;
 
-extern BOOL diskacc;
+extern bool diskacc;
 extern tPsUpdateDiskCounters fPsUpdateDiskCounters;
 extern tCcCopyReadEx fCcCopyReadEx;
 extern tFsRtlUpdateDiskCounters fFsRtlUpdateDiskCounters;
 
-#define LINUX_PAGE_SIZE 4096
+#define LZO_PAGE_SIZE 4096
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI read_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#else
-static NTSTATUS read_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#endif
+static NTSTATUS __stdcall read_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
     read_data_stripe* stripe = conptr;
     read_data_context* context = (read_data_context*)stripe->context;
 
@@ -81,24 +77,24 @@ static NTSTATUS read_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOI
         stripe->status = ReadDataStatus_Error;
 
     if (InterlockedDecrement(&context->stripes_left) == 0)
-        KeSetEvent(&context->Event, 0, FALSE);
+        KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
 
-NTSTATUS check_csum(device_extension* Vcb, UINT8* data, UINT32 sectors, UINT32* csum) {
+NTSTATUS check_csum(device_extension* Vcb, uint8_t* data, uint32_t sectors, uint32_t* csum) {
     NTSTATUS Status;
     calc_job* cj;
-    UINT32* csum2;
+    uint32_t* csum2;
 
     // From experimenting, it seems that 40 sectors is roughly the crossover
     // point where offloading the crc32 calculation becomes worth it.
 
-    if (sectors < 40 || KeQueryActiveProcessorCount(NULL) < 2) {
+    if (sectors < 40 || get_num_of_processors() < 2) {
         ULONG j;
 
         for (j = 0; j < sectors; j++) {
-            UINT32 crc32 = ~calc_crc32c(0xffffffff, data + (j * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
+            uint32_t crc32 = ~calc_crc32c(0xffffffff, data + (j * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
             if (crc32 != csum[j]) {
                 return STATUS_CRC_ERROR;
@@ -108,7 +104,7 @@ NTSTATUS check_csum(device_extension* Vcb, UINT8* data, UINT32 sectors, UINT32*
         return STATUS_SUCCESS;
     }
 
-    csum2 = ExAllocatePoolWithTag(PagedPool, sizeof(UINT32) * sectors, ALLOC_TAG);
+    csum2 = ExAllocatePoolWithTag(PagedPool, sizeof(uint32_t) * sectors, ALLOC_TAG);
     if (!csum2) {
         ERR("out of memory\n");
         return STATUS_INSUFFICIENT_RESOURCES;
@@ -121,9 +117,9 @@ NTSTATUS check_csum(device_extension* Vcb, UINT8* data, UINT32 sectors, UINT32*
         return Status;
     }
 
-    KeWaitForSingleObject(&cj->event, Executive, KernelMode, FALSE, NULL);
+    KeWaitForSingleObject(&cj->event, Executive, KernelMode, false, NULL);
 
-    if (RtlCompareMemory(csum2, csum, sectors * sizeof(UINT32)) != sectors * sizeof(UINT32)) {
+    if (RtlCompareMemory(csum2, csum, sectors * sizeof(uint32_t)) != sectors * sizeof(uint32_t)) {
         free_calc_job(cj);
         ExFreePool(csum2);
         return STATUS_CRC_ERROR;
@@ -135,11 +131,11 @@ NTSTATUS check_csum(device_extension* Vcb, UINT8* data, UINT32 sectors, UINT32*
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS read_data_dup(device_extension* Vcb, UINT8* buf, UINT64 addr, read_data_context* context, CHUNK_ITEM* ci,
-                              device** devices, UINT64 generation) {
+static NTSTATUS read_data_dup(device_extension* Vcb, uint8_t* buf, uint64_t addr, read_data_context* context, CHUNK_ITEM* ci,
+                              device** devices, uint64_t generation) {
     ULONG i;
-    BOOL checksum_error = FALSE;
-    UINT16 j, stripe = 0;
+    bool checksum_error = false;
+    uint16_t j, stripe = 0;
     NTSTATUS Status;
     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&ci[1];
 
@@ -159,37 +155,27 @@ static NTSTATUS read_data_dup(device_extension* Vcb, UINT8* buf, UINT64 addr, re
 
     if (context->tree) {
         tree_header* th = (tree_header*)buf;
-        UINT32 crc32;
+        uint32_t crc32;
 
-        crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, context->buflen - sizeof(th->csum));
+        crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, context->buflen - sizeof(th->csum));
 
-        if (th->address != context->address || crc32 != *((UINT32*)th->csum)) {
-            checksum_error = TRUE;
+        if (th->address != context->address || crc32 != *((uint32_t*)th->csum)) {
+            checksum_error = true;
             log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
         } else if (generation != 0 && th->generation != generation) {
-            checksum_error = TRUE;
+            checksum_error = true;
             log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_GENERATION_ERRORS);
         }
     } else if (context->csum) {
-#ifdef DEBUG_STATS
-        LARGE_INTEGER time1, time2;
-
-        time1 = KeQueryPerformanceCounter(NULL);
-#endif
         Status = check_csum(Vcb, buf, (ULONG)context->stripes[stripe].Irp->IoStatus.Information / context->sector_size, context->csum);
 
         if (Status == STATUS_CRC_ERROR) {
-            checksum_error = TRUE;
+            checksum_error = true;
             log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
         } else if (!NT_SUCCESS(Status)) {
             ERR("check_csum returned %08x\n", Status);
             return Status;
         }
-#ifdef DEBUG_STATS
-        time2 = KeQueryPerformanceCounter(NULL);
-
-        Vcb->stats.read_csum_time += time2.QuadPart - time1.QuadPart;
-#endif
     }
 
     if (!checksum_error)
@@ -200,7 +186,7 @@ static NTSTATUS read_data_dup(device_extension* Vcb, UINT8* buf, UINT64 addr, re
 
     if (context->tree) {
         tree_header* t2;
-        BOOL recovered = FALSE;
+        bool recovered = false;
 
         t2 = ExAllocatePoolWithTag(NonPagedPool, Vcb->superblock.node_size, ALLOC_TAG);
         if (!t2) {
@@ -210,20 +196,21 @@ static NTSTATUS read_data_dup(device_extension* Vcb, UINT8* buf, UINT64 addr, re
 
         for (j = 0; j < ci->num_stripes; j++) {
             if (j != stripe && devices[j] && devices[j]->devobj) {
-                Status = sync_read_phys(devices[j]->devobj, cis[j].offset + context->stripes[stripe].stripestart, Vcb->superblock.node_size, (UINT8*)t2, FALSE);
+                Status = sync_read_phys(devices[j]->devobj, devices[j]->fileobj, cis[j].offset + context->stripes[stripe].stripestart,
+                                        Vcb->superblock.node_size, (uint8_t*)t2, false);
                 if (!NT_SUCCESS(Status)) {
                     WARN("sync_read_phys returned %08x\n", Status);
                     log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_READ_ERRORS);
                 } else {
-                    UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&t2->fs_uuid, Vcb->superblock.node_size - sizeof(t2->csum));
+                    uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&t2->fs_uuid, Vcb->superblock.node_size - sizeof(t2->csum));
 
-                    if (t2->address == addr && crc32 == *((UINT32*)t2->csum) && (generation == 0 || t2->generation == generation)) {
+                    if (t2->address == addr && crc32 == *((uint32_t*)t2->csum) && (generation == 0 || t2->generation == generation)) {
                         RtlCopyMemory(buf, t2, Vcb->superblock.node_size);
-                        ERR("recovering from checksum error at %llx, device %llx\n", addr, devices[stripe]->devitem.dev_id);
-                        recovered = TRUE;
+                        ERR("recovering from checksum error at %I64x, device %I64x\n", addr, devices[stripe]->devitem.dev_id);
+                        recovered = true;
 
                         if (!Vcb->readonly && !devices[stripe]->readonly) { // write good data over bad
-                            Status = write_data_phys(devices[stripe]->devobj, cis[stripe].offset + context->stripes[stripe].stripestart,
+                            Status = write_data_phys(devices[stripe]->devobj, devices[stripe]->fileobj, cis[stripe].offset + context->stripes[stripe].stripestart,
                                                      t2, Vcb->superblock.node_size);
                             if (!NT_SUCCESS(Status)) {
                                 WARN("write_data_phys returned %08x\n", Status);
@@ -232,7 +219,7 @@ static NTSTATUS read_data_dup(device_extension* Vcb, UINT8* buf, UINT64 addr, re
                         }
 
                         break;
-                    } else if (t2->address != addr || crc32 != *((UINT32*)t2->csum))
+                    } else if (t2->address != addr || crc32 != *((uint32_t*)t2->csum))
                         log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                     else
                         log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_GENERATION_ERRORS);
@@ -241,7 +228,7 @@ static NTSTATUS read_data_dup(device_extension* Vcb, UINT8* buf, UINT64 addr, re
         }
 
         if (!recovered) {
-            ERR("unrecoverable checksum error at %llx\n", addr);
+            ERR("unrecoverable checksum error at %I64x\n", addr);
             ExFreePool(t2);
             return STATUS_CRC_ERROR;
         }
@@ -249,7 +236,7 @@ static NTSTATUS read_data_dup(device_extension* Vcb, UINT8* buf, UINT64 addr, re
         ExFreePool(t2);
     } else {
         ULONG sectors = (ULONG)context->stripes[stripe].Irp->IoStatus.Information / Vcb->superblock.sector_size;
-        UINT8* sector;
+        uint8_t* sector;
 
         sector = ExAllocatePoolWithTag(NonPagedPool, Vcb->superblock.sector_size, ALLOC_TAG);
         if (!sector) {
@@ -258,28 +245,30 @@ static NTSTATUS read_data_dup(device_extension* Vcb, UINT8* buf, UINT64 addr, re
         }
 
         for (i = 0; i < sectors; i++) {
-            UINT32 crc32 = ~calc_crc32c(0xffffffff, buf + (i * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
+            uint32_t crc32 = ~calc_crc32c(0xffffffff, buf + (i * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
             if (context->csum[i] != crc32) {
-                BOOL recovered = FALSE;
+                bool recovered = false;
 
                 for (j = 0; j < ci->num_stripes; j++) {
                     if (j != stripe && devices[j] && devices[j]->devobj) {
-                        Status = sync_read_phys(devices[j]->devobj, cis[j].offset + context->stripes[stripe].stripestart + UInt32x32To64(i, Vcb->superblock.sector_size),
-                                                Vcb->superblock.sector_size, sector, FALSE);
+                        Status = sync_read_phys(devices[j]->devobj, devices[j]->fileobj,
+                                                cis[j].offset + context->stripes[stripe].stripestart + UInt32x32To64(i, Vcb->superblock.sector_size),
+                                                Vcb->superblock.sector_size, sector, false);
                         if (!NT_SUCCESS(Status)) {
                             WARN("sync_read_phys returned %08x\n", Status);
                             log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_READ_ERRORS);
                         } else {
-                            UINT32 crc32b = ~calc_crc32c(0xffffffff, sector, Vcb->superblock.sector_size);
+                            uint32_t crc32b = ~calc_crc32c(0xffffffff, sector, Vcb->superblock.sector_size);
 
                             if (crc32b == context->csum[i]) {
                                 RtlCopyMemory(buf + (i * Vcb->superblock.sector_size), sector, Vcb->superblock.sector_size);
-                                ERR("recovering from checksum error at %llx, device %llx\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size), devices[stripe]->devitem.dev_id);
-                                recovered = TRUE;
+                                ERR("recovering from checksum error at %I64x, device %I64x\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size), devices[stripe]->devitem.dev_id);
+                                recovered = true;
 
                                 if (!Vcb->readonly && !devices[stripe]->readonly) { // write good data over bad
-                                    Status = write_data_phys(devices[stripe]->devobj, cis[stripe].offset + context->stripes[stripe].stripestart + UInt32x32To64(i, Vcb->superblock.sector_size),
+                                    Status = write_data_phys(devices[stripe]->devobj, devices[stripe]->fileobj,
+                                                             cis[stripe].offset + context->stripes[stripe].stripestart + UInt32x32To64(i, Vcb->superblock.sector_size),
                                                              sector, Vcb->superblock.sector_size);
                                     if (!NT_SUCCESS(Status)) {
                                         WARN("write_data_phys returned %08x\n", Status);
@@ -295,7 +284,7 @@ static NTSTATUS read_data_dup(device_extension* Vcb, UINT8* buf, UINT64 addr, re
                 }
 
                 if (!recovered) {
-                    ERR("unrecoverable checksum error at %llx\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size));
+                    ERR("unrecoverable checksum error at %I64x\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size));
                     ExFreePool(sector);
                     return STATUS_CRC_ERROR;
                 }
@@ -308,13 +297,13 @@ static NTSTATUS read_data_dup(device_extension* Vcb, UINT8* buf, UINT64 addr, re
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS read_data_raid0(device_extension* Vcb, UINT8* buf, UINT64 addr, UINT32 length, read_data_context* context,
-                                CHUNK_ITEM* ci, device** devices, UINT64 generation, UINT64 offset) {
-    UINT64 i;
+static NTSTATUS read_data_raid0(device_extension* Vcb, uint8_t* buf, uint64_t addr, uint32_t length, read_data_context* context,
+                                CHUNK_ITEM* ci, device** devices, uint64_t generation, uint64_t offset) {
+    uint64_t i;
 
     for (i = 0; i < ci->num_stripes; i++) {
         if (context->stripes[i].status == ReadDataStatus_Error) {
-            WARN("stripe %llu returned error %08x\n", i, context->stripes[i].iosb.Status);
+            WARN("stripe %I64u returned error %08x\n", i, context->stripes[i].iosb.Status);
             log_device_error(Vcb, devices[i], BTRFS_DEV_STAT_READ_ERRORS);
             return context->stripes[i].iosb.Status;
         }
@@ -322,50 +311,46 @@ static NTSTATUS read_data_raid0(device_extension* Vcb, UINT8* buf, UINT64 addr,
 
     if (context->tree) { // shouldn't happen, as trees shouldn't cross stripe boundaries
         tree_header* th = (tree_header*)buf;
-        UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+        uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-        if (crc32 != *((UINT32*)th->csum) || addr != th->address || (generation != 0 && generation != th->generation)) {
-            UINT64 off;
-            UINT16 stripe;
+        if (crc32 != *((uint32_t*)th->csum) || addr != th->address || (generation != 0 && generation != th->generation)) {
+            uint64_t off;
+            uint16_t stripe;
 
             get_raid0_offset(addr - offset, ci->stripe_length, ci->num_stripes, &off, &stripe);
 
-            ERR("unrecoverable checksum error at %llx, device %llx\n", addr, devices[stripe]->devitem.dev_id);
+            ERR("unrecoverable checksum error at %I64x, device %I64x\n", addr, devices[stripe]->devitem.dev_id);
 
-            if (crc32 != *((UINT32*)th->csum)) {
-                WARN("crc32 was %08x, expected %08x\n", crc32, *((UINT32*)th->csum));
+            if (crc32 != *((uint32_t*)th->csum)) {
+                WARN("crc32 was %08x, expected %08x\n", crc32, *((uint32_t*)th->csum));
                 log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                 return STATUS_CRC_ERROR;
             } else if (addr != th->address) {
-                WARN("address of tree was %llx, not %llx as expected\n", th->address, addr);
+                WARN("address of tree was %I64x, not %I64x as expected\n", th->address, addr);
                 log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                 return STATUS_CRC_ERROR;
             } else if (generation != 0 && generation != th->generation) {
-                WARN("generation of tree was %llx, not %llx as expected\n", th->generation, generation);
+                WARN("generation of tree was %I64x, not %I64x as expected\n", th->generation, generation);
                 log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_GENERATION_ERRORS);
                 return STATUS_CRC_ERROR;
             }
         }
     } else if (context->csum) {
         NTSTATUS Status;
-#ifdef DEBUG_STATS
-        LARGE_INTEGER time1, time2;
 
-        time1 = KeQueryPerformanceCounter(NULL);
-#endif
         Status = check_csum(Vcb, buf, length / Vcb->superblock.sector_size, context->csum);
 
         if (Status == STATUS_CRC_ERROR) {
             for (i = 0; i < length / Vcb->superblock.sector_size; i++) {
-                UINT32 crc32 = ~calc_crc32c(0xffffffff, buf + (i * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
+                uint32_t crc32 = ~calc_crc32c(0xffffffff, buf + (i * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
                 if (context->csum[i] != crc32) {
-                    UINT64 off;
-                    UINT16 stripe;
+                    uint64_t off;
+                    uint16_t stripe;
 
                     get_raid0_offset(addr - offset + UInt32x32To64(i, Vcb->superblock.sector_size), ci->stripe_length, ci->num_stripes, &off, &stripe);
 
-                    ERR("unrecoverable checksum error at %llx, device %llx\n", addr, devices[stripe]->devitem.dev_id);
+                    ERR("unrecoverable checksum error at %I64x, device %I64x\n", addr, devices[stripe]->devitem.dev_id);
 
                     log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
 
@@ -378,27 +363,22 @@ static NTSTATUS read_data_raid0(device_extension* Vcb, UINT8* buf, UINT64 addr,
             ERR("check_csum returned %08x\n", Status);
             return Status;
         }
-#ifdef DEBUG_STATS
-        time2 = KeQueryPerformanceCounter(NULL);
-
-        Vcb->stats.read_csum_time += time2.QuadPart - time1.QuadPart;
-#endif
     }
 
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr, UINT32 length, read_data_context* context,
-                                 CHUNK_ITEM* ci, device** devices, UINT64 generation, UINT64 offset) {
-    UINT64 i;
-    UINT16 j, stripe;
+static NTSTATUS read_data_raid10(device_extension* Vcb, uint8_t* buf, uint64_t addr, uint32_t length, read_data_context* context,
+                                 CHUNK_ITEM* ci, device** devices, uint64_t generation, uint64_t offset) {
+    uint64_t i;
+    uint16_t j, stripe;
     NTSTATUS Status;
-    BOOL checksum_error = FALSE;
+    bool checksum_error = false;
     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&ci[1];
 
     for (j = 0; j < ci->num_stripes; j++) {
         if (context->stripes[j].status == ReadDataStatus_Error) {
-            WARN("stripe %llu returned error %08x\n", j, context->stripes[j].iosb.Status);
+            WARN("stripe %I64u returned error %08x\n", j, context->stripes[j].iosb.Status);
             log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_READ_ERRORS);
             return context->stripes[j].iosb.Status;
         } else if (context->stripes[j].status == ReadDataStatus_Success)
@@ -407,40 +387,30 @@ static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr,
 
     if (context->tree) {
         tree_header* th = (tree_header*)buf;
-        UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+        uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-        if (crc32 != *((UINT32*)th->csum)) {
-            WARN("crc32 was %08x, expected %08x\n", crc32, *((UINT32*)th->csum));
-            checksum_error = TRUE;
+        if (crc32 != *((uint32_t*)th->csum)) {
+            WARN("crc32 was %08x, expected %08x\n", crc32, *((uint32_t*)th->csum));
+            checksum_error = true;
             log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
         } else if (addr != th->address) {
-            WARN("address of tree was %llx, not %llx as expected\n", th->address, addr);
-            checksum_error = TRUE;
+            WARN("address of tree was %I64x, not %I64x as expected\n", th->address, addr);
+            checksum_error = true;
             log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
         } else if (generation != 0 && generation != th->generation) {
-            WARN("generation of tree was %llx, not %llx as expected\n", th->generation, generation);
-            checksum_error = TRUE;
+            WARN("generation of tree was %I64x, not %I64x as expected\n", th->generation, generation);
+            checksum_error = true;
             log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_GENERATION_ERRORS);
         }
     } else if (context->csum) {
-#ifdef DEBUG_STATS
-        LARGE_INTEGER time1, time2;
-
-        time1 = KeQueryPerformanceCounter(NULL);
-#endif
         Status = check_csum(Vcb, buf, length / Vcb->superblock.sector_size, context->csum);
 
         if (Status == STATUS_CRC_ERROR)
-            checksum_error = TRUE;
+            checksum_error = true;
         else if (!NT_SUCCESS(Status)) {
             ERR("check_csum returned %08x\n", Status);
             return Status;
         }
-#ifdef DEBUG_STATS
-        time2 = KeQueryPerformanceCounter(NULL);
-
-        Vcb->stats.read_csum_time += time2.QuadPart - time1.QuadPart;
-#endif
     }
 
     if (!checksum_error)
@@ -448,9 +418,9 @@ static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr,
 
     if (context->tree) {
         tree_header* t2;
-        UINT64 off;
-        UINT16 badsubstripe = 0;
-        BOOL recovered = FALSE;
+        uint64_t off;
+        uint16_t badsubstripe = 0;
+        bool recovered = false;
 
         t2 = ExAllocatePoolWithTag(NonPagedPool, Vcb->superblock.node_size, ALLOC_TAG);
         if (!t2) {
@@ -471,22 +441,22 @@ static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr,
 
         for (j = 0; j < ci->sub_stripes; j++) {
             if (context->stripes[stripe + j].status != ReadDataStatus_Success && devices[stripe + j] && devices[stripe + j]->devobj) {
-                Status = sync_read_phys(devices[stripe + j]->devobj, cis[stripe + j].offset + off,
-                                        Vcb->superblock.node_size, (UINT8*)t2, FALSE);
+                Status = sync_read_phys(devices[stripe + j]->devobj, devices[stripe + j]->fileobj, cis[stripe + j].offset + off,
+                                        Vcb->superblock.node_size, (uint8_t*)t2, false);
                 if (!NT_SUCCESS(Status)) {
                     WARN("sync_read_phys returned %08x\n", Status);
                     log_device_error(Vcb, devices[stripe + j], BTRFS_DEV_STAT_READ_ERRORS);
                 } else {
-                    UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&t2->fs_uuid, Vcb->superblock.node_size - sizeof(t2->csum));
+                    uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&t2->fs_uuid, Vcb->superblock.node_size - sizeof(t2->csum));
 
-                    if (t2->address == addr && crc32 == *((UINT32*)t2->csum) && (generation == 0 || t2->generation == generation)) {
+                    if (t2->address == addr && crc32 == *((uint32_t*)t2->csum) && (generation == 0 || t2->generation == generation)) {
                         RtlCopyMemory(buf, t2, Vcb->superblock.node_size);
-                        ERR("recovering from checksum error at %llx, device %llx\n", addr, devices[stripe + j]->devitem.dev_id);
-                        recovered = TRUE;
+                        ERR("recovering from checksum error at %I64x, device %I64x\n", addr, devices[stripe + j]->devitem.dev_id);
+                        recovered = true;
 
                         if (!Vcb->readonly && !devices[stripe + badsubstripe]->readonly && devices[stripe + badsubstripe]->devobj) { // write good data over bad
-                            Status = write_data_phys(devices[stripe + badsubstripe]->devobj, cis[stripe + badsubstripe].offset + off,
-                                                     t2, Vcb->superblock.node_size);
+                            Status = write_data_phys(devices[stripe + badsubstripe]->devobj, devices[stripe + badsubstripe]->fileobj,
+                                                     cis[stripe + badsubstripe].offset + off, t2, Vcb->superblock.node_size);
                             if (!NT_SUCCESS(Status)) {
                                 WARN("write_data_phys returned %08x\n", Status);
                                 log_device_error(Vcb, devices[stripe + badsubstripe], BTRFS_DEV_STAT_WRITE_ERRORS);
@@ -494,7 +464,7 @@ static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr,
                         }
 
                         break;
-                    } else if (t2->address != addr || crc32 != *((UINT32*)t2->csum))
+                    } else if (t2->address != addr || crc32 != *((uint32_t*)t2->csum))
                         log_device_error(Vcb, devices[stripe + j], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                     else
                         log_device_error(Vcb, devices[stripe + j], BTRFS_DEV_STAT_GENERATION_ERRORS);
@@ -503,7 +473,7 @@ static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr,
         }
 
         if (!recovered) {
-            ERR("unrecoverable checksum error at %llx\n", addr);
+            ERR("unrecoverable checksum error at %I64x\n", addr);
             ExFreePool(t2);
             return STATUS_CRC_ERROR;
         }
@@ -511,7 +481,7 @@ static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr,
         ExFreePool(t2);
     } else {
         ULONG sectors = length / Vcb->superblock.sector_size;
-        UINT8* sector;
+        uint8_t* sector;
 
         sector = ExAllocatePoolWithTag(NonPagedPool, Vcb->superblock.sector_size, ALLOC_TAG);
         if (!sector) {
@@ -520,12 +490,12 @@ static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr,
         }
 
         for (i = 0; i < sectors; i++) {
-            UINT32 crc32 = ~calc_crc32c(0xffffffff, buf + (i * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
+            uint32_t crc32 = ~calc_crc32c(0xffffffff, buf + (i * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
             if (context->csum[i] != crc32) {
-                UINT64 off;
-                UINT16 stripe2, badsubstripe = 0;
-                BOOL recovered = FALSE;
+                uint64_t off;
+                uint16_t stripe2, badsubstripe = 0;
+                bool recovered = false;
 
                 get_raid0_offset(addr - offset + UInt32x32To64(i, Vcb->superblock.sector_size), ci->stripe_length,
                                  ci->num_stripes / ci->sub_stripes, &off, &stripe2);
@@ -543,22 +513,22 @@ static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr,
 
                 for (j = 0; j < ci->sub_stripes; j++) {
                     if (context->stripes[stripe2 + j].status != ReadDataStatus_Success && devices[stripe2 + j] && devices[stripe2 + j]->devobj) {
-                        Status = sync_read_phys(devices[stripe2 + j]->devobj, cis[stripe2 + j].offset + off,
-                                                Vcb->superblock.sector_size, sector, FALSE);
+                        Status = sync_read_phys(devices[stripe2 + j]->devobj, devices[stripe2 + j]->fileobj, cis[stripe2 + j].offset + off,
+                                                Vcb->superblock.sector_size, sector, false);
                         if (!NT_SUCCESS(Status)) {
                             WARN("sync_read_phys returned %08x\n", Status);
                             log_device_error(Vcb, devices[stripe2 + j], BTRFS_DEV_STAT_READ_ERRORS);
                         } else {
-                            UINT32 crc32b = ~calc_crc32c(0xffffffff, sector, Vcb->superblock.sector_size);
+                            uint32_t crc32b = ~calc_crc32c(0xffffffff, sector, Vcb->superblock.sector_size);
 
                             if (crc32b == context->csum[i]) {
                                 RtlCopyMemory(buf + (i * Vcb->superblock.sector_size), sector, Vcb->superblock.sector_size);
-                                ERR("recovering from checksum error at %llx, device %llx\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size), devices[stripe2 + j]->devitem.dev_id);
-                                recovered = TRUE;
+                                ERR("recovering from checksum error at %I64x, device %I64x\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size), devices[stripe2 + j]->devitem.dev_id);
+                                recovered = true;
 
                                 if (!Vcb->readonly && !devices[stripe2 + badsubstripe]->readonly && devices[stripe2 + badsubstripe]->devobj) { // write good data over bad
-                                    Status = write_data_phys(devices[stripe2 + badsubstripe]->devobj, cis[stripe2 + badsubstripe].offset + off,
-                                                             sector, Vcb->superblock.sector_size);
+                                    Status = write_data_phys(devices[stripe2 + badsubstripe]->devobj, devices[stripe2 + badsubstripe]->fileobj,
+                                                             cis[stripe2 + badsubstripe].offset + off, sector, Vcb->superblock.sector_size);
                                     if (!NT_SUCCESS(Status)) {
                                         WARN("write_data_phys returned %08x\n", Status);
                                         log_device_error(Vcb, devices[stripe2 + badsubstripe], BTRFS_DEV_STAT_READ_ERRORS);
@@ -573,7 +543,7 @@ static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr,
                 }
 
                 if (!recovered) {
-                    ERR("unrecoverable checksum error at %llx\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size));
+                    ERR("unrecoverable checksum error at %I64x\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size));
                     ExFreePool(sector);
                     return STATUS_CRC_ERROR;
                 }
@@ -586,14 +556,14 @@ static NTSTATUS read_data_raid10(device_extension* Vcb, UINT8* buf, UINT64 addr,
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr, UINT32 length, read_data_context* context, CHUNK_ITEM* ci,
-                                device** devices, UINT64 offset, UINT64 generation, chunk* c, BOOL degraded) {
+static NTSTATUS read_data_raid5(device_extension* Vcb, uint8_t* buf, uint64_t addr, uint32_t length, read_data_context* context, CHUNK_ITEM* ci,
+                                device** devices, uint64_t offset, uint64_t generation, chunk* c, bool degraded) {
     ULONG i;
     NTSTATUS Status;
-    BOOL checksum_error = FALSE;
+    bool checksum_error = false;
     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&ci[1];
-    UINT16 j, stripe;
-    BOOL no_success = TRUE;
+    uint16_t j, stripe;
+    bool no_success = true;
 
     for (j = 0; j < ci->num_stripes; j++) {
         if (context->stripes[j].status == ReadDataStatus_Error) {
@@ -602,15 +572,15 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
             return context->stripes[j].iosb.Status;
         } else if (context->stripes[j].status == ReadDataStatus_Success) {
             stripe = j;
-            no_success = FALSE;
+            no_success = false;
         }
     }
 
     if (c) {    // check partial stripes
         LIST_ENTRY* le;
-        UINT64 ps_length = (ci->num_stripes - 1) * ci->stripe_length;
+        uint64_t ps_length = (ci->num_stripes - 1) * ci->stripe_length;
 
-        ExAcquireResourceSharedLite(&c->partial_stripes_lock, TRUE);
+        ExAcquireResourceSharedLite(&c->partial_stripes_lock, true);
 
         le = c->partial_stripes.Flink;
         while (le != &c->partial_stripes) {
@@ -622,10 +592,30 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
                 runlength = RtlFindFirstRunClear(&ps->bmp, &index);
 
                 while (runlength != 0) {
-                    UINT64 runstart = ps->address + (index * Vcb->superblock.sector_size);
-                    UINT64 runend = runstart + (runlength * Vcb->superblock.sector_size);
-                    UINT64 start = max(runstart, addr);
-                    UINT64 end = min(runend, addr + length);
+#ifdef __REACTOS__
+                    uint64_t runstart, runend, start, end;
+#endif
+                    if (index >= ps->bmplen)
+                        break;
+
+                    if (index + runlength >= ps->bmplen) {
+                        runlength = ps->bmplen - index;
+
+                        if (runlength == 0)
+                            break;
+                    }
+
+#ifndef __REACTOS__
+                    uint64_t runstart = ps->address + (index * Vcb->superblock.sector_size);
+                    uint64_t runend = runstart + (runlength * Vcb->superblock.sector_size);
+                    uint64_t start = max(runstart, addr);
+                    uint64_t end = min(runend, addr + length);
+#else
+                    runstart = ps->address + (index * Vcb->superblock.sector_size);
+                    runend = runstart + (runlength * Vcb->superblock.sector_size);
+                    start = max(runstart, addr);
+                    end = min(runend, addr + length);
+#endif
 
                     if (end > start)
                         RtlCopyMemory(buf + start - addr, &ps->data[start - ps->address], (ULONG)(end - start));
@@ -643,50 +633,39 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
 
     if (context->tree) {
         tree_header* th = (tree_header*)buf;
-        UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+        uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-        if (addr != th->address || crc32 != *((UINT32*)th->csum)) {
-            checksum_error = TRUE;
+        if (addr != th->address || crc32 != *((uint32_t*)th->csum)) {
+            checksum_error = true;
             if (!no_success && !degraded)
                 log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
         } else if (generation != 0 && generation != th->generation) {
-            checksum_error = TRUE;
+            checksum_error = true;
             if (!no_success && !degraded)
                 log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_GENERATION_ERRORS);
         }
     } else if (context->csum) {
-#ifdef DEBUG_STATS
-        LARGE_INTEGER time1, time2;
-
-        time1 = KeQueryPerformanceCounter(NULL);
-#endif
         Status = check_csum(Vcb, buf, length / Vcb->superblock.sector_size, context->csum);
 
         if (Status == STATUS_CRC_ERROR) {
             if (!degraded)
                 WARN("checksum error\n");
-            checksum_error = TRUE;
+            checksum_error = true;
         } else if (!NT_SUCCESS(Status)) {
             ERR("check_csum returned %08x\n", Status);
             return Status;
         }
-
-#ifdef DEBUG_STATS
-        time2 = KeQueryPerformanceCounter(NULL);
-
-        Vcb->stats.read_csum_time += time2.QuadPart - time1.QuadPart;
-#endif
     } else if (degraded)
-        checksum_error = TRUE;
+        checksum_error = true;
 
     if (!checksum_error)
         return STATUS_SUCCESS;
 
     if (context->tree) {
-        UINT16 parity;
-        UINT64 off;
-        BOOL recovered = FALSE, first = TRUE, failed = FALSE;
-        UINT8* t2;
+        uint16_t parity;
+        uint64_t off;
+        bool recovered = false, first = true, failed = false;
+        uint8_t* t2;
 
         t2 = ExAllocatePoolWithTag(NonPagedPool, Vcb->superblock.node_size * 2, ALLOC_TAG);
         if (!t2) {
@@ -704,28 +683,28 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
             if (j != stripe) {
                 if (devices[j] && devices[j]->devobj) {
                     if (first) {
-                        Status = sync_read_phys(devices[j]->devobj, cis[j].offset + off, Vcb->superblock.node_size, t2, FALSE);
+                        Status = sync_read_phys(devices[j]->devobj, devices[j]->fileobj, cis[j].offset + off, Vcb->superblock.node_size, t2, false);
                         if (!NT_SUCCESS(Status)) {
                             ERR("sync_read_phys returned %08x\n", Status);
                             log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_READ_ERRORS);
-                            failed = TRUE;
+                            failed = true;
                             break;
                         }
 
-                        first = FALSE;
+                        first = false;
                     } else {
-                        Status = sync_read_phys(devices[j]->devobj, cis[j].offset + off, Vcb->superblock.node_size, t2 + Vcb->superblock.node_size, FALSE);
+                        Status = sync_read_phys(devices[j]->devobj, devices[j]->fileobj, cis[j].offset + off, Vcb->superblock.node_size, t2 + Vcb->superblock.node_size, false);
                         if (!NT_SUCCESS(Status)) {
                             ERR("sync_read_phys returned %08x\n", Status);
                             log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_READ_ERRORS);
-                            failed = TRUE;
+                            failed = true;
                             break;
                         }
 
                         do_xor(t2, t2 + Vcb->superblock.node_size, Vcb->superblock.node_size);
                     }
                 } else {
-                    failed = TRUE;
+                    failed = true;
                     break;
                 }
             }
@@ -733,18 +712,18 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
 
         if (!failed) {
             tree_header* t3 = (tree_header*)t2;
-            UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&t3->fs_uuid, Vcb->superblock.node_size - sizeof(t3->csum));
+            uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&t3->fs_uuid, Vcb->superblock.node_size - sizeof(t3->csum));
 
-            if (t3->address == addr && crc32 == *((UINT32*)t3->csum) && (generation == 0 || t3->generation == generation)) {
+            if (t3->address == addr && crc32 == *((uint32_t*)t3->csum) && (generation == 0 || t3->generation == generation)) {
                 RtlCopyMemory(buf, t2, Vcb->superblock.node_size);
 
                 if (!degraded)
-                    ERR("recovering from checksum error at %llx, device %llx\n", addr, devices[stripe]->devitem.dev_id);
+                    ERR("recovering from checksum error at %I64x, device %I64x\n", addr, devices[stripe]->devitem.dev_id);
 
-                recovered = TRUE;
+                recovered = true;
 
                 if (!Vcb->readonly && devices[stripe] && !devices[stripe]->readonly && devices[stripe]->devobj) { // write good data over bad
-                    Status = write_data_phys(devices[stripe]->devobj, cis[stripe].offset + off, t2, Vcb->superblock.node_size);
+                    Status = write_data_phys(devices[stripe]->devobj, devices[stripe]->fileobj, cis[stripe].offset + off, t2, Vcb->superblock.node_size);
                     if (!NT_SUCCESS(Status)) {
                         WARN("write_data_phys returned %08x\n", Status);
                         log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_WRITE_ERRORS);
@@ -754,7 +733,7 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
         }
 
         if (!recovered) {
-            ERR("unrecoverable checksum error at %llx\n", addr);
+            ERR("unrecoverable checksum error at %I64x\n", addr);
             ExFreePool(t2);
             return STATUS_CRC_ERROR;
         }
@@ -762,7 +741,7 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
         ExFreePool(t2);
     } else {
         ULONG sectors = length / Vcb->superblock.sector_size;
-        UINT8* sector;
+        uint8_t* sector;
 
         sector = ExAllocatePoolWithTag(NonPagedPool, Vcb->superblock.sector_size * 2, ALLOC_TAG);
         if (!sector) {
@@ -771,9 +750,9 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
         }
 
         for (i = 0; i < sectors; i++) {
-            UINT16 parity;
-            UINT64 off;
-            UINT32 crc32;
+            uint16_t parity;
+            uint64_t off;
+            uint32_t crc32;
 
             if (context->csum)
                 crc32 = ~calc_crc32c(0xffffffff, buf + (i * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
@@ -786,7 +765,7 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
             stripe = (parity + stripe + 1) % ci->num_stripes;
 
             if (!devices[stripe] || !devices[stripe]->devobj || (context->csum && context->csum[i] != crc32)) {
-                BOOL recovered = FALSE, first = TRUE, failed = FALSE;
+                bool recovered = false, first = true, failed = false;
 
                 if (devices[stripe] && devices[stripe]->devobj)
                     log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_READ_ERRORS);
@@ -795,20 +774,21 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
                     if (j != stripe) {
                         if (devices[j] && devices[j]->devobj) {
                             if (first) {
-                                Status = sync_read_phys(devices[j]->devobj, cis[j].offset + off, Vcb->superblock.sector_size, sector, FALSE);
+                                Status = sync_read_phys(devices[j]->devobj, devices[j]->fileobj, cis[j].offset + off, Vcb->superblock.sector_size, sector, false);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("sync_read_phys returned %08x\n", Status);
-                                    failed = TRUE;
+                                    failed = true;
                                     log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_READ_ERRORS);
                                     break;
                                 }
 
-                                first = FALSE;
+                                first = false;
                             } else {
-                                Status = sync_read_phys(devices[j]->devobj, cis[j].offset + off, Vcb->superblock.sector_size, sector + Vcb->superblock.sector_size, FALSE);
+                                Status = sync_read_phys(devices[j]->devobj, devices[j]->fileobj, cis[j].offset + off, Vcb->superblock.sector_size,
+                                                        sector + Vcb->superblock.sector_size, false);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("sync_read_phys returned %08x\n", Status);
-                                    failed = TRUE;
+                                    failed = true;
                                     log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_READ_ERRORS);
                                     break;
                                 }
@@ -816,7 +796,7 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
                                 do_xor(sector, sector + Vcb->superblock.sector_size, Vcb->superblock.sector_size);
                             }
                         } else {
-                            failed = TRUE;
+                            failed = true;
                             break;
                         }
                     }
@@ -830,12 +810,12 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
                         RtlCopyMemory(buf + (i * Vcb->superblock.sector_size), sector, Vcb->superblock.sector_size);
 
                         if (!degraded)
-                            ERR("recovering from checksum error at %llx, device %llx\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size), devices[stripe]->devitem.dev_id);
+                            ERR("recovering from checksum error at %I64x, device %I64x\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size), devices[stripe]->devitem.dev_id);
 
-                        recovered = TRUE;
+                        recovered = true;
 
                         if (!Vcb->readonly && devices[stripe] && !devices[stripe]->readonly && devices[stripe]->devobj) { // write good data over bad
-                            Status = write_data_phys(devices[stripe]->devobj, cis[stripe].offset + off,
+                            Status = write_data_phys(devices[stripe]->devobj, devices[stripe]->fileobj, cis[stripe].offset + off,
                                                      sector, Vcb->superblock.sector_size);
                             if (!NT_SUCCESS(Status)) {
                                 WARN("write_data_phys returned %08x\n", Status);
@@ -846,7 +826,7 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
                 }
 
                 if (!recovered) {
-                    ERR("unrecoverable checksum error at %llx\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size));
+                    ERR("unrecoverable checksum error at %I64x\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size));
                     ExFreePool(sector);
                     return STATUS_CRC_ERROR;
                 }
@@ -859,10 +839,10 @@ static NTSTATUS read_data_raid5(device_extension* Vcb, UINT8* buf, UINT64 addr,
     return STATUS_SUCCESS;
 }
 
-void raid6_recover2(UINT8* sectors, UINT16 num_stripes, ULONG sector_size, UINT16 missing1, UINT16 missing2, UINT8* out) {
+void raid6_recover2(uint8_t* sectors, uint16_t num_stripes, ULONG sector_size, uint16_t missing1, uint16_t missing2, uint8_t* out) {
     if (missing1 == num_stripes - 2 || missing2 == num_stripes - 2) { // reconstruct from q and data
-        UINT16 missing = missing1 == (num_stripes - 2) ? missing2 : missing1;
-        UINT16 stripe;
+        uint16_t missing = missing1 == (num_stripes - 2) ? missing2 : missing1;
+        uint16_t stripe;
 
         stripe = num_stripes - 3;
 
@@ -883,11 +863,11 @@ void raid6_recover2(UINT8* sectors, UINT16 num_stripes, ULONG sector_size, UINT1
         do_xor(out, sectors + ((num_stripes - 1) * sector_size), sector_size);
 
         if (missing != 0)
-            galois_divpower(out, (UINT8)missing, sector_size);
+            galois_divpower(out, (uint8_t)missing, sector_size);
     } else { // reconstruct from p and q
-        UINT16 x, y, stripe;
-        UINT8 gyx, gx, denom, a, b, *p, *q, *pxy, *qxy;
-        UINT32 j;
+        uint16_t x, y, stripe;
+        uint8_t gyx, gx, denom, a, b, *p, *q, *pxy, *qxy;
+        uint32_t j;
 
         stripe = num_stripes - 3;
 
@@ -945,14 +925,14 @@ void raid6_recover2(UINT8* sectors, UINT16 num_stripes, ULONG sector_size, UINT1
     }
 }
 
-static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr, UINT32 length, read_data_context* context, CHUNK_ITEM* ci,
-                                device** devices, UINT64 offset, UINT64 generation, chunk* c, BOOL degraded) {
+static NTSTATUS read_data_raid6(device_extension* Vcb, uint8_t* buf, uint64_t addr, uint32_t length, read_data_context* context, CHUNK_ITEM* ci,
+                                device** devices, uint64_t offset, uint64_t generation, chunk* c, bool degraded) {
     NTSTATUS Status;
     ULONG i;
-    BOOL checksum_error = FALSE;
+    bool checksum_error = false;
     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&ci[1];
-    UINT16 stripe, j;
-    BOOL no_success = TRUE;
+    uint16_t stripe, j;
+    bool no_success = true;
 
     for (j = 0; j < ci->num_stripes; j++) {
         if (context->stripes[j].status == ReadDataStatus_Error) {
@@ -963,15 +943,15 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
             return context->stripes[j].iosb.Status;
         } else if (context->stripes[j].status == ReadDataStatus_Success) {
             stripe = j;
-            no_success = FALSE;
+            no_success = false;
         }
     }
 
     if (c) {    // check partial stripes
         LIST_ENTRY* le;
-        UINT64 ps_length = (ci->num_stripes - 2) * ci->stripe_length;
+        uint64_t ps_length = (ci->num_stripes - 2) * ci->stripe_length;
 
-        ExAcquireResourceSharedLite(&c->partial_stripes_lock, TRUE);
+        ExAcquireResourceSharedLite(&c->partial_stripes_lock, true);
 
         le = c->partial_stripes.Flink;
         while (le != &c->partial_stripes) {
@@ -983,10 +963,30 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                 runlength = RtlFindFirstRunClear(&ps->bmp, &index);
 
                 while (runlength != 0) {
-                    UINT64 runstart = ps->address + (index * Vcb->superblock.sector_size);
-                    UINT64 runend = runstart + (runlength * Vcb->superblock.sector_size);
-                    UINT64 start = max(runstart, addr);
-                    UINT64 end = min(runend, addr + length);
+#ifdef __REACTOS__
+                    uint64_t runstart, runend, start, end;
+#endif
+                    if (index >= ps->bmplen)
+                        break;
+
+                    if (index + runlength >= ps->bmplen) {
+                        runlength = ps->bmplen - index;
+
+                        if (runlength == 0)
+                            break;
+                    }
+
+#ifndef __REACTOS__
+                    uint64_t runstart = ps->address + (index * Vcb->superblock.sector_size);
+                    uint64_t runend = runstart + (runlength * Vcb->superblock.sector_size);
+                    uint64_t start = max(runstart, addr);
+                    uint64_t end = min(runend, addr + length);
+#else
+                    runstart = ps->address + (index * Vcb->superblock.sector_size);
+                    runend = runstart + (runlength * Vcb->superblock.sector_size);
+                    start = max(runstart, addr);
+                    end = min(runend, addr + length);
+#endif
 
                     if (end > start)
                         RtlCopyMemory(buf + start - addr, &ps->data[start - ps->address], (ULONG)(end - start));
@@ -1004,49 +1004,39 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
 
     if (context->tree) {
         tree_header* th = (tree_header*)buf;
-        UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+        uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-        if (addr != th->address || crc32 != *((UINT32*)th->csum)) {
-            checksum_error = TRUE;
+        if (addr != th->address || crc32 != *((uint32_t*)th->csum)) {
+            checksum_error = true;
             if (!no_success && !degraded && devices[stripe])
                 log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
         } else if (generation != 0 && generation != th->generation) {
-            checksum_error = TRUE;
+            checksum_error = true;
             if (!no_success && !degraded && devices[stripe])
                 log_device_error(Vcb, devices[stripe], BTRFS_DEV_STAT_GENERATION_ERRORS);
         }
     } else if (context->csum) {
-#ifdef DEBUG_STATS
-        LARGE_INTEGER time1, time2;
-
-        time1 = KeQueryPerformanceCounter(NULL);
-#endif
         Status = check_csum(Vcb, buf, length / Vcb->superblock.sector_size, context->csum);
 
         if (Status == STATUS_CRC_ERROR) {
             if (!degraded)
                 WARN("checksum error\n");
-            checksum_error = TRUE;
+            checksum_error = true;
         } else if (!NT_SUCCESS(Status)) {
             ERR("check_csum returned %08x\n", Status);
             return Status;
         }
-#ifdef DEBUG_STATS
-        time2 = KeQueryPerformanceCounter(NULL);
-
-        Vcb->stats.read_csum_time += time2.QuadPart - time1.QuadPart;
-#endif
     } else if (degraded)
-        checksum_error = TRUE;
+        checksum_error = true;
 
     if (!checksum_error)
         return STATUS_SUCCESS;
 
     if (context->tree) {
-        UINT8* sector;
-        UINT16 k, physstripe, parity1, parity2, error_stripe;
-        UINT64 off;
-        BOOL recovered = FALSE, failed = FALSE;
+        uint8_t* sector;
+        uint16_t k, physstripe, parity1, parity2, error_stripe;
+        uint64_t off;
+        bool recovered = false, failed = false;
         ULONG num_errors = 0;
 
         sector = ExAllocatePoolWithTag(NonPagedPool, Vcb->superblock.node_size * (ci->num_stripes + 2), ALLOC_TAG);
@@ -1067,7 +1057,8 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
         for (k = 0; k < ci->num_stripes - 1; k++) {
             if (j != physstripe) {
                 if (devices[j] && devices[j]->devobj) {
-                    Status = sync_read_phys(devices[j]->devobj, cis[j].offset + off, Vcb->superblock.node_size, sector + (k * Vcb->superblock.node_size), FALSE);
+                    Status = sync_read_phys(devices[j]->devobj, devices[j]->fileobj, cis[j].offset + off, Vcb->superblock.node_size,
+                                            sector + (k * Vcb->superblock.node_size), false);
                     if (!NT_SUCCESS(Status)) {
                         ERR("sync_read_phys returned %08x\n", Status);
                         log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_READ_ERRORS);
@@ -1075,7 +1066,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                         error_stripe = k;
 
                         if (num_errors > 1) {
-                            failed = TRUE;
+                            failed = true;
                             break;
                         }
                     }
@@ -1084,7 +1075,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                     error_stripe = k;
 
                     if (num_errors > 1) {
-                        failed = TRUE;
+                        failed = true;
                         break;
                     }
                 }
@@ -1096,7 +1087,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
         if (!failed) {
             if (num_errors == 0) {
                 tree_header* th = (tree_header*)(sector + (stripe * Vcb->superblock.node_size));
-                UINT32 crc32;
+                uint32_t crc32;
 
                 RtlCopyMemory(sector + (stripe * Vcb->superblock.node_size), sector + ((ci->num_stripes - 2) * Vcb->superblock.node_size),
                               Vcb->superblock.node_size);
@@ -1106,18 +1097,18 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                         do_xor(sector + (stripe * Vcb->superblock.node_size), sector + (j * Vcb->superblock.node_size), Vcb->superblock.node_size);
                 }
 
-                crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-                if (th->address == addr && crc32 == *((UINT32*)th->csum) && (generation == 0 || th->generation == generation)) {
+                if (th->address == addr && crc32 == *((uint32_t*)th->csum) && (generation == 0 || th->generation == generation)) {
                     RtlCopyMemory(buf, sector + (stripe * Vcb->superblock.node_size), Vcb->superblock.node_size);
 
                     if (devices[physstripe] && devices[physstripe]->devobj)
-                        ERR("recovering from checksum error at %llx, device %llx\n", addr, devices[physstripe]->devitem.dev_id);
+                        ERR("recovering from checksum error at %I64x, device %I64x\n", addr, devices[physstripe]->devitem.dev_id);
 
-                    recovered = TRUE;
+                    recovered = true;
 
                     if (!Vcb->readonly && devices[physstripe] && devices[physstripe]->devobj && !devices[physstripe]->readonly) { // write good data over bad
-                        Status = write_data_phys(devices[physstripe]->devobj, cis[physstripe].offset + off,
+                        Status = write_data_phys(devices[physstripe]->devobj, devices[physstripe]->fileobj, cis[physstripe].offset + off,
                                                  sector + (stripe * Vcb->superblock.node_size), Vcb->superblock.node_size);
                         if (!NT_SUCCESS(Status)) {
                             WARN("write_data_phys returned %08x\n", Status);
@@ -1128,37 +1119,37 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
             }
 
             if (!recovered) {
-                UINT32 crc32;
+                uint32_t crc32;
                 tree_header* th = (tree_header*)(sector + (ci->num_stripes * Vcb->superblock.node_size));
-                BOOL read_q = FALSE;
+                bool read_q = false;
 
                 if (devices[parity2] && devices[parity2]->devobj) {
-                    Status = sync_read_phys(devices[parity2]->devobj, cis[parity2].offset + off,
-                                            Vcb->superblock.node_size, sector + ((ci->num_stripes - 1) * Vcb->superblock.node_size), FALSE);
+                    Status = sync_read_phys(devices[parity2]->devobj, devices[parity2]->fileobj, cis[parity2].offset + off,
+                                            Vcb->superblock.node_size, sector + ((ci->num_stripes - 1) * Vcb->superblock.node_size), false);
                     if (!NT_SUCCESS(Status)) {
                         ERR("sync_read_phys returned %08x\n", Status);
                         log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_READ_ERRORS);
                     } else
-                        read_q = TRUE;
+                        read_q = true;
                 }
 
                 if (read_q) {
                     if (num_errors == 1) {
                         raid6_recover2(sector, ci->num_stripes, Vcb->superblock.node_size, stripe, error_stripe, sector + (ci->num_stripes * Vcb->superblock.node_size));
 
-                        crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                        crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-                        if (th->address == addr && crc32 == *((UINT32*)th->csum) && (generation == 0 || th->generation == generation))
-                            recovered = TRUE;
+                        if (th->address == addr && crc32 == *((uint32_t*)th->csum) && (generation == 0 || th->generation == generation))
+                            recovered = true;
                     } else {
                         for (j = 0; j < ci->num_stripes - 1; j++) {
                             if (j != stripe) {
                                 raid6_recover2(sector, ci->num_stripes, Vcb->superblock.node_size, stripe, j, sector + (ci->num_stripes * Vcb->superblock.node_size));
 
-                                crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                                crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-                                if (th->address == addr && crc32 == *((UINT32*)th->csum) && (generation == 0 || th->generation == generation)) {
-                                    recovered = TRUE;
+                                if (th->address == addr && crc32 == *((uint32_t*)th->csum) && (generation == 0 || th->generation == generation)) {
+                                    recovered = true;
                                     error_stripe = j;
                                     break;
                                 }
@@ -1168,15 +1159,15 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                 }
 
                 if (recovered) {
-                    UINT16 error_stripe_phys = (parity2 + error_stripe + 1) % ci->num_stripes;
+                    uint16_t error_stripe_phys = (parity2 + error_stripe + 1) % ci->num_stripes;
 
                     if (devices[physstripe] && devices[physstripe]->devobj)
-                        ERR("recovering from checksum error at %llx, device %llx\n", addr, devices[physstripe]->devitem.dev_id);
+                        ERR("recovering from checksum error at %I64x, device %I64x\n", addr, devices[physstripe]->devitem.dev_id);
 
                     RtlCopyMemory(buf, sector + (ci->num_stripes * Vcb->superblock.node_size), Vcb->superblock.node_size);
 
                     if (!Vcb->readonly && devices[physstripe] && devices[physstripe]->devobj && !devices[physstripe]->readonly) { // write good data over bad
-                        Status = write_data_phys(devices[physstripe]->devobj, cis[physstripe].offset + off,
+                        Status = write_data_phys(devices[physstripe]->devobj, devices[physstripe]->fileobj, cis[physstripe].offset + off,
                                                  sector + (ci->num_stripes * Vcb->superblock.node_size), Vcb->superblock.node_size);
                         if (!NT_SUCCESS(Status)) {
                             WARN("write_data_phys returned %08x\n", Status);
@@ -1186,7 +1177,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
 
                     if (devices[error_stripe_phys] && devices[error_stripe_phys]->devobj) {
                         if (error_stripe == ci->num_stripes - 2) {
-                            ERR("recovering from parity error at %llx, device %llx\n", addr, devices[error_stripe_phys]->devitem.dev_id);
+                            ERR("recovering from parity error at %I64x, device %I64x\n", addr, devices[error_stripe_phys]->devitem.dev_id);
 
                             log_device_error(Vcb, devices[error_stripe_phys], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
 
@@ -1202,7 +1193,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                                 }
                             }
                         } else {
-                            ERR("recovering from checksum error at %llx, device %llx\n", addr + ((error_stripe - stripe) * ci->stripe_length),
+                            ERR("recovering from checksum error at %I64x, device %I64x\n", addr + ((error_stripe - stripe) * ci->stripe_length),
                                 devices[error_stripe_phys]->devitem.dev_id);
 
                             log_device_error(Vcb, devices[error_stripe_phys], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
@@ -1213,7 +1204,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                     }
 
                     if (!Vcb->readonly && devices[error_stripe_phys] && devices[error_stripe_phys]->devobj && !devices[error_stripe_phys]->readonly) { // write good data over bad
-                        Status = write_data_phys(devices[error_stripe_phys]->devobj, cis[error_stripe_phys].offset + off,
+                        Status = write_data_phys(devices[error_stripe_phys]->devobj, devices[error_stripe_phys]->fileobj, cis[error_stripe_phys].offset + off,
                                                  sector + (error_stripe * Vcb->superblock.node_size), Vcb->superblock.node_size);
                         if (!NT_SUCCESS(Status)) {
                             WARN("write_data_phys returned %08x\n", Status);
@@ -1225,7 +1216,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
         }
 
         if (!recovered) {
-            ERR("unrecoverable checksum error at %llx\n", addr);
+            ERR("unrecoverable checksum error at %I64x\n", addr);
             ExFreePool(sector);
             return STATUS_CRC_ERROR;
         }
@@ -1233,7 +1224,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
         ExFreePool(sector);
     } else {
         ULONG sectors = length / Vcb->superblock.sector_size;
-        UINT8* sector;
+        uint8_t* sector;
 
         sector = ExAllocatePoolWithTag(NonPagedPool, Vcb->superblock.sector_size * (ci->num_stripes + 2), ALLOC_TAG);
         if (!sector) {
@@ -1242,9 +1233,9 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
         }
 
         for (i = 0; i < sectors; i++) {
-            UINT64 off;
-            UINT16 physstripe, parity1, parity2;
-            UINT32 crc32;
+            uint64_t off;
+            uint16_t physstripe, parity1, parity2;
+            uint32_t crc32;
 
             if (context->csum)
                 crc32 = ~calc_crc32c(0xffffffff, buf + (i * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
@@ -1258,8 +1249,8 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
             physstripe = (parity2 + stripe + 1) % ci->num_stripes;
 
             if (!devices[physstripe] || !devices[physstripe]->devobj || (context->csum && context->csum[i] != crc32)) {
-                UINT16 k, error_stripe;
-                BOOL recovered = FALSE, failed = FALSE;
+                uint16_t k, error_stripe;
+                bool recovered = false, failed = false;
                 ULONG num_errors = 0;
 
                 if (devices[physstripe] && devices[physstripe]->devobj)
@@ -1270,7 +1261,8 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                 for (k = 0; k < ci->num_stripes - 1; k++) {
                     if (j != physstripe) {
                         if (devices[j] && devices[j]->devobj) {
-                            Status = sync_read_phys(devices[j]->devobj, cis[j].offset + off, Vcb->superblock.sector_size, sector + (k * Vcb->superblock.sector_size), FALSE);
+                            Status = sync_read_phys(devices[j]->devobj, devices[j]->fileobj, cis[j].offset + off, Vcb->superblock.sector_size,
+                                                    sector + (k * Vcb->superblock.sector_size), false);
                             if (!NT_SUCCESS(Status)) {
                                 ERR("sync_read_phys returned %08x\n", Status);
                                 log_device_error(Vcb, devices[j], BTRFS_DEV_STAT_READ_ERRORS);
@@ -1278,7 +1270,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                                 error_stripe = k;
 
                                 if (num_errors > 1) {
-                                    failed = TRUE;
+                                    failed = true;
                                     break;
                                 }
                             }
@@ -1287,7 +1279,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                             error_stripe = k;
 
                             if (num_errors > 1) {
-                                failed = TRUE;
+                                failed = true;
                                 break;
                             }
                         }
@@ -1312,13 +1304,13 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                             RtlCopyMemory(buf + (i * Vcb->superblock.sector_size), sector + (stripe * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
                             if (devices[physstripe] && devices[physstripe]->devobj)
-                                ERR("recovering from checksum error at %llx, device %llx\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size),
+                                ERR("recovering from checksum error at %I64x, device %I64x\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size),
                                     devices[physstripe]->devitem.dev_id);
 
-                            recovered = TRUE;
+                            recovered = true;
 
                             if (!Vcb->readonly && devices[physstripe] && devices[physstripe]->devobj && !devices[physstripe]->readonly) { // write good data over bad
-                                Status = write_data_phys(devices[physstripe]->devobj, cis[physstripe].offset + off,
+                                Status = write_data_phys(devices[physstripe]->devobj, devices[physstripe]->fileobj, cis[physstripe].offset + off,
                                                          sector + (stripe * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
                                 if (!NT_SUCCESS(Status)) {
                                     WARN("write_data_phys returned %08x\n", Status);
@@ -1329,16 +1321,16 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                     }
 
                     if (!recovered) {
-                        BOOL read_q = FALSE;
+                        bool read_q = false;
 
                         if (devices[parity2] && devices[parity2]->devobj) {
-                            Status = sync_read_phys(devices[parity2]->devobj, cis[parity2].offset + off,
-                                                    Vcb->superblock.sector_size, sector + ((ci->num_stripes - 1) * Vcb->superblock.sector_size), FALSE);
+                            Status = sync_read_phys(devices[parity2]->devobj, devices[parity2]->fileobj, cis[parity2].offset + off,
+                                                    Vcb->superblock.sector_size, sector + ((ci->num_stripes - 1) * Vcb->superblock.sector_size), false);
                             if (!NT_SUCCESS(Status)) {
                                 ERR("sync_read_phys returned %08x\n", Status);
                                 log_device_error(Vcb, devices[parity2], BTRFS_DEV_STAT_READ_ERRORS);
                             } else
-                                read_q = TRUE;
+                                read_q = true;
                         }
 
                         if (read_q) {
@@ -1346,12 +1338,12 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                                 raid6_recover2(sector, ci->num_stripes, Vcb->superblock.sector_size, stripe, error_stripe, sector + (ci->num_stripes * Vcb->superblock.sector_size));
 
                                 if (!devices[physstripe] || !devices[physstripe]->devobj)
-                                    recovered = TRUE;
+                                    recovered = true;
                                 else {
                                     crc32 = ~calc_crc32c(0xffffffff, sector + (ci->num_stripes * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
                                     if (crc32 == context->csum[i])
-                                        recovered = TRUE;
+                                        recovered = true;
                                 }
                             } else {
                                 for (j = 0; j < ci->num_stripes - 1; j++) {
@@ -1361,7 +1353,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                                         crc32 = ~calc_crc32c(0xffffffff, sector + (ci->num_stripes * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
                                         if (crc32 == context->csum[i]) {
-                                            recovered = TRUE;
+                                            recovered = true;
                                             error_stripe = j;
                                             break;
                                         }
@@ -1371,16 +1363,16 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                         }
 
                         if (recovered) {
-                            UINT16 error_stripe_phys = (parity2 + error_stripe + 1) % ci->num_stripes;
+                            uint16_t error_stripe_phys = (parity2 + error_stripe + 1) % ci->num_stripes;
 
                             if (devices[physstripe] && devices[physstripe]->devobj)
-                                ERR("recovering from checksum error at %llx, device %llx\n",
+                                ERR("recovering from checksum error at %I64x, device %I64x\n",
                                     addr + UInt32x32To64(i, Vcb->superblock.sector_size), devices[physstripe]->devitem.dev_id);
 
                             RtlCopyMemory(buf + (i * Vcb->superblock.sector_size), sector + (ci->num_stripes * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
                             if (!Vcb->readonly && devices[physstripe] && devices[physstripe]->devobj && !devices[physstripe]->readonly) { // write good data over bad
-                                Status = write_data_phys(devices[physstripe]->devobj, cis[physstripe].offset + off,
+                                Status = write_data_phys(devices[physstripe]->devobj, devices[physstripe]->fileobj, cis[physstripe].offset + off,
                                                          sector + (ci->num_stripes * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
                                 if (!NT_SUCCESS(Status)) {
                                     WARN("write_data_phys returned %08x\n", Status);
@@ -1390,7 +1382,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
 
                             if (devices[error_stripe_phys] && devices[error_stripe_phys]->devobj) {
                                 if (error_stripe == ci->num_stripes - 2) {
-                                    ERR("recovering from parity error at %llx, device %llx\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size),
+                                    ERR("recovering from parity error at %I64x, device %I64x\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size),
                                         devices[error_stripe_phys]->devitem.dev_id);
 
                                     log_device_error(Vcb, devices[error_stripe_phys], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
@@ -1407,7 +1399,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                                         }
                                     }
                                 } else {
-                                    ERR("recovering from checksum error at %llx, device %llx\n",
+                                    ERR("recovering from checksum error at %I64x, device %I64x\n",
                                         addr + UInt32x32To64(i, Vcb->superblock.sector_size) + ((error_stripe - stripe) * ci->stripe_length),
                                         devices[error_stripe_phys]->devitem.dev_id);
 
@@ -1419,7 +1411,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                             }
 
                             if (!Vcb->readonly && devices[error_stripe_phys] && devices[error_stripe_phys]->devobj && !devices[error_stripe_phys]->readonly) { // write good data over bad
-                                Status = write_data_phys(devices[error_stripe_phys]->devobj, cis[error_stripe_phys].offset + off,
+                                Status = write_data_phys(devices[error_stripe_phys]->devobj, devices[error_stripe_phys]->fileobj, cis[error_stripe_phys].offset + off,
                                                          sector + (error_stripe * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
                                 if (!NT_SUCCESS(Status)) {
                                     WARN("write_data_phys returned %08x\n", Status);
@@ -1431,7 +1423,7 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
                 }
 
                 if (!recovered) {
-                    ERR("unrecoverable checksum error at %llx\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size));
+                    ERR("unrecoverable checksum error at %I64x\n", addr + UInt32x32To64(i, Vcb->superblock.sector_size));
                     ExFreePool(sector);
                     return STATUS_CRC_ERROR;
                 }
@@ -1444,23 +1436,20 @@ static NTSTATUS read_data_raid6(device_extension* Vcb, UINT8* buf, UINT64 addr,
     return STATUS_SUCCESS;
 }
 
-NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 length, _In_reads_bytes_opt_(length*sizeof(UINT32)/Vcb->superblock.sector_size) UINT32* csum,
-                   _In_ BOOL is_tree, _Out_writes_bytes_(length) UINT8* buf, _In_opt_ chunk* c, _Out_opt_ chunk** pc, _In_opt_ PIRP Irp, _In_ UINT64 generation, _In_ BOOL file_read,
+NTSTATUS read_data(_In_ device_extension* Vcb, _In_ uint64_t addr, _In_ uint32_t length, _In_reads_bytes_opt_(length*sizeof(uint32_t)/Vcb->superblock.sector_size) uint32_t* csum,
+                   _In_ bool is_tree, _Out_writes_bytes_(length) uint8_t* buf, _In_opt_ chunk* c, _Out_opt_ chunk** pc, _In_opt_ PIRP Irp, _In_ uint64_t generation, _In_ bool file_read,
                    _In_ ULONG priority) {
     CHUNK_ITEM* ci;
     CHUNK_ITEM_STRIPE* cis;
     read_data_context context;
-    UINT64 type, offset, total_reading = 0;
+    uint64_t type, offset, total_reading = 0;
     NTSTATUS Status;
     device** devices = NULL;
-    UINT16 i, startoffstripe, allowed_missing, missing_devices = 0;
-    UINT8* dummypage = NULL;
+    uint16_t i, startoffstripe, allowed_missing, missing_devices = 0;
+    uint8_t* dummypage = NULL;
     PMDL dummy_mdl = NULL;
-    BOOL need_to_wait;
-    UINT64 lockaddr, locklen;
-#ifdef DEBUG_STATS
-    LARGE_INTEGER time1, time2;
-#endif
+    bool need_to_wait;
+    uint64_t lockaddr, locklen;
 
     if (Vcb->log_to_phys_loaded) {
         if (!c) {
@@ -1495,7 +1484,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                     offset = sc->key.offset;
                     cis = (CHUNK_ITEM_STRIPE*)&chunk_item[1];
 
-                    devices = ExAllocatePoolWithTag(PagedPool, sizeof(device*) * ci->num_stripes, ALLOC_TAG);
+                    devices = ExAllocatePoolWithTag(NonPagedPool, sizeof(device*) * ci->num_stripes, ALLOC_TAG);
                     if (!devices) {
                         ERR("out of memory\n");
                         return STATUS_INSUFFICIENT_RESOURCES;
@@ -1513,7 +1502,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
         }
 
         if (!ci) {
-            ERR("could not find chunk for %llx in bootstrap\n", addr);
+            ERR("could not find chunk for %I64x in bootstrap\n", addr);
             return STATUS_INTERNAL_ERROR;
         }
 
@@ -1547,7 +1536,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
     cis = (CHUNK_ITEM_STRIPE*)&ci[1];
 
     RtlZeroMemory(&context, sizeof(read_data_context));
-    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&context.Event, NotificationEvent, false);
 
     context.stripes = ExAllocatePoolWithTag(NonPagedPool, sizeof(read_data_stripe) * ci->num_stripes, ALLOC_TAG);
     if (!context.stripes) {
@@ -1571,9 +1560,9 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
     context.type = type;
 
     if (type == BLOCK_FLAG_RAID0) {
-        UINT64 startoff, endoff;
-        UINT16 endoffstripe, stripe;
-        UINT32 *stripeoff, pos;
+        uint64_t startoff, endoff;
+        uint16_t endoffstripe, stripe;
+        uint32_t *stripeoff, pos;
         PMDL master_mdl;
         PFN_NUMBER* pfns;
 
@@ -1602,7 +1591,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
         } else
             context.va = buf;
 
-        master_mdl = IoAllocateMdl(context.va, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl(context.va, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1641,7 +1630,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                 context.stripes[i].stripeend = endoff - (endoff % ci->stripe_length);
 
             if (context.stripes[i].stripestart != context.stripes[i].stripeend) {
-                context.stripes[i].mdl = IoAllocateMdl(context.va, (ULONG)(context.stripes[i].stripeend - context.stripes[i].stripestart), FALSE, FALSE, NULL);
+                context.stripes[i].mdl = IoAllocateMdl(context.va, (ULONG)(context.stripes[i].stripeend - context.stripes[i].stripestart), false, false, NULL);
 
                 if (!context.stripes[i].mdl) {
                     ERR("IoAllocateMdl failed\n");
@@ -1653,7 +1642,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             }
         }
 
-        stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(UINT32) * ci->num_stripes, ALLOC_TAG);
+        stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(uint32_t) * ci->num_stripes, ALLOC_TAG);
         if (!stripeoff) {
             ERR("out of memory\n");
             MmUnlockPages(master_mdl);
@@ -1662,7 +1651,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             goto exit;
         }
 
-        RtlZeroMemory(stripeoff, sizeof(UINT32) * ci->num_stripes);
+        RtlZeroMemory(stripeoff, sizeof(uint32_t) * ci->num_stripes);
 
         pos = 0;
         stripe = startoffstripe;
@@ -1670,7 +1659,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             PFN_NUMBER* stripe_pfns = (PFN_NUMBER*)(context.stripes[stripe].mdl + 1);
 
             if (pos == 0) {
-                UINT32 readlen = (UINT32)min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart, ci->stripe_length - (context.stripes[stripe].stripestart % ci->stripe_length));
+                uint32_t readlen = (uint32_t)min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart, ci->stripe_length - (context.stripes[stripe].stripestart % ci->stripe_length));
 
                 RtlCopyMemory(stripe_pfns, pfns, readlen * sizeof(PFN_NUMBER) >> PAGE_SHIFT);
 
@@ -1683,8 +1672,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             } else {
                 RtlCopyMemory(&stripe_pfns[stripeoff[stripe] >> PAGE_SHIFT], &pfns[pos >> PAGE_SHIFT], (ULONG)(ci->stripe_length * sizeof(PFN_NUMBER) >> PAGE_SHIFT));
 
-                stripeoff[stripe] += (UINT32)ci->stripe_length;
-                pos += (UINT32)ci->stripe_length;
+                stripeoff[stripe] += (uint32_t)ci->stripe_length;
+                pos += (uint32_t)ci->stripe_length;
             }
 
             stripe = (stripe + 1) % ci->num_stripes;
@@ -1695,12 +1684,12 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
 
         ExFreePool(stripeoff);
     } else if (type == BLOCK_FLAG_RAID10) {
-        UINT64 startoff, endoff;
-        UINT16 endoffstripe, j, stripe;
+        uint64_t startoff, endoff;
+        uint16_t endoffstripe, j, stripe;
         ULONG orig_ls;
         PMDL master_mdl;
         PFN_NUMBER* pfns;
-        UINT32* stripeoff, pos;
+        uint32_t* stripeoff, pos;
         read_data_stripe** stripes;
 
         if (c)
@@ -1712,7 +1701,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
         get_raid0_offset(addr + length - offset - 1, ci->stripe_length, ci->num_stripes / ci->sub_stripes, &endoff, &endoffstripe);
 
         if ((ci->num_stripes % ci->sub_stripes) != 0) {
-            ERR("chunk %llx: num_stripes %x was not a multiple of sub_stripes %x!\n", offset, ci->num_stripes, ci->sub_stripes);
+            ERR("chunk %I64x: num_stripes %x was not a multiple of sub_stripes %x!\n", offset, ci->num_stripes, ci->sub_stripes);
             Status = STATUS_INTERNAL_ERROR;
             goto exit;
         }
@@ -1728,9 +1717,9 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
         } else
             context.va = buf;
 
-        context.firstoff = (UINT16)((startoff % ci->stripe_length) / Vcb->superblock.sector_size);
+        context.firstoff = (uint16_t)((startoff % ci->stripe_length) / Vcb->superblock.sector_size);
         context.startoffstripe = startoffstripe;
-        context.sectors_per_stripe = (UINT16)(ci->stripe_length / Vcb->superblock.sector_size);
+        context.sectors_per_stripe = (uint16_t)(ci->stripe_length / Vcb->superblock.sector_size);
 
         startoffstripe *= ci->sub_stripes;
         endoffstripe *= ci->sub_stripes;
@@ -1738,7 +1727,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
         if (c)
             c->last_stripe = (orig_ls + 1) % ci->sub_stripes;
 
-        master_mdl = IoAllocateMdl(context.va, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl(context.va, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1773,8 +1762,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
         RtlZeroMemory(stripes, sizeof(read_data_stripe*) * ci->num_stripes / ci->sub_stripes);
 
         for (i = 0; i < ci->num_stripes; i += ci->sub_stripes) {
-            UINT64 sstart, send;
-            BOOL stripeset = FALSE;
+            uint64_t sstart, send;
+            bool stripeset = false;
 
             if (startoffstripe > i)
                 sstart = startoff - (startoff % ci->stripe_length) + ci->stripe_length;
@@ -1797,7 +1786,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                     stripes[i / ci->sub_stripes] = &context.stripes[i+j];
 
                     if (sstart != send) {
-                        context.stripes[i+j].mdl = IoAllocateMdl(context.va, (ULONG)(send - sstart), FALSE, FALSE, NULL);
+                        context.stripes[i+j].mdl = IoAllocateMdl(context.va, (ULONG)(send - sstart), false, false, NULL);
 
                         if (!context.stripes[i+j].mdl) {
                             ERR("IoAllocateMdl failed\n");
@@ -1808,7 +1797,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                         }
                     }
 
-                    stripeset = TRUE;
+                    stripeset = true;
                 } else
                     context.stripes[i+j].status = ReadDataStatus_Skip;
             }
@@ -1822,7 +1811,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                         stripes[i / ci->sub_stripes] = &context.stripes[i+j];
 
                         if (sstart != send) {
-                            context.stripes[i+j].mdl = IoAllocateMdl(context.va, (ULONG)(send - sstart), FALSE, FALSE, NULL);
+                            context.stripes[i+j].mdl = IoAllocateMdl(context.va, (ULONG)(send - sstart), false, false, NULL);
 
                             if (!context.stripes[i+j].mdl) {
                                 ERR("IoAllocateMdl failed\n");
@@ -1833,7 +1822,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                             }
                         }
 
-                        stripeset = TRUE;
+                        stripeset = true;
                         break;
                     }
                 }
@@ -1846,7 +1835,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             }
         }
 
-        stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(UINT32) * ci->num_stripes / ci->sub_stripes, ALLOC_TAG);
+        stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(uint32_t) * ci->num_stripes / ci->sub_stripes, ALLOC_TAG);
         if (!stripeoff) {
             ERR("out of memory\n");
             MmUnlockPages(master_mdl);
@@ -1855,7 +1844,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             goto exit;
         }
 
-        RtlZeroMemory(stripeoff, sizeof(UINT32) * ci->num_stripes / ci->sub_stripes);
+        RtlZeroMemory(stripeoff, sizeof(uint32_t) * ci->num_stripes / ci->sub_stripes);
 
         pos = 0;
         stripe = startoffstripe / ci->sub_stripes;
@@ -1863,7 +1852,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             PFN_NUMBER* stripe_pfns = (PFN_NUMBER*)(stripes[stripe]->mdl + 1);
 
             if (pos == 0) {
-                UINT32 readlen = (UINT32)min(stripes[stripe]->stripeend - stripes[stripe]->stripestart,
+                uint32_t readlen = (uint32_t)min(stripes[stripe]->stripeend - stripes[stripe]->stripestart,
                                              ci->stripe_length - (stripes[stripe]->stripestart % ci->stripe_length));
 
                 RtlCopyMemory(stripe_pfns, pfns, readlen * sizeof(PFN_NUMBER) >> PAGE_SHIFT);
@@ -1890,7 +1879,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
         ExFreePool(stripeoff);
         ExFreePool(stripes);
     } else if (type == BLOCK_FLAG_DUPLICATE) {
-        UINT64 orig_ls;
+        uint64_t orig_ls;
 
         if (c)
             orig_ls = i = c->last_stripe;
@@ -1922,7 +1911,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                 goto exit;
             }
 
-            context.stripes[i].mdl = IoAllocateMdl(context.va, length, FALSE, FALSE, NULL);
+            context.stripes[i].mdl = IoAllocateMdl(context.va, length, false, false, NULL);
             if (!context.stripes[i].mdl) {
                 ERR("IoAllocateMdl failed\n");
                 Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1931,7 +1920,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
 
             MmBuildMdlForNonPagedPool(context.stripes[i].mdl);
         } else {
-            context.stripes[i].mdl = IoAllocateMdl(buf, length, FALSE, FALSE, NULL);
+            context.stripes[i].mdl = IoAllocateMdl(buf, length, false, false, NULL);
 
             if (!context.stripes[i].mdl) {
                 ERR("IoAllocateMdl failed\n");
@@ -1953,12 +1942,12 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             }
         }
     } else if (type == BLOCK_FLAG_RAID5) {
-        UINT64 startoff, endoff;
-        UINT16 endoffstripe, parity;
-        UINT32 *stripeoff, pos;
+        uint64_t startoff, endoff;
+        uint16_t endoffstripe, parity;
+        uint32_t *stripeoff, pos;
         PMDL master_mdl;
         PFN_NUMBER *pfns, dummy;
-        BOOL need_dummy = FALSE;
+        bool need_dummy = false;
 
         get_raid0_offset(addr - offset, ci->stripe_length, ci->num_stripes - 1, &startoff, &startoffstripe);
         get_raid0_offset(addr + length - offset - 1, ci->stripe_length, ci->num_stripes - 1, &endoff, &endoffstripe);
@@ -1974,7 +1963,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
         } else
             context.va = buf;
 
-        master_mdl = IoAllocateMdl(context.va, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl(context.va, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2002,7 +1991,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             parity = (((addr - offset + pos) / ((ci->num_stripes - 1) * ci->stripe_length)) + ci->num_stripes - 1) % ci->num_stripes;
 
             if (pos == 0) {
-                UINT16 stripe = (parity + startoffstripe + 1) % ci->num_stripes;
+                uint16_t stripe = (parity + startoffstripe + 1) % ci->num_stripes;
                 ULONG skip, readlen;
 
                 i = startoffstripe;
@@ -2037,7 +2026,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                     break;
 
                 for (i = 0; i < startoffstripe; i++) {
-                    UINT16 stripe2 = (parity + i + 1) % ci->num_stripes;
+                    uint16_t stripe2 = (parity + i + 1) % ci->num_stripes;
 
                     context.stripes[stripe2].stripestart = context.stripes[stripe2].stripeend = startoff - (startoff % ci->stripe_length) + ci->stripe_length;
                 }
@@ -2051,18 +2040,18 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                         context.stripes[i].stripeend += skip * ci->num_stripes * ci->stripe_length;
                     }
 
-                    pos += (UINT32)(skip * (ci->num_stripes - 1) * ci->num_stripes * ci->stripe_length);
-                    need_dummy = TRUE;
+                    pos += (uint32_t)(skip * (ci->num_stripes - 1) * ci->num_stripes * ci->stripe_length);
+                    need_dummy = true;
                 }
             } else if (length - pos >= ci->stripe_length * (ci->num_stripes - 1)) {
                 for (i = 0; i < ci->num_stripes; i++) {
                     context.stripes[i].stripeend += ci->stripe_length;
                 }
 
-                pos += (UINT32)(ci->stripe_length * (ci->num_stripes - 1));
-                need_dummy = TRUE;
+                pos += (uint32_t)(ci->stripe_length * (ci->num_stripes - 1));
+                need_dummy = true;
             } else {
-                UINT16 stripe = (parity + 1) % ci->num_stripes;
+                uint16_t stripe = (parity + 1) % ci->num_stripes;
 
                 i = 0;
                 while (stripe != parity) {
@@ -2083,7 +2072,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
         for (i = 0; i < ci->num_stripes; i++) {
             if (context.stripes[i].stripestart != context.stripes[i].stripeend) {
                 context.stripes[i].mdl = IoAllocateMdl(context.va, (ULONG)(context.stripes[i].stripeend - context.stripes[i].stripestart),
-                                                       FALSE, FALSE, NULL);
+                                                       false, false, NULL);
 
                 if (!context.stripes[i].mdl) {
                     ERR("IoAllocateMdl failed\n");
@@ -2105,7 +2094,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                 goto exit;
             }
 
-            dummy_mdl = IoAllocateMdl(dummypage, PAGE_SIZE, FALSE, FALSE, NULL);
+            dummy_mdl = IoAllocateMdl(dummypage, PAGE_SIZE, false, false, NULL);
             if (!dummy_mdl) {
                 ERR("IoAllocateMdl failed\n");
                 MmUnlockPages(master_mdl);
@@ -2119,7 +2108,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             dummy = *(PFN_NUMBER*)(dummy_mdl + 1);
         }
 
-        stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(UINT32) * ci->num_stripes, ALLOC_TAG);
+        stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(uint32_t) * ci->num_stripes, ALLOC_TAG);
         if (!stripeoff) {
             ERR("out of memory\n");
             MmUnlockPages(master_mdl);
@@ -2128,7 +2117,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             goto exit;
         }
 
-        RtlZeroMemory(stripeoff, sizeof(UINT32) * ci->num_stripes);
+        RtlZeroMemory(stripeoff, sizeof(uint32_t) * ci->num_stripes);
 
         pos = 0;
 
@@ -2138,8 +2127,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             parity = (((addr - offset + pos) / ((ci->num_stripes - 1) * ci->stripe_length)) + ci->num_stripes - 1) % ci->num_stripes;
 
             if (pos == 0) {
-                UINT16 stripe = (parity + startoffstripe + 1) % ci->num_stripes;
-                UINT32 readlen = min(length - pos, (UINT32)min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart,
+                uint16_t stripe = (parity + startoffstripe + 1) % ci->num_stripes;
+                uint32_t readlen = min(length - pos, (uint32_t)min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart,
                                                        ci->stripe_length - (context.stripes[stripe].stripestart % ci->stripe_length)));
 
                 stripe_pfns = (PFN_NUMBER*)(context.stripes[stripe].mdl + 1);
@@ -2153,7 +2142,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
 
                 while (stripe != parity) {
                     stripe_pfns = (PFN_NUMBER*)(context.stripes[stripe].mdl + 1);
-                    readlen = min(length - pos, (UINT32)min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart, ci->stripe_length));
+                    readlen = min(length - pos, (uint32_t)min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart, ci->stripe_length));
 
                     if (readlen == 0)
                         break;
@@ -2166,7 +2155,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                     stripe = (stripe + 1) % ci->num_stripes;
                 }
             } else if (length - pos >= ci->stripe_length * (ci->num_stripes - 1)) {
-                UINT16 stripe = (parity + 1) % ci->num_stripes;
+                uint16_t stripe = (parity + 1) % ci->num_stripes;
                 ULONG k;
 
                 while (stripe != parity) {
@@ -2174,8 +2163,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
 
                     RtlCopyMemory(&stripe_pfns[stripeoff[stripe] >> PAGE_SHIFT], &pfns[pos >> PAGE_SHIFT], (ULONG)(ci->stripe_length * sizeof(PFN_NUMBER) >> PAGE_SHIFT));
 
-                    stripeoff[stripe] += (UINT32)ci->stripe_length;
-                    pos += (UINT32)ci->stripe_length;
+                    stripeoff[stripe] += (uint32_t)ci->stripe_length;
+                    pos += (uint32_t)ci->stripe_length;
 
                     stripe = (stripe + 1) % ci->num_stripes;
                 }
@@ -2187,8 +2176,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                     stripeoff[parity] += PAGE_SIZE;
                 }
             } else {
-                UINT16 stripe = (parity + 1) % ci->num_stripes;
-                UINT32 readlen;
+                uint16_t stripe = (parity + 1) % ci->num_stripes;
+                uint32_t readlen;
 
                 while (pos < length) {
                     stripe_pfns = (PFN_NUMBER*)(context.stripes[stripe].mdl + 1);
@@ -2212,12 +2201,12 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
 
         ExFreePool(stripeoff);
     } else if (type == BLOCK_FLAG_RAID6) {
-        UINT64 startoff, endoff;
-        UINT16 endoffstripe, parity1;
-        UINT32 *stripeoff, pos;
+        uint64_t startoff, endoff;
+        uint16_t endoffstripe, parity1;
+        uint32_t *stripeoff, pos;
         PMDL master_mdl;
         PFN_NUMBER *pfns, dummy;
-        BOOL need_dummy = FALSE;
+        bool need_dummy = false;
 
         get_raid0_offset(addr - offset, ci->stripe_length, ci->num_stripes - 2, &startoff, &startoffstripe);
         get_raid0_offset(addr + length - offset - 1, ci->stripe_length, ci->num_stripes - 2, &endoff, &endoffstripe);
@@ -2233,7 +2222,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
         } else
             context.va = buf;
 
-        master_mdl = IoAllocateMdl(context.va, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl(context.va, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2261,7 +2250,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             parity1 = (((addr - offset + pos) / ((ci->num_stripes - 2) * ci->stripe_length)) + ci->num_stripes - 2) % ci->num_stripes;
 
             if (pos == 0) {
-                UINT16 stripe = (parity1 + startoffstripe + 2) % ci->num_stripes, parity2;
+                uint16_t stripe = (parity1 + startoffstripe + 2) % ci->num_stripes, parity2;
                 ULONG skip, readlen;
 
                 i = startoffstripe;
@@ -2296,7 +2285,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                     break;
 
                 for (i = 0; i < startoffstripe; i++) {
-                    UINT16 stripe2 = (parity1 + i + 2) % ci->num_stripes;
+                    uint16_t stripe2 = (parity1 + i + 2) % ci->num_stripes;
 
                     context.stripes[stripe2].stripestart = context.stripes[stripe2].stripeend = startoff - (startoff % ci->stripe_length) + ci->stripe_length;
                 }
@@ -2313,18 +2302,18 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                         context.stripes[i].stripeend += skip * ci->num_stripes * ci->stripe_length;
                     }
 
-                    pos += (UINT32)(skip * (ci->num_stripes - 2) * ci->num_stripes * ci->stripe_length);
-                    need_dummy = TRUE;
+                    pos += (uint32_t)(skip * (ci->num_stripes - 2) * ci->num_stripes * ci->stripe_length);
+                    need_dummy = true;
                 }
             } else if (length - pos >= ci->stripe_length * (ci->num_stripes - 2)) {
                 for (i = 0; i < ci->num_stripes; i++) {
                     context.stripes[i].stripeend += ci->stripe_length;
                 }
 
-                pos += (UINT32)(ci->stripe_length * (ci->num_stripes - 2));
-                need_dummy = TRUE;
+                pos += (uint32_t)(ci->stripe_length * (ci->num_stripes - 2));
+                need_dummy = true;
             } else {
-                UINT16 stripe = (parity1 + 2) % ci->num_stripes;
+                uint16_t stripe = (parity1 + 2) % ci->num_stripes;
 
                 i = 0;
                 while (stripe != parity1) {
@@ -2344,7 +2333,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
 
         for (i = 0; i < ci->num_stripes; i++) {
             if (context.stripes[i].stripestart != context.stripes[i].stripeend) {
-                context.stripes[i].mdl = IoAllocateMdl(context.va, (ULONG)(context.stripes[i].stripeend - context.stripes[i].stripestart), FALSE, FALSE, NULL);
+                context.stripes[i].mdl = IoAllocateMdl(context.va, (ULONG)(context.stripes[i].stripeend - context.stripes[i].stripestart), false, false, NULL);
 
                 if (!context.stripes[i].mdl) {
                     ERR("IoAllocateMdl failed\n");
@@ -2366,7 +2355,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                 goto exit;
             }
 
-            dummy_mdl = IoAllocateMdl(dummypage, PAGE_SIZE, FALSE, FALSE, NULL);
+            dummy_mdl = IoAllocateMdl(dummypage, PAGE_SIZE, false, false, NULL);
             if (!dummy_mdl) {
                 ERR("IoAllocateMdl failed\n");
                 MmUnlockPages(master_mdl);
@@ -2380,7 +2369,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             dummy = *(PFN_NUMBER*)(dummy_mdl + 1);
         }
 
-        stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(UINT32) * ci->num_stripes, ALLOC_TAG);
+        stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(uint32_t) * ci->num_stripes, ALLOC_TAG);
         if (!stripeoff) {
             ERR("out of memory\n");
             MmUnlockPages(master_mdl);
@@ -2389,7 +2378,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             goto exit;
         }
 
-        RtlZeroMemory(stripeoff, sizeof(UINT32) * ci->num_stripes);
+        RtlZeroMemory(stripeoff, sizeof(uint32_t) * ci->num_stripes);
 
         pos = 0;
 
@@ -2399,8 +2388,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             parity1 = (((addr - offset + pos) / ((ci->num_stripes - 2) * ci->stripe_length)) + ci->num_stripes - 2) % ci->num_stripes;
 
             if (pos == 0) {
-                UINT16 stripe = (parity1 + startoffstripe + 2) % ci->num_stripes;
-                UINT32 readlen = min(length - pos, (UINT32)min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart,
+                uint16_t stripe = (parity1 + startoffstripe + 2) % ci->num_stripes;
+                uint32_t readlen = min(length - pos, (uint32_t)min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart,
                                                        ci->stripe_length - (context.stripes[stripe].stripestart % ci->stripe_length)));
 
                 stripe_pfns = (PFN_NUMBER*)(context.stripes[stripe].mdl + 1);
@@ -2414,7 +2403,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
 
                 while (stripe != parity1) {
                     stripe_pfns = (PFN_NUMBER*)(context.stripes[stripe].mdl + 1);
-                    readlen = (UINT32)min(length - pos, min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart, ci->stripe_length));
+                    readlen = (uint32_t)min(length - pos, min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart, ci->stripe_length));
 
                     if (readlen == 0)
                         break;
@@ -2427,8 +2416,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                     stripe = (stripe + 1) % ci->num_stripes;
                 }
             } else if (length - pos >= ci->stripe_length * (ci->num_stripes - 2)) {
-                UINT16 stripe = (parity1 + 2) % ci->num_stripes;
-                UINT16 parity2 = (parity1 + 1) % ci->num_stripes;
+                uint16_t stripe = (parity1 + 2) % ci->num_stripes;
+                uint16_t parity2 = (parity1 + 1) % ci->num_stripes;
                 ULONG k;
 
                 while (stripe != parity1) {
@@ -2436,8 +2425,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
 
                     RtlCopyMemory(&stripe_pfns[stripeoff[stripe] >> PAGE_SHIFT], &pfns[pos >> PAGE_SHIFT], (ULONG)(ci->stripe_length * sizeof(PFN_NUMBER) >> PAGE_SHIFT));
 
-                    stripeoff[stripe] += (UINT32)ci->stripe_length;
-                    pos += (UINT32)ci->stripe_length;
+                    stripeoff[stripe] += (uint32_t)ci->stripe_length;
+                    pos += (uint32_t)ci->stripe_length;
 
                     stripe = (stripe + 1) % ci->num_stripes;
                 }
@@ -2456,12 +2445,12 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
                     stripeoff[parity2] += PAGE_SIZE;
                 }
             } else {
-                UINT16 stripe = (parity1 + 2) % ci->num_stripes;
-                UINT32 readlen;
+                uint16_t stripe = (parity1 + 2) % ci->num_stripes;
+                uint32_t readlen;
 
                 while (pos < length) {
                     stripe_pfns = (PFN_NUMBER*)(context.stripes[stripe].mdl + 1);
-                    readlen = (UINT32)min(length - pos, min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart, ci->stripe_length));
+                    readlen = (uint32_t)min(length - pos, min(context.stripes[stripe].stripeend - context.stripes[stripe].stripestart, ci->stripe_length));
 
                     if (readlen == 0)
                         break;
@@ -2511,7 +2500,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             }
 
             if (!Irp) {
-                context.stripes[i].Irp = IoAllocateIrp(devices[i]->devobj->StackSize, FALSE);
+                context.stripes[i].Irp = IoAllocateIrp(devices[i]->devobj->StackSize, false);
 
                 if (!context.stripes[i].Irp) {
                     ERR("IoAllocateIrp failed\n");
@@ -2530,6 +2519,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
 
             IrpSp = IoGetNextIrpStackLocation(context.stripes[i].Irp);
             IrpSp->MajorFunction = IRP_MJ_READ;
+            IrpSp->MinorFunction = IRP_MN_NORMAL;
+            IrpSp->FileObject = devices[i]->fileobj;
 
             if (devices[i]->devobj->Flags & DO_BUFFERED_IO) {
                 context.stripes[i].Irp->AssociatedIrp.SystemBuffer = ExAllocatePoolWithTag(NonPagedPool, (ULONG)(context.stripes[i].stripeend - context.stripes[i].stripestart), ALLOC_TAG);
@@ -2554,35 +2545,22 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
 
             context.stripes[i].Irp->UserIosb = &context.stripes[i].iosb;
 
-            IoSetCompletionRoutine(context.stripes[i].Irp, read_data_completion, &context.stripes[i], TRUE, TRUE, TRUE);
+            IoSetCompletionRoutine(context.stripes[i].Irp, read_data_completion, &context.stripes[i], true, true, true);
 
             context.stripes[i].status = ReadDataStatus_Pending;
         }
     }
 
-#ifdef DEBUG_STATS
-    if (!is_tree)
-        time1 = KeQueryPerformanceCounter(NULL);
-#endif
-
-    need_to_wait = FALSE;
+    need_to_wait = false;
     for (i = 0; i < ci->num_stripes; i++) {
         if (context.stripes[i].status != ReadDataStatus_MissingDevice && context.stripes[i].status != ReadDataStatus_Skip) {
             IoCallDriver(devices[i]->devobj, context.stripes[i].Irp);
-            need_to_wait = TRUE;
+            need_to_wait = true;
         }
     }
 
     if (need_to_wait)
-        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
-
-#ifdef DEBUG_STATS
-    if (!is_tree) {
-        time2 = KeQueryPerformanceCounter(NULL);
-
-        Vcb->stats.read_disk_time += time2.QuadPart - time1.QuadPart;
-    }
-#endif
+        KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
 
     if (diskacc)
         fFsRtlUpdateDiskCounters(total_reading, 0);
@@ -2643,7 +2621,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             ExFreePool(context.va);
         }
     } else if (type == BLOCK_FLAG_RAID5) {
-        Status = read_data_raid5(Vcb, file_read ? context.va : buf, addr, length, &context, ci, devices, offset, generation, c, missing_devices > 0 ? TRUE : FALSE);
+        Status = read_data_raid5(Vcb, file_read ? context.va : buf, addr, length, &context, ci, devices, offset, generation, c, missing_devices > 0 ? true : false);
         if (!NT_SUCCESS(Status)) {
             ERR("read_data_raid5 returned %08x\n", Status);
 
@@ -2658,7 +2636,7 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
             ExFreePool(context.va);
         }
     } else if (type == BLOCK_FLAG_RAID6) {
-        Status = read_data_raid6(Vcb, file_read ? context.va : buf, addr, length, &context, ci, devices, offset, generation, c, missing_devices > 0 ? TRUE : FALSE);
+        Status = read_data_raid6(Vcb, file_read ? context.va : buf, addr, length, &context, ci, devices, offset, generation, c, missing_devices > 0 ? true : false);
         if (!NT_SUCCESS(Status)) {
             ERR("read_data_raid6 returned %08x\n", Status);
 
@@ -2704,10 +2682,10 @@ exit:
     return Status;
 }
 
-NTSTATUS read_stream(fcb* fcb, UINT8* data, UINT64 start, ULONG length, ULONG* pbr) {
+NTSTATUS read_stream(fcb* fcb, uint8_t* data, uint64_t start, ULONG length, ULONG* pbr) {
     ULONG readlen;
 
-    TRACE("(%p, %p, %llx, %llx, %p)\n", fcb, data, start, length, pbr);
+    TRACE("(%p, %p, %I64x, %I64x, %p)\n", fcb, data, start, length, pbr);
 
     if (pbr) *pbr = 0;
 
@@ -2734,17 +2712,15 @@ NTSTATUS read_stream(fcb* fcb, UINT8* data, UINT64 start, ULONG length, ULONG* p
     return STATUS_SUCCESS;
 }
 
-NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pbr, PIRP Irp) {
+NTSTATUS read_file(fcb* fcb, uint8_t* data, uint64_t start, uint64_t length, ULONG* pbr, PIRP Irp) {
     NTSTATUS Status;
     EXTENT_DATA* ed;
-    UINT32 bytes_read = 0;
-    UINT64 last_end;
+    uint32_t bytes_read = 0;
+    uint64_t last_end;
     LIST_ENTRY* le;
-#ifdef DEBUG_STATS
-    LARGE_INTEGER time1, time2;
-#endif
+    POOL_TYPE pool_type;
 
-    TRACE("(%p, %p, %llx, %llx, %p)\n", fcb, data, start, length, pbr);
+    TRACE("(%p, %p, %I64x, %I64x, %p)\n", fcb, data, start, length, pbr);
 
     if (pbr)
         *pbr = 0;
@@ -2755,16 +2731,14 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb
         goto exit;
     }
 
-#ifdef DEBUG_STATS
-    time1 = KeQueryPerformanceCounter(NULL);
-#endif
+    pool_type = fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE ? NonPagedPool : PagedPool;
 
     le = fcb->extents.Flink;
 
     last_end = start;
 
     while (le != &fcb->extents) {
-        UINT64 len;
+        uint64_t len;
         extent* ext = CONTAINING_RECORD(le, extent, list_entry);
         EXTENT_DATA2* ed2;
 
@@ -2781,7 +2755,7 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb
             }
 
             if (ext->offset > last_end && ext->offset > start + bytes_read) {
-                UINT32 read = (UINT32)min(length, ext->offset - max(start, last_end));
+                uint32_t read = (uint32_t)min(length, ext->offset - max(start, last_end));
 
                 RtlZeroMemory(data + bytes_read, read);
                 bytes_read += read;
@@ -2806,64 +2780,64 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb
             switch (ed->type) {
                 case EXTENT_TYPE_INLINE:
                 {
-                    UINT64 off = start + bytes_read - ext->offset;
-                    UINT32 read;
+                    uint64_t off = start + bytes_read - ext->offset;
+                    uint32_t read;
 
                     if (ed->compression == BTRFS_COMPRESSION_NONE) {
-                        read = (UINT32)min(min(len, ext->datalen) - off, length);
+                        read = (uint32_t)min(min(len, ext->datalen) - off, length);
 
                         RtlCopyMemory(data + bytes_read, &ed->data[off], read);
                     } else if (ed->compression == BTRFS_COMPRESSION_ZLIB || ed->compression == BTRFS_COMPRESSION_LZO || ed->compression == BTRFS_COMPRESSION_ZSTD) {
-                        UINT8* decomp;
-                        BOOL decomp_alloc;
-                        UINT16 inlen = ext->datalen - (UINT16)offsetof(EXTENT_DATA, data[0]);
+                        uint8_t* decomp;
+                        bool decomp_alloc;
+                        uint16_t inlen = ext->datalen - (uint16_t)offsetof(EXTENT_DATA, data[0]);
 
                         if (ed->decoded_size == 0 || ed->decoded_size > 0xffffffff) {
-                            ERR("ed->decoded_size was invalid (%llx)\n", ed->decoded_size);
+                            ERR("ed->decoded_size was invalid (%I64x)\n", ed->decoded_size);
                             Status = STATUS_INTERNAL_ERROR;
                             goto exit;
                         }
 
-                        read = (UINT32)min(ed->decoded_size - off, length);
+                        read = (uint32_t)min(ed->decoded_size - off, length);
 
                         if (off > 0) {
-                            decomp = ExAllocatePoolWithTag(NonPagedPool, (UINT32)ed->decoded_size, ALLOC_TAG);
+                            decomp = ExAllocatePoolWithTag(NonPagedPool, (uint32_t)ed->decoded_size, ALLOC_TAG);
                             if (!decomp) {
                                 ERR("out of memory\n");
                                 Status = STATUS_INSUFFICIENT_RESOURCES;
                                 goto exit;
                             }
 
-                            decomp_alloc = TRUE;
+                            decomp_alloc = true;
                         } else {
                             decomp = data + bytes_read;
-                            decomp_alloc = FALSE;
+                            decomp_alloc = false;
                         }
 
                         if (ed->compression == BTRFS_COMPRESSION_ZLIB) {
-                            Status = zlib_decompress(ed->data, inlen, decomp, (UINT32)(read + off));
+                            Status = zlib_decompress(ed->data, inlen, decomp, (uint32_t)(read + off));
                             if (!NT_SUCCESS(Status)) {
                                 ERR("zlib_decompress returned %08x\n", Status);
                                 if (decomp_alloc) ExFreePool(decomp);
                                 goto exit;
                             }
                         } else if (ed->compression == BTRFS_COMPRESSION_LZO) {
-                            if (inlen < sizeof(UINT32)) {
+                            if (inlen < sizeof(uint32_t)) {
                                 ERR("extent data was truncated\n");
                                 Status = STATUS_INTERNAL_ERROR;
                                 if (decomp_alloc) ExFreePool(decomp);
                                 goto exit;
                             } else
-                                inlen -= sizeof(UINT32);
+                                inlen -= sizeof(uint32_t);
 
-                            Status = lzo_decompress(ed->data + sizeof(UINT32), inlen, decomp, (UINT32)(read + off), sizeof(UINT32));
+                            Status = lzo_decompress(ed->data + sizeof(uint32_t), inlen, decomp, (uint32_t)(read + off), sizeof(uint32_t));
                             if (!NT_SUCCESS(Status)) {
                                 ERR("lzo_decompress returned %08x\n", Status);
                                 if (decomp_alloc) ExFreePool(decomp);
                                 goto exit;
                             }
                         } else if (ed->compression == BTRFS_COMPRESSION_ZSTD) {
-                            Status = zstd_decompress(ed->data, inlen, decomp, (UINT32)(read + off));
+                            Status = zstd_decompress(ed->data, inlen, decomp, (uint32_t)(read + off));
                             if (!NT_SUCCESS(Status)) {
                                 ERR("zstd_decompress returned %08x\n", Status);
                                 if (decomp_alloc) ExFreePool(decomp);
@@ -2889,39 +2863,39 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb
 
                 case EXTENT_TYPE_REGULAR:
                 {
-                    UINT64 off = start + bytes_read - ext->offset;
-                    UINT32 to_read, read;
-                    UINT8* buf;
-                    BOOL mdl = (Irp && Irp->MdlAddress) ? TRUE : FALSE;
-                    BOOL buf_free;
-                    UINT32 bumpoff = 0, *csum;
-                    UINT64 addr;
+                    uint64_t off = start + bytes_read - ext->offset;
+                    uint32_t to_read, read;
+                    uint8_t* buf;
+                    bool mdl = (Irp && Irp->MdlAddress) ? true : false;
+                    bool buf_free;
+                    uint32_t bumpoff = 0, *csum;
+                    uint64_t addr;
                     chunk* c;
 
-                    read = (UINT32)(len - off);
-                    if (read > length) read = (UINT32)length;
+                    read = (uint32_t)(len - off);
+                    if (read > length) read = (uint32_t)length;
 
                     if (ed->compression == BTRFS_COMPRESSION_NONE) {
                         addr = ed2->address + ed2->offset + off;
-                        to_read = (UINT32)sector_align(read, fcb->Vcb->superblock.sector_size);
+                        to_read = (uint32_t)sector_align(read, fcb->Vcb->superblock.sector_size);
 
                         if (addr % fcb->Vcb->superblock.sector_size > 0) {
                             bumpoff = addr % fcb->Vcb->superblock.sector_size;
                             addr -= bumpoff;
-                            to_read = (UINT32)sector_align(read + bumpoff, fcb->Vcb->superblock.sector_size);
+                            to_read = (uint32_t)sector_align(read + bumpoff, fcb->Vcb->superblock.sector_size);
                         }
                     } else {
                         addr = ed2->address;
-                        to_read = (UINT32)sector_align(ed2->size, fcb->Vcb->superblock.sector_size);
+                        to_read = (uint32_t)sector_align(ed2->size, fcb->Vcb->superblock.sector_size);
                     }
 
                     if (ed->compression == BTRFS_COMPRESSION_NONE && start % fcb->Vcb->superblock.sector_size == 0 &&
                         length % fcb->Vcb->superblock.sector_size == 0) {
                         buf = data + bytes_read;
-                        buf_free = FALSE;
+                        buf_free = false;
                     } else {
-                        buf = ExAllocatePoolWithTag(PagedPool, to_read, ALLOC_TAG);
-                        buf_free = TRUE;
+                        buf = ExAllocatePoolWithTag(pool_type, to_read, ALLOC_TAG);
+                        buf_free = true;
 
                         if (!buf) {
                             ERR("out of memory\n");
@@ -2929,13 +2903,13 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb
                             goto exit;
                         }
 
-                        mdl = FALSE;
+                        mdl = false;
                     }
 
                     c = get_chunk_from_address(fcb->Vcb, addr);
 
                     if (!c) {
-                        ERR("get_chunk_from_address(%llx) failed\n", addr);
+                        ERR("get_chunk_from_address(%I64x) failed\n", addr);
 
                         if (buf_free)
                             ExFreePool(buf);
@@ -2951,7 +2925,7 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb
                     } else
                         csum = NULL;
 
-                    Status = read_data(fcb->Vcb, addr, to_read, csum, FALSE, buf, c, NULL, Irp, 0, mdl,
+                    Status = read_data(fcb->Vcb, addr, to_read, csum, false, buf, c, NULL, Irp, 0, mdl,
                                        fcb && fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE ? HighPagePriority : NormalPagePriority);
                     if (!NT_SUCCESS(Status)) {
                         ERR("read_data returned %08x\n", Status);
@@ -2966,47 +2940,47 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb
                         if (buf_free)
                             RtlCopyMemory(data + bytes_read, buf + bumpoff, read);
                     } else {
-                        UINT8 *decomp = NULL, *buf2;
+                        uint8_t *decomp = NULL, *buf2;
                         ULONG outlen, inlen, off2;
-                        UINT32 inpageoff = 0;
+                        uint32_t inpageoff = 0;
 
                         off2 = (ULONG)(ed2->offset + off);
                         buf2 = buf;
                         inlen = (ULONG)ed2->size;
 
                         if (ed->compression == BTRFS_COMPRESSION_LZO) {
-                            ULONG inoff = sizeof(UINT32);
+                            ULONG inoff = sizeof(uint32_t);
 
-                            inlen -= sizeof(UINT32);
+                            inlen -= sizeof(uint32_t);
 
                             // If reading a few sectors in, skip to the interesting bit
-                            while (off2 > LINUX_PAGE_SIZE) {
-                                UINT32 partlen;
+                            while (off2 > LZO_PAGE_SIZE) {
+                                uint32_t partlen;
 
-                                if (inlen < sizeof(UINT32))
+                                if (inlen < sizeof(uint32_t))
                                     break;
 
-                                partlen = *(UINT32*)(buf2 + inoff);
+                                partlen = *(uint32_t*)(buf2 + inoff);
 
                                 if (partlen < inlen) {
-                                    off2 -= LINUX_PAGE_SIZE;
-                                    inoff += partlen + sizeof(UINT32);
-                                    inlen -= partlen + sizeof(UINT32);
+                                    off2 -= LZO_PAGE_SIZE;
+                                    inoff += partlen + sizeof(uint32_t);
+                                    inlen -= partlen + sizeof(uint32_t);
 
-                                    if (LINUX_PAGE_SIZE - (inoff % LINUX_PAGE_SIZE) < sizeof(UINT32))
-                                        inoff = ((inoff / LINUX_PAGE_SIZE) + 1) * LINUX_PAGE_SIZE;
+                                    if (LZO_PAGE_SIZE - (inoff % LZO_PAGE_SIZE) < sizeof(uint32_t))
+                                        inoff = ((inoff / LZO_PAGE_SIZE) + 1) * LZO_PAGE_SIZE;
                                 } else
                                     break;
                             }
 
                             buf2 = &buf2[inoff];
-                            inpageoff = inoff % LINUX_PAGE_SIZE;
+                            inpageoff = inoff % LZO_PAGE_SIZE;
                         }
 
                         if (off2 != 0) {
-                            outlen = off2 + min(read, (UINT32)(ed2->num_bytes - off));
+                            outlen = off2 + min(read, (uint32_t)(ed2->num_bytes - off));
 
-                            decomp = ExAllocatePoolWithTag(PagedPool, outlen, ALLOC_TAG);
+                            decomp = ExAllocatePoolWithTag(pool_type, outlen, ALLOC_TAG);
                             if (!decomp) {
                                 ERR("out of memory\n");
                                 ExFreePool(buf);
@@ -3014,7 +2988,7 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb
                                 goto exit;
                             }
                         } else
-                            outlen = min(read, (UINT32)(ed2->num_bytes - off));
+                            outlen = min(read, (uint32_t)(ed2->num_bytes - off));
 
                         if (ed->compression == BTRFS_COMPRESSION_ZLIB) {
                             Status = zlib_decompress(buf2, inlen, decomp ? decomp : (data + bytes_read), outlen);
@@ -3081,10 +3055,10 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb
 
                 case EXTENT_TYPE_PREALLOC:
                 {
-                    UINT64 off = start + bytes_read - ext->offset;
-                    UINT32 read = (UINT32)(len - off);
+                    uint64_t off = start + bytes_read - ext->offset;
+                    uint32_t read = (uint32_t)(len - off);
 
-                    if (read > length) read = (UINT32)length;
+                    if (read > length) read = (uint32_t)length;
 
                     RtlZeroMemory(data + bytes_read, read);
 
@@ -3111,7 +3085,7 @@ nextitem:
     }
 
     if (length > 0 && start + bytes_read < fcb->inode_item.st_size) {
-        UINT32 read = (UINT32)min(fcb->inode_item.st_size - start - bytes_read, length);
+        uint32_t read = (uint32_t)min(fcb->inode_item.st_size - start - bytes_read, length);
 
         RtlZeroMemory(data + bytes_read, read);
 
@@ -3123,25 +3097,17 @@ nextitem:
     if (pbr)
         *pbr = bytes_read;
 
-#ifdef DEBUG_STATS
-    time2 = KeQueryPerformanceCounter(NULL);
-
-    fcb->Vcb->stats.num_reads++;
-    fcb->Vcb->stats.data_read += bytes_read;
-    fcb->Vcb->stats.read_total_time += time2.QuadPart - time1.QuadPart;
-#endif
-
 exit:
     return Status;
 }
 
-NTSTATUS do_read(PIRP Irp, BOOLEAN wait, ULONG* bytes_read) {
+NTSTATUS do_read(PIRP Irp, bool wait, ULONG* bytes_read) {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     fcb* fcb = FileObject->FsContext;
-    UINT8* data = NULL;
+    uint8_t* data = NULL;
     ULONG length = IrpSp->Parameters.Read.Length, addon = 0;
-    UINT64 start = IrpSp->Parameters.Read.ByteOffset.QuadPart;
+    uint64_t start = IrpSp->Parameters.Read.ByteOffset.QuadPart;
 
     *bytes_read = 0;
 
@@ -3149,8 +3115,8 @@ NTSTATUS do_read(PIRP Irp, BOOLEAN wait, ULONG* bytes_read) {
         return STATUS_INTERNAL_ERROR;
 
     TRACE("file = %S (fcb = %p)\n", file_desc(FileObject), fcb);
-    TRACE("offset = %llx, length = %x\n", start, length);
-    TRACE("paging_io = %s, no cache = %s\n", Irp->Flags & IRP_PAGING_IO ? "TRUE" : "FALSE", Irp->Flags & IRP_NOCACHE ? "TRUE" : "FALSE");
+    TRACE("offset = %I64x, length = %x\n", start, length);
+    TRACE("paging_io = %s, no cache = %s\n", Irp->Flags & IRP_PAGING_IO ? "true" : "false", Irp->Flags & IRP_NOCACHE ? "true" : "false");
 
     if (!fcb->ads && fcb->type == BTRFS_TYPE_DIRECTORY)
         return STATUS_INVALID_DEVICE_REQUEST;
@@ -3165,12 +3131,12 @@ NTSTATUS do_read(PIRP Irp, BOOLEAN wait, ULONG* bytes_read) {
         return STATUS_SUCCESS;
     }
 
-    if (start >= (UINT64)fcb->Header.FileSize.QuadPart) {
-        TRACE("tried to read with offset after file end (%llx >= %llx)\n", start, fcb->Header.FileSize.QuadPart);
+    if (start >= (uint64_t)fcb->Header.FileSize.QuadPart) {
+        TRACE("tried to read with offset after file end (%I64x >= %I64x)\n", start, fcb->Header.FileSize.QuadPart);
         return STATUS_END_OF_FILE;
     }
 
-    TRACE("FileObject %p fcb %p FileSize = %llx st_size = %llx (%p)\n", FileObject, fcb, fcb->Header.FileSize.QuadPart, fcb->inode_item.st_size, &fcb->inode_item.st_size);
+    TRACE("FileObject %p fcb %p FileSize = %I64x st_size = %I64x (%p)\n", FileObject, fcb, fcb->Header.FileSize.QuadPart, fcb->inode_item.st_size, &fcb->inode_item.st_size);
 
     if (Irp->Flags & IRP_NOCACHE || !(IrpSp->MinorFunction & IRP_MN_MDL)) {
         data = map_user_buffer(Irp, fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE ? HighPagePriority : NormalPagePriority);
@@ -3180,15 +3146,15 @@ NTSTATUS do_read(PIRP Irp, BOOLEAN wait, ULONG* bytes_read) {
             return STATUS_INSUFFICIENT_RESOURCES;
         }
 
-        if (start >= (UINT64)fcb->Header.ValidDataLength.QuadPart) {
-            length = (ULONG)min(length, min(start + length, (UINT64)fcb->Header.FileSize.QuadPart) - fcb->Header.ValidDataLength.QuadPart);
+        if (start >= (uint64_t)fcb->Header.ValidDataLength.QuadPart) {
+            length = (ULONG)min(length, min(start + length, (uint64_t)fcb->Header.FileSize.QuadPart) - fcb->Header.ValidDataLength.QuadPart);
             RtlZeroMemory(data, length);
             Irp->IoStatus.Information = *bytes_read = length;
             return STATUS_SUCCESS;
         }
 
-        if (length + start > (UINT64)fcb->Header.ValidDataLength.QuadPart) {
-            addon = (ULONG)(min(start + length, (UINT64)fcb->Header.FileSize.QuadPart) - fcb->Header.ValidDataLength.QuadPart);
+        if (length + start > (uint64_t)fcb->Header.ValidDataLength.QuadPart) {
+            addon = (ULONG)(min(start + length, (uint64_t)fcb->Header.FileSize.QuadPart) - fcb->Header.ValidDataLength.QuadPart);
             RtlZeroMemory(data + (fcb->Header.ValidDataLength.QuadPart - start), addon);
             length = (ULONG)(fcb->Header.ValidDataLength.QuadPart - start);
         }
@@ -3212,9 +3178,9 @@ NTSTATUS do_read(PIRP Irp, BOOLEAN wait, ULONG* bytes_read) {
                 CcMdlRead(FileObject,&IrpSp->Parameters.Read.ByteOffset, length, &Irp->MdlAddress, &Irp->IoStatus);
             } else {
                 if (fCcCopyReadEx) {
-                    TRACE("CcCopyReadEx(%p, %llx, %x, %u, %p, %p, %p, %p)\n", FileObject, IrpSp->Parameters.Read.ByteOffset.QuadPart,
+                    TRACE("CcCopyReadEx(%p, %I64x, %x, %u, %p, %p, %p, %p)\n", FileObject, IrpSp->Parameters.Read.ByteOffset.QuadPart,
                           length, wait, data, &Irp->IoStatus, Irp->Tail.Overlay.Thread);
-                    TRACE("sizes = %llx, %llx, %llx\n", fcb->Header.AllocationSize, fcb->Header.FileSize, fcb->Header.ValidDataLength);
+                    TRACE("sizes = %I64x, %I64x, %I64x\n", fcb->Header.AllocationSize, fcb->Header.FileSize, fcb->Header.ValidDataLength);
                     if (!fCcCopyReadEx(FileObject, &IrpSp->Parameters.Read.ByteOffset, length, wait, data, &Irp->IoStatus, Irp->Tail.Overlay.Thread)) {
                         TRACE("CcCopyReadEx could not wait\n");
 
@@ -3223,8 +3189,8 @@ NTSTATUS do_read(PIRP Irp, BOOLEAN wait, ULONG* bytes_read) {
                     }
                     TRACE("CcCopyReadEx finished\n");
                 } else {
-                    TRACE("CcCopyRead(%p, %llx, %x, %u, %p, %p)\n", FileObject, IrpSp->Parameters.Read.ByteOffset.QuadPart, length, wait, data, &Irp->IoStatus);
-                    TRACE("sizes = %llx, %llx, %llx\n", fcb->Header.AllocationSize, fcb->Header.FileSize, fcb->Header.ValidDataLength);
+                    TRACE("CcCopyRead(%p, %I64x, %x, %u, %p, %p)\n", FileObject, IrpSp->Parameters.Read.ByteOffset.QuadPart, length, wait, data, &Irp->IoStatus);
+                    TRACE("sizes = %I64x, %I64x, %I64x\n", fcb->Header.AllocationSize, fcb->Header.FileSize, fcb->Header.ValidDataLength);
                     if (!CcCopyRead(FileObject, &IrpSp->Parameters.Read.ByteOffset, length, wait, data, &Irp->IoStatus)) {
                         TRACE("CcCopyRead could not wait\n");
 
@@ -3284,16 +3250,16 @@ NTSTATUS do_read(PIRP Irp, BOOLEAN wait, ULONG* bytes_read) {
 
 _Dispatch_type_(IRP_MJ_READ)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_read(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
+NTSTATUS __stdcall drv_read(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
     device_extension* Vcb = DeviceObject->DeviceExtension;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     ULONG bytes_read = 0;
     NTSTATUS Status;
-    BOOL top_level;
+    bool top_level;
     fcb* fcb;
     ccb* ccb;
-    BOOLEAN fcb_lock = FALSE, wait;
+    bool acquired_fcb_lock = false, wait;
 
     FsRtlEnterFileSystem();
 
@@ -3357,7 +3323,7 @@ NTSTATUS NTAPI drv_read(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
     // Don't offload jobs when doing paging IO - otherwise this can lead to
     // deadlocks in CcCopyRead.
     if (Irp->Flags & IRP_PAGING_IO)
-        wait = TRUE;
+        wait = true;
 
     if (!(Irp->Flags & IRP_PAGING_IO) && FileObject->SectionObjectPointer && FileObject->SectionObjectPointer->DataSectionObject) {
         IO_STATUS_BLOCK iosb;
@@ -3376,12 +3342,12 @@ NTSTATUS NTAPI drv_read(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
             goto exit;
         }
 
-        fcb_lock = TRUE;
+        acquired_fcb_lock = true;
     }
 
     Status = do_read(Irp, wait, &bytes_read);
 
-    if (fcb_lock)
+    if (acquired_fcb_lock)
         ExReleaseResourceLite(fcb->Header.Resource);
 
 exit:
@@ -3399,7 +3365,7 @@ end:
         IoCompleteRequest(Irp, IO_NO_INCREMENT);
     else {
         if (!add_thread_job(Vcb, Irp))
-            do_read_job(Irp);
+            Status = do_read_job(Irp);
     }
 
 exit2:
diff --git a/drivers/filesystems/btrfs/registry.c b/drivers/filesystems/btrfs/registry.c
index 84196df0026..a13baf35aba 100644
--- a/drivers/filesystems/btrfs/registry.c
+++ b/drivers/filesystems/btrfs/registry.c
@@ -133,64 +133,64 @@ NTSTATUS registry_load_volume_options(device_extension* Vcb) {
             us.Length = us.MaximumLength = (USHORT)kvfi->NameLength;
             us.Buffer = kvfi->Name;
 
-            if (FsRtlAreNamesEqual(&ignoreus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+            if (FsRtlAreNamesEqual(&ignoreus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
-                options->ignore = *val != 0 ? TRUE : FALSE;
-            } else if (FsRtlAreNamesEqual(&compressus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+                options->ignore = *val != 0 ? true : false;
+            } else if (FsRtlAreNamesEqual(&compressus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
-                options->compress = *val != 0 ? TRUE : FALSE;
-            } else if (FsRtlAreNamesEqual(&compressforceus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+                options->compress = *val != 0 ? true : false;
+            } else if (FsRtlAreNamesEqual(&compressforceus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
-                options->compress_force = *val != 0 ? TRUE : FALSE;
-            } else if (FsRtlAreNamesEqual(&compresstypeus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+                options->compress_force = *val != 0 ? true : false;
+            } else if (FsRtlAreNamesEqual(&compresstypeus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
-                options->compress_type = (UINT8)(*val > BTRFS_COMPRESSION_ZSTD ? 0 : *val);
-            } else if (FsRtlAreNamesEqual(&readonlyus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+                options->compress_type = (uint8_t)(*val > BTRFS_COMPRESSION_ZSTD ? 0 : *val);
+            } else if (FsRtlAreNamesEqual(&readonlyus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
-                options->readonly = *val != 0 ? TRUE : FALSE;
-            } else if (FsRtlAreNamesEqual(&zliblevelus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+                options->readonly = *val != 0 ? true : false;
+            } else if (FsRtlAreNamesEqual(&zliblevelus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
                 options->zlib_level = *val;
-            } else if (FsRtlAreNamesEqual(&flushintervalus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+            } else if (FsRtlAreNamesEqual(&flushintervalus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
                 options->flush_interval = *val;
-            } else if (FsRtlAreNamesEqual(&maxinlineus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+            } else if (FsRtlAreNamesEqual(&maxinlineus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
                 options->max_inline = min(*val, Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node) - sizeof(EXTENT_DATA) + 1);
-            } else if (FsRtlAreNamesEqual(&subvolidus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_QWORD) {
-                UINT64* val = (UINT64*)((UINT8*)kvfi + kvfi->DataOffset);
+            } else if (FsRtlAreNamesEqual(&subvolidus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_QWORD) {
+                uint64_t* val = (uint64_t*)((uint8_t*)kvfi + kvfi->DataOffset);
 
                 options->subvol_id = *val;
-            } else if (FsRtlAreNamesEqual(&skipbalanceus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+            } else if (FsRtlAreNamesEqual(&skipbalanceus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
                 options->skip_balance = *val;
-            } else if (FsRtlAreNamesEqual(&nobarrierus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+            } else if (FsRtlAreNamesEqual(&nobarrierus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
                 options->no_barrier = *val;
-            } else if (FsRtlAreNamesEqual(&notrimus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+            } else if (FsRtlAreNamesEqual(&notrimus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
                 options->no_trim = *val;
-            } else if (FsRtlAreNamesEqual(&clearcacheus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+            } else if (FsRtlAreNamesEqual(&clearcacheus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
                 options->clear_cache = *val;
-            } else if (FsRtlAreNamesEqual(&allowdegradedus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+            } else if (FsRtlAreNamesEqual(&allowdegradedus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
                 options->allow_degraded = *val;
-            } else if (FsRtlAreNamesEqual(&zstdlevelus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
+            } else if (FsRtlAreNamesEqual(&zstdlevelus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
+                DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
 
                 options->zstd_level = *val;
             }
@@ -201,12 +201,12 @@ NTSTATUS registry_load_volume_options(device_extension* Vcb) {
     } while (NT_SUCCESS(Status));
 
     if (!options->compress && options->compress_force)
-        options->compress = TRUE;
+        options->compress = true;
 
     if (options->zlib_level > 9)
         options->zlib_level = 9;
 
-    if (options->zstd_level > (UINT32)ZSTD_maxCLevel())
+    if (options->zstd_level > (uint32_t)ZSTD_maxCLevel())
         options->zstd_level = ZSTD_maxCLevel();
 
     if (options->flush_interval == 0)
@@ -296,7 +296,7 @@ static NTSTATUS registry_mark_volume_unmounted_path(PUNICODE_STRING path) {
     NTSTATUS Status;
     ULONG index, kvbilen = sizeof(KEY_VALUE_BASIC_INFORMATION) - sizeof(WCHAR) + (255 * sizeof(WCHAR)), retlen;
     KEY_VALUE_BASIC_INFORMATION* kvbi;
-    BOOL has_options = FALSE;
+    bool has_options = false;
     UNICODE_STRING mountedus;
 
     // If a volume key has any options in it, we set Mounted to 0 and return. Otherwise,
@@ -332,8 +332,8 @@ static NTSTATUS registry_mark_volume_unmounted_path(PUNICODE_STRING path) {
             us.Length = us.MaximumLength = (USHORT)kvbi->NameLength;
             us.Buffer = kvbi->Name;
 
-            if (!FsRtlAreNamesEqual(&mountedus, &us, TRUE, NULL)) {
-                has_options = TRUE;
+            if (!FsRtlAreNamesEqual(&mountedus, &us, true, NULL)) {
+                has_options = true;
                 break;
             }
         } else if (Status != STATUS_NO_MORE_ENTRIES) {
@@ -416,21 +416,21 @@ end:
 
 #define is_hex(c) ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
 
-static BOOL is_uuid(ULONG namelen, WCHAR* name) {
+static bool is_uuid(ULONG namelen, WCHAR* name) {
     ULONG i;
 
     if (namelen != 36 * sizeof(WCHAR))
-        return FALSE;
+        return false;
 
     for (i = 0; i < 36; i++) {
         if (i == 8 || i == 13 || i == 18 || i == 23) {
             if (name[i] != '-')
-                return FALSE;
+                return false;
         } else if (!is_hex(name[i]))
-            return FALSE;
+            return false;
     }
 
-    return TRUE;
+    return true;
 }
 
 typedef struct {
@@ -552,7 +552,7 @@ static void read_mappings(PUNICODE_STRING regpath) {
     }
 
     RtlCopyMemory(path, regpath->Buffer, regpath->Length);
-    RtlCopyMemory((UINT8*)path + regpath->Length, mappings, sizeof(mappings) - sizeof(WCHAR));
+    RtlCopyMemory((uint8_t*)path + regpath->Length, mappings, sizeof(mappings) - sizeof(WCHAR));
 
     us.Buffer = path;
     us.Length = us.MaximumLength = regpath->Length + sizeof(mappings) - sizeof(WCHAR);
@@ -586,9 +586,9 @@ static void read_mappings(PUNICODE_STRING regpath) {
             Status = ZwEnumerateValueKey(h, i, KeyValueFullInformation, kvfi, kvfilen, &retlen);
 
             if (NT_SUCCESS(Status) && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                UINT32 val = 0;
+                uint32_t val = 0;
 
-                RtlCopyMemory(&val, (UINT8*)kvfi + kvfi->DataOffset, min(kvfi->DataLength, sizeof(UINT32)));
+                RtlCopyMemory(&val, (uint8_t*)kvfi + kvfi->DataOffset, min(kvfi->DataLength, sizeof(uint32_t)));
 
                 TRACE("entry %u = %.*S = %u\n", i, kvfi->NameLength / sizeof(WCHAR), kvfi->Name, val);
 
@@ -630,7 +630,7 @@ static void read_group_mappings(PUNICODE_STRING regpath) {
     }
 
     RtlCopyMemory(path, regpath->Buffer, regpath->Length);
-    RtlCopyMemory((UINT8*)path + regpath->Length, mappings, sizeof(mappings) - sizeof(WCHAR));
+    RtlCopyMemory((uint8_t*)path + regpath->Length, mappings, sizeof(mappings) - sizeof(WCHAR));
 
     us.Buffer = path;
     us.Length = us.MaximumLength = regpath->Length + sizeof(mappings) - sizeof(WCHAR);
@@ -665,9 +665,9 @@ static void read_group_mappings(PUNICODE_STRING regpath) {
             Status = ZwEnumerateValueKey(h, i, KeyValueFullInformation, kvfi, kvfilen, &retlen);
 
             if (NT_SUCCESS(Status) && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
-                UINT32 val = 0;
+                uint32_t val = 0;
 
-                RtlCopyMemory(&val, (UINT8*)kvfi + kvfi->DataOffset, min(kvfi->DataLength, sizeof(UINT32)));
+                RtlCopyMemory(&val, (uint8_t*)kvfi + kvfi->DataOffset, min(kvfi->DataLength, sizeof(uint32_t)));
 
                 TRACE("entry %u = %.*S = %u\n", i, kvfi->NameLength / sizeof(WCHAR), kvfi->Name, val);
 
@@ -734,7 +734,7 @@ static void get_registry_value(HANDLE h, WCHAR* string, ULONG type, void* val, U
 
         if (NT_SUCCESS(Status)) {
             if (kvfi->Type == type && kvfi->DataLength >= size) {
-                RtlCopyMemory(val, ((UINT8*)kvfi) + kvfi->DataOffset, size);
+                RtlCopyMemory(val, ((uint8_t*)kvfi) + kvfi->DataOffset, size);
             } else {
                 Status = ZwDeleteValueKey(h, &us);
                 if (!NT_SUCCESS(Status)) {
@@ -760,7 +760,7 @@ static void get_registry_value(HANDLE h, WCHAR* string, ULONG type, void* val, U
     }
 }
 
-void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
+void read_registry(PUNICODE_STRING regpath, bool refresh) {
     OBJECT_ATTRIBUTES oa;
     NTSTATUS Status;
     HANDLE h;
@@ -773,7 +773,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
     static const WCHAR def_log_file[] = L"\\??\\C:\\btrfs.log";
 #endif
 
-    ExAcquireResourceExclusiveLite(&mapping_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&mapping_lock, true);
 
     read_mappings(regpath);
     read_group_mappings(regpath);
@@ -849,7 +849,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
                     return;
                 }
 
-                RtlCopyMemory(log_device.Buffer, ((UINT8*)kvfi) + kvfi->DataOffset, log_device.Length);
+                RtlCopyMemory(log_device.Buffer, ((uint8_t*)kvfi) + kvfi->DataOffset, log_device.Length);
 
                 if (log_device.Buffer[(log_device.Length / sizeof(WCHAR)) - 1] == 0)
                     log_device.Length -= sizeof(WCHAR);
@@ -868,7 +868,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
         ERR("ZwQueryValueKey returned %08x\n", Status);
     }
 
-    ExAcquireResourceExclusiveLite(&log_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&log_lock, true);
 
     if (refresh && (log_device.Length != old_log_device.Length || RtlCompareMemory(log_device.Buffer, old_log_device.Buffer, log_device.Length) != log_device.Length ||
         (!comfo && log_device.Length > 0) || (old_debug_log_level == 0 && debug_log_level > 0) || (old_debug_log_level > 0 && debug_log_level == 0))) {
@@ -926,7 +926,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
                     return;
                 }
 
-                RtlCopyMemory(log_file.Buffer, ((UINT8*)kvfi) + kvfi->DataOffset, log_file.Length);
+                RtlCopyMemory(log_file.Buffer, ((uint8_t*)kvfi) + kvfi->DataOffset, log_file.Length);
 
                 if (log_file.Buffer[(log_file.Length / sizeof(WCHAR)) - 1] == 0)
                     log_file.Length -= sizeof(WCHAR);
@@ -970,7 +970,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
         RtlCopyMemory(log_file.Buffer, def_log_file, log_file.Length);
     }
 
-    ExAcquireResourceExclusiveLite(&log_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&log_lock, true);
 
     if (refresh && (log_file.Length != old_log_file.Length || RtlCompareMemory(log_file.Buffer, old_log_file.Buffer, log_file.Length) != log_file.Length ||
         (!log_handle && log_file.Length > 0) || (old_debug_log_level == 0 && debug_log_level > 0) || (old_debug_log_level > 0 && debug_log_level == 0))) {
@@ -1003,20 +1003,16 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
 }
 
 _Function_class_(WORKER_THREAD_ROUTINE)
-#ifdef __REACTOS__
-static void NTAPI registry_work_item(PVOID Parameter) {
-#else
-static void registry_work_item(PVOID Parameter) {
-#endif
+static void __stdcall registry_work_item(PVOID Parameter) {
     NTSTATUS Status;
     HANDLE regh = (HANDLE)Parameter;
     IO_STATUS_BLOCK iosb;
 
     TRACE("registry changed\n");
 
-    read_registry(&registry_path, TRUE);
+    read_registry(&registry_path, true);
 
-    Status = ZwNotifyChangeKey(regh, NULL, (PVOID)&wqi, (PVOID)DelayedWorkQueue, &iosb, REG_NOTIFY_CHANGE_LAST_SET, TRUE, NULL, 0, TRUE);
+    Status = ZwNotifyChangeKey(regh, NULL, (PVOID)&wqi, (PVOID)DelayedWorkQueue, &iosb, REG_NOTIFY_CHANGE_LAST_SET, true, NULL, 0, true);
     if (!NT_SUCCESS(Status))
         ERR("ZwNotifyChangeKey returned %08x\n", Status);
 }
@@ -1027,7 +1023,7 @@ void watch_registry(HANDLE regh) {
 
     ExInitializeWorkItem(&wqi, registry_work_item, regh);
 
-    Status = ZwNotifyChangeKey(regh, NULL, (PVOID)&wqi, (PVOID)DelayedWorkQueue, &iosb, REG_NOTIFY_CHANGE_LAST_SET, TRUE, NULL, 0, TRUE);
+    Status = ZwNotifyChangeKey(regh, NULL, (PVOID)&wqi, (PVOID)DelayedWorkQueue, &iosb, REG_NOTIFY_CHANGE_LAST_SET, true, NULL, 0, true);
     if (!NT_SUCCESS(Status))
         ERR("ZwNotifyChangeKey returned %08x\n", Status);
 }
diff --git a/drivers/filesystems/btrfs/reparse.c b/drivers/filesystems/btrfs/reparse.c
index 957ad073050..fb6a98808b8 100644
--- a/drivers/filesystems/btrfs/reparse.c
+++ b/drivers/filesystems/btrfs/reparse.c
@@ -17,6 +17,8 @@
 
 #include "btrfs_drv.h"
 
+extern tFsRtlValidateReparsePointBuffer fFsRtlValidateReparsePointBuffer;
+
 NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject, void* buffer, DWORD buflen, ULONG_PTR* retlen) {
     USHORT subnamelen, printnamelen, i;
     ULONG stringlen;
@@ -31,12 +33,12 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
     if (!ccb)
         return STATUS_INVALID_PARAMETER;
 
-    ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
-    ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
+    ExAcquireResourceSharedLite(fcb->Header.Resource, true);
 
     if (fcb->type == BTRFS_TYPE_SYMLINK) {
         if (ccb->lxss) {
-            reqlen = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(UINT32);
+            reqlen = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(uint32_t);
 
             if (buflen < reqlen) {
                 Status = STATUS_BUFFER_OVERFLOW;
@@ -44,10 +46,10 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
             }
 
             rdb->ReparseTag = IO_REPARSE_TAG_LXSS_SYMLINK;
-            rdb->ReparseDataLength = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(UINT32);
+            rdb->ReparseDataLength = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(uint32_t);
             rdb->Reserved = 0;
 
-            *((UINT32*)rdb->GenericReparseBuffer.DataBuffer) = 1;
+            *((uint32_t*)rdb->GenericReparseBuffer.DataBuffer) = 1;
 
             *retlen = reqlen;
         } else {
@@ -66,7 +68,7 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
             }
 
             TRACE("data = %p, size = %x\n", data, fcb->inode_item.st_size);
-            Status = read_file(fcb, (UINT8*)data, 0, fcb->inode_item.st_size, NULL, NULL);
+            Status = read_file(fcb, (uint8_t*)data, 0, fcb->inode_item.st_size, NULL, NULL);
 
             if (!NT_SUCCESS(Status)) {
                 ERR("read_file returned %08x\n", Status);
@@ -74,15 +76,15 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
                 goto end;
             }
 
-            Status = RtlUTF8ToUnicodeN(NULL, 0, &stringlen, data, (ULONG)fcb->inode_item.st_size);
+            Status = utf8_to_utf16(NULL, 0, &stringlen, data, (ULONG)fcb->inode_item.st_size);
             if (!NT_SUCCESS(Status)) {
-                ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
+                ERR("utf8_to_utf16 1 returned %08x\n", Status);
                 ExFreePool(data);
                 goto end;
             }
 
-            subnamelen = (UINT16)stringlen;
-            printnamelen = (UINT16)stringlen;
+            subnamelen = (uint16_t)stringlen;
+            printnamelen = (uint16_t)stringlen;
 
             reqlen = offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) + subnamelen + printnamelen;
 
@@ -108,11 +110,11 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
             rdb->SymbolicLinkReparseBuffer.PrintNameLength = printnamelen;
             rdb->SymbolicLinkReparseBuffer.Flags = SYMLINK_FLAG_RELATIVE;
 
-            Status = RtlUTF8ToUnicodeN(&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
+            Status = utf8_to_utf16(&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
                                        stringlen, &stringlen, data, (ULONG)fcb->inode_item.st_size);
 
             if (!NT_SUCCESS(Status)) {
-                ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
+                ERR("utf8_to_utf16 2 returned %08x\n", Status);
                 ExFreePool(data);
                 goto end;
             }
@@ -169,7 +171,7 @@ end:
     return Status;
 }
 
-static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, BOOL write, LIST_ENTRY* rollback) {
+static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, bool write, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     ULONG minlen;
     ULONG tlength;
@@ -211,9 +213,9 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REP
             return Status;
         }
 
-        Status = RtlUnicodeToUTF8N(NULL, 0, (PULONG)&target.Length, subname.Buffer, subname.Length);
+        Status = utf16_to_utf8(NULL, 0, (PULONG)&target.Length, subname.Buffer, subname.Length);
         if (!NT_SUCCESS(Status)) {
-            ERR("RtlUnicodeToUTF8N 1 failed with error %08x\n", Status);
+            ERR("utf16_to_utf8 1 failed with error %08x\n", Status);
             return Status;
         }
 
@@ -224,9 +226,9 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REP
             return STATUS_INSUFFICIENT_RESOURCES;
         }
 
-        Status = RtlUnicodeToUTF8N(target.Buffer, target.Length, (PULONG)&target.Length, subname.Buffer, subname.Length);
+        Status = utf16_to_utf8(target.Buffer, target.Length, (PULONG)&target.Length, subname.Buffer, subname.Length);
         if (!NT_SUCCESS(Status)) {
-            ERR("RtlUnicodeToUTF8N 2 failed with error %08x\n", Status);
+            ERR("utf16_to_utf8 2 failed with error %08x\n", Status);
             ExFreePool(target.Buffer);
             return Status;
         }
@@ -238,8 +240,8 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REP
 
         offset.QuadPart = 0;
         tlength = target.Length;
-        Status = write_file2(fcb->Vcb, Irp, offset, target.Buffer, &tlength, FALSE, TRUE,
-                             TRUE, FALSE, FALSE, rollback);
+        Status = write_file2(fcb->Vcb, Irp, offset, target.Buffer, &tlength, false, true,
+                             true, false, false, rollback);
         ExFreePool(target.Buffer);
     } else
         Status = STATUS_SUCCESS;
@@ -259,7 +261,7 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REP
     fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
     fcb->subvol->root_item.ctime = now;
 
-    fcb->inode_item_changed = TRUE;
+    fcb->inode_item_changed = true;
     mark_fcb_dirty(fcb);
 
     if (fileref)
@@ -286,7 +288,7 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, cc
         return STATUS_INVALID_BUFFER_SIZE;
     }
 
-    Status = FsRtlValidateReparsePointBuffer(buflen, rdb);
+    Status = fFsRtlValidateReparsePointBuffer(buflen, rdb);
     if (!NT_SUCCESS(Status)) {
         ERR("FsRtlValidateReparsePointBuffer returned %08x\n", Status);
         return Status;
@@ -310,7 +312,7 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, cc
                 ERR("out of memory\n");
                 return STATUS_INSUFFICIENT_RESOURCES;
             }
-            buf.Length = buf.MaximumLength = (UINT16)buflen;
+            buf.Length = buf.MaximumLength = (uint16_t)buflen;
 
             if (fcb->reparse_xattr.Buffer)
                 ExFreePool(fcb->reparse_xattr.Buffer);
@@ -318,7 +320,7 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, cc
             fcb->reparse_xattr = buf;
             RtlCopyMemory(buf.Buffer, rdb, buflen);
 
-            fcb->reparse_xattr_changed = TRUE;
+            fcb->reparse_xattr_changed = true;
 
             Status = STATUS_SUCCESS;
         } else { // otherwise, store as file data
@@ -330,7 +332,7 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, cc
 
             offset.QuadPart = 0;
 
-            Status = write_file2(fcb->Vcb, Irp, offset, rdb, &buflen, FALSE, TRUE, TRUE, FALSE, FALSE, rollback);
+            Status = write_file2(fcb->Vcb, Irp, offset, rdb, &buflen, false, true, true, false, false, rollback);
             if (!NT_SUCCESS(Status)) {
                 ERR("write_file2 returned %08x\n", Status);
                 return Status;
@@ -350,12 +352,12 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, cc
             fcb->inode_item.st_mtime = now;
 
         fcb->atts |= FILE_ATTRIBUTE_REPARSE_POINT;
-        fcb->atts_changed = TRUE;
+        fcb->atts_changed = true;
 
         fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
         fcb->subvol->root_item.ctime = now;
 
-        fcb->inode_item_changed = TRUE;
+        fcb->inode_item_changed = true;
         mark_fcb_dirty(fcb);
     }
 
@@ -414,8 +416,8 @@ NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
 
     TRACE("%S\n", file_desc(FileObject));
 
-    ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     Status = set_reparse_point2(fcb, rdb, buflen, ccb, fileref, Irp, &rollback);
     if (!NT_SUCCESS(Status)) {
@@ -483,8 +485,8 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
         return STATUS_INVALID_PARAMETER;
     }
 
-    ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     TRACE("%S\n", file_desc(FileObject));
 
@@ -539,7 +541,7 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
 
         mark_fileref_dirty(fileref);
 
-        fileref->fcb->inode_item_changed = TRUE;
+        fileref->fcb->inode_item_changed = true;
         mark_fcb_dirty(fileref->fcb);
 
         fileref->fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
@@ -557,7 +559,7 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
         }
 
         fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
-        fcb->atts_changed = TRUE;
+        fcb->atts_changed = true;
 
         KeQuerySystemTime(&time);
         win_time_to_unix(time, &now);
@@ -571,7 +573,7 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
         if (!ccb->user_set_write_time)
             fcb->inode_item.st_mtime = now;
 
-        fcb->inode_item_changed = TRUE;
+        fcb->inode_item_changed = true;
         mark_fcb_dirty(fcb);
 
         fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
@@ -583,14 +585,14 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
         // FIXME - do we need to check that the reparse tags match?
 
         fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
-        fcb->atts_changed = TRUE;
+        fcb->atts_changed = true;
 
         if (fcb->reparse_xattr.Buffer) {
             ExFreePool(fcb->reparse_xattr.Buffer);
             fcb->reparse_xattr.Buffer = NULL;
         }
 
-        fcb->reparse_xattr_changed = TRUE;
+        fcb->reparse_xattr_changed = true;
 
         KeQuerySystemTime(&time);
         win_time_to_unix(time, &now);
@@ -604,7 +606,7 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
         if (!ccb->user_set_write_time)
             fcb->inode_item.st_mtime = now;
 
-        fcb->inode_item_changed = TRUE;
+        fcb->inode_item_changed = true;
         mark_fcb_dirty(fcb);
 
         fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
diff --git a/drivers/filesystems/btrfs/scrub.c b/drivers/filesystems/btrfs/scrub.c
index f2d3d5e9eda..d1994b7fe63 100644
--- a/drivers/filesystems/btrfs/scrub.c
+++ b/drivers/filesystems/btrfs/scrub.c
@@ -24,12 +24,12 @@ struct _scrub_context;
 typedef struct {
     struct _scrub_context* context;
     PIRP Irp;
-    UINT64 start;
-    UINT32 length;
+    uint64_t start;
+    uint32_t length;
     IO_STATUS_BLOCK iosb;
-    UINT8* buf;
-    BOOL csum_error;
-    UINT32* bad_csums;
+    uint8_t* buf;
+    bool csum_error;
+    uint32_t* bad_csums;
 } scrub_context_stripe;
 
 typedef struct _scrub_context {
@@ -40,17 +40,17 @@ typedef struct _scrub_context {
 
 typedef struct {
     ANSI_STRING name;
-    BOOL orig_subvol;
+    bool orig_subvol;
     LIST_ENTRY list_entry;
 } path_part;
 
-static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 devid, UINT64 subvol, UINT64 inode, UINT64 offset) {
+static void log_file_checksum_error(device_extension* Vcb, uint64_t addr, uint64_t devid, uint64_t subvol, uint64_t inode, uint64_t offset) {
     LIST_ENTRY *le, parts;
     root* r = NULL;
     KEY searchkey;
     traverse_ptr tp;
-    UINT64 dir;
-    BOOL orig_subvol = TRUE, not_in_tree = FALSE;
+    uint64_t dir;
+    bool orig_subvol = true, not_in_tree = false;
     ANSI_STRING fn;
     scrub_error* err;
     NTSTATUS Status;
@@ -69,7 +69,7 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
     }
 
     if (!r) {
-        ERR("could not find subvol %llx\n", subvol);
+        ERR("could not find subvol %I64x\n", subvol);
         return;
     }
 
@@ -77,7 +77,7 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
 
     dir = inode;
 
-    while (TRUE) {
+    while (true) {
         if (dir == r->root_item.objid) {
             if (r == Vcb->root_fileref->fcb->subvol)
                 break;
@@ -86,7 +86,7 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
             searchkey.obj_type = TYPE_ROOT_BACKREF;
             searchkey.offset = 0xffffffffffffffff;
 
-            Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, FALSE, NULL);
+            Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, NULL);
             if (!NT_SUCCESS(Status)) {
                 ERR("find_item returned %08x\n", Status);
                 goto end;
@@ -97,12 +97,12 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
                 path_part* pp;
 
                 if (tp.item->size < sizeof(ROOT_REF)) {
-                    ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(ROOT_REF));
+                    ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(ROOT_REF));
                     goto end;
                 }
 
                 if (tp.item->size < offsetof(ROOT_REF, name[0]) + rr->n) {
-                    ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+                    ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                         tp.item->size, offsetof(ROOT_REF, name[0]) + rr->n);
                     goto end;
                 }
@@ -115,7 +115,7 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
 
                 pp->name.Buffer = rr->name;
                 pp->name.Length = pp->name.MaximumLength = rr->n;
-                pp->orig_subvol = FALSE;
+                pp->orig_subvol = false;
 
                 InsertTailList(&parts, &pp->list_entry);
 
@@ -134,14 +134,14 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
                 }
 
                 if (!r) {
-                    ERR("could not find subvol %llx\n", tp.item->key.offset);
+                    ERR("could not find subvol %I64x\n", tp.item->key.offset);
                     goto end;
                 }
 
                 dir = rr->dir;
-                orig_subvol = FALSE;
+                orig_subvol = false;
             } else {
-                not_in_tree = TRUE;
+                not_in_tree = true;
                 break;
             }
         } else {
@@ -149,7 +149,7 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
             searchkey.obj_type = TYPE_INODE_EXTREF;
             searchkey.offset = 0xffffffffffffffff;
 
-            Status = find_item(Vcb, r, &tp, &searchkey, FALSE, NULL);
+            Status = find_item(Vcb, r, &tp, &searchkey, false, NULL);
             if (!NT_SUCCESS(Status)) {
                 ERR("find_item returned %08x\n", Status);
                 goto end;
@@ -160,12 +160,12 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
                 path_part* pp;
 
                 if (tp.item->size < sizeof(INODE_REF)) {
-                    ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(INODE_REF));
+                    ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(INODE_REF));
                     goto end;
                 }
 
                 if (tp.item->size < offsetof(INODE_REF, name[0]) + ir->n) {
-                    ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+                    ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                         tp.item->size, offsetof(INODE_REF, name[0]) + ir->n);
                     goto end;
                 }
@@ -191,13 +191,13 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
                 path_part* pp;
 
                 if (tp.item->size < sizeof(INODE_EXTREF)) {
-                    ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+                    ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                                                                                tp.item->size, sizeof(INODE_EXTREF));
                     goto end;
                 }
 
                 if (tp.item->size < offsetof(INODE_EXTREF, name[0]) + ier->n) {
-                    ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+                    ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                         tp.item->size, offsetof(INODE_EXTREF, name[0]) + ier->n);
                     goto end;
                 }
@@ -219,7 +219,7 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
 
                 dir = ier->dir;
             } else {
-                ERR("could not find INODE_REF for inode %llx in subvol %llx\n", dir, r->id);
+                ERR("could not find INODE_REF for inode %I64x in subvol %I64x\n", dir, r->id);
                 goto end;
             }
         }
@@ -274,13 +274,13 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
     }
 
     if (not_in_tree)
-        ERR("subvol %llx, %.*s, offset %llx\n", subvol, fn.Length, fn.Buffer, offset);
+        ERR("subvol %I64x, %.*s, offset %I64x\n", subvol, fn.Length, fn.Buffer, offset);
     else
-        ERR("%.*s, offset %llx\n", fn.Length, fn.Buffer, offset);
+        ERR("%.*s, offset %I64x\n", fn.Length, fn.Buffer, offset);
 
-    Status = RtlUTF8ToUnicodeN(NULL, 0, &utf16len, fn.Buffer, fn.Length);
+    Status = utf8_to_utf16(NULL, 0, &utf16len, fn.Buffer, fn.Length);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
+        ERR("utf8_to_utf16 1 returned %08x\n", Status);
         ExFreePool(fn.Buffer);
         goto end;
     }
@@ -294,23 +294,23 @@ static void log_file_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
 
     err->address = addr;
     err->device = devid;
-    err->recovered = FALSE;
-    err->is_metadata = FALSE;
-    err->parity = FALSE;
+    err->recovered = false;
+    err->is_metadata = false;
+    err->parity = false;
 
     err->data.subvol = not_in_tree ? subvol : 0;
     err->data.offset = offset;
-    err->data.filename_length = (UINT16)utf16len;
+    err->data.filename_length = (uint16_t)utf16len;
 
-    Status = RtlUTF8ToUnicodeN(err->data.filename, utf16len, &utf16len, fn.Buffer, fn.Length);
+    Status = utf8_to_utf16(err->data.filename, utf16len, &utf16len, fn.Buffer, fn.Length);
     if (!NT_SUCCESS(Status)) {
-        ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
+        ERR("utf8_to_utf16 2 returned %08x\n", Status);
         ExFreePool(fn.Buffer);
         ExFreePool(err);
         goto end;
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, true);
 
     Vcb->scrub.num_errors++;
     InsertTailList(&Vcb->scrub.errors, &err->list_entry);
@@ -327,7 +327,7 @@ end:
     }
 }
 
-static void log_file_checksum_error_shared(device_extension* Vcb, UINT64 treeaddr, UINT64 addr, UINT64 devid, UINT64 extent) {
+static void log_file_checksum_error_shared(device_extension* Vcb, uint64_t treeaddr, uint64_t addr, uint64_t devid, uint64_t extent) {
     tree_header* tree;
     NTSTATUS Status;
     leaf_node* ln;
@@ -339,7 +339,7 @@ static void log_file_checksum_error_shared(device_extension* Vcb, UINT64 treeadd
         return;
     }
 
-    Status = read_data(Vcb, treeaddr, Vcb->superblock.node_size, NULL, TRUE, (UINT8*)tree, NULL, NULL, NULL, 0, FALSE, NormalPagePriority);
+    Status = read_data(Vcb, treeaddr, Vcb->superblock.node_size, NULL, true, (uint8_t*)tree, NULL, NULL, NULL, 0, false, NormalPagePriority);
     if (!NT_SUCCESS(Status)) {
         ERR("read_data returned %08x\n", Status);
         goto end;
@@ -354,7 +354,7 @@ static void log_file_checksum_error_shared(device_extension* Vcb, UINT64 treeadd
 
     for (i = 0; i < tree->num_items; i++) {
         if (ln[i].key.obj_type == TYPE_EXTENT_DATA && ln[i].size >= sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2)) {
-            EXTENT_DATA* ed = (EXTENT_DATA*)((UINT8*)tree + sizeof(tree_header) + ln[i].offset);
+            EXTENT_DATA* ed = (EXTENT_DATA*)((uint8_t*)tree + sizeof(tree_header) + ln[i].offset);
             EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ed->data;
 
             if (ed->type == EXTENT_TYPE_REGULAR && ed2->size != 0 && ed2->address == addr)
@@ -366,7 +366,7 @@ end:
     ExFreePool(tree);
 }
 
-static void log_tree_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 devid, UINT64 root, UINT8 level, KEY* firstitem) {
+static void log_tree_checksum_error(device_extension* Vcb, uint64_t addr, uint64_t devid, uint64_t root, uint8_t level, KEY* firstitem) {
     scrub_error* err;
 
     err = ExAllocatePoolWithTag(PagedPool, sizeof(scrub_error), ALLOC_TAG);
@@ -377,25 +377,25 @@ static void log_tree_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
 
     err->address = addr;
     err->device = devid;
-    err->recovered = FALSE;
-    err->is_metadata = TRUE;
-    err->parity = FALSE;
+    err->recovered = false;
+    err->is_metadata = true;
+    err->parity = false;
 
     err->metadata.root = root;
     err->metadata.level = level;
 
     if (firstitem) {
-        ERR("root %llx, level %u, first item (%llx,%x,%llx)\n", root, level, firstitem->obj_id,
+        ERR("root %I64x, level %u, first item (%I64x,%x,%I64x)\n", root, level, firstitem->obj_id,
                                                                 firstitem->obj_type, firstitem->offset);
 
         err->metadata.firstitem = *firstitem;
     } else {
-        ERR("root %llx, level %u\n", root, level);
+        ERR("root %I64x, level %u\n", root, level);
 
         RtlZeroMemory(&err->metadata.firstitem, sizeof(KEY));
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, true);
 
     Vcb->scrub.num_errors++;
     InsertTailList(&Vcb->scrub.errors, &err->list_entry);
@@ -403,7 +403,7 @@ static void log_tree_checksum_error(device_extension* Vcb, UINT64 addr, UINT64 d
     ExReleaseResourceLite(&Vcb->scrub.stats_lock);
 }
 
-static void log_tree_checksum_error_shared(device_extension* Vcb, UINT64 offset, UINT64 address, UINT64 devid) {
+static void log_tree_checksum_error_shared(device_extension* Vcb, uint64_t offset, uint64_t address, uint64_t devid) {
     tree_header* tree;
     NTSTATUS Status;
     internal_node* in;
@@ -415,7 +415,7 @@ static void log_tree_checksum_error_shared(device_extension* Vcb, UINT64 offset,
         return;
     }
 
-    Status = read_data(Vcb, offset, Vcb->superblock.node_size, NULL, TRUE, (UINT8*)tree, NULL, NULL, NULL, 0, FALSE, NormalPagePriority);
+    Status = read_data(Vcb, offset, Vcb->superblock.node_size, NULL, true, (uint8_t*)tree, NULL, NULL, NULL, 0, false, NormalPagePriority);
     if (!NT_SUCCESS(Status)) {
         ERR("read_data returned %08x\n", Status);
         goto end;
@@ -439,15 +439,15 @@ end:
     ExFreePool(tree);
 }
 
-static void log_unrecoverable_error(device_extension* Vcb, UINT64 address, UINT64 devid) {
+static void log_unrecoverable_error(device_extension* Vcb, uint64_t address, uint64_t devid) {
     KEY searchkey;
     traverse_ptr tp;
     NTSTATUS Status;
     EXTENT_ITEM* ei;
     EXTENT_ITEM2* ei2 = NULL;
-    UINT8* ptr;
+    uint8_t* ptr;
     ULONG len;
-    UINT64 rc;
+    uint64_t rc;
 
     // FIXME - still log even if rest of this function fails
 
@@ -455,7 +455,7 @@ static void log_unrecoverable_error(device_extension* Vcb, UINT64 address, UINT6
     searchkey.obj_type = TYPE_METADATA_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return;
@@ -469,17 +469,17 @@ static void log_unrecoverable_error(device_extension* Vcb, UINT64 address, UINT6
         return;
 
     if (tp.item->size < sizeof(EXTENT_ITEM)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
         return;
     }
 
     ei = (EXTENT_ITEM*)tp.item->data;
-    ptr = (UINT8*)&ei[1];
+    ptr = (uint8_t*)&ei[1];
     len = tp.item->size - sizeof(EXTENT_ITEM);
 
     if (tp.item->key.obj_id == TYPE_EXTENT_ITEM && ei->flags & EXTENT_ITEM_TREE_BLOCK) {
         if (tp.item->size < sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                                                                        tp.item->size, sizeof(EXTENT_ITEM) + sizeof(EXTENT_ITEM2));
             return;
         }
@@ -493,7 +493,7 @@ static void log_unrecoverable_error(device_extension* Vcb, UINT64 address, UINT6
     rc = 0;
 
     while (len > 0) {
-        UINT8 type = *ptr;
+        uint8_t type = *ptr;
 
         ptr++;
         len--;
@@ -508,7 +508,7 @@ static void log_unrecoverable_error(device_extension* Vcb, UINT64 address, UINT6
 
             tbr = (TREE_BLOCK_REF*)ptr;
 
-            log_tree_checksum_error(Vcb, address, devid, tbr->offset, ei2 ? ei2->level : (UINT8)tp.item->key.offset, ei2 ? &ei2->firstitem : NULL);
+            log_tree_checksum_error(Vcb, address, devid, tbr->offset, ei2 ? ei2->level : (uint8_t)tp.item->key.offset, ei2 ? &ei2->firstitem : NULL);
 
             rc++;
 
@@ -572,19 +572,19 @@ static void log_unrecoverable_error(device_extension* Vcb, UINT64 address, UINT6
         do {
             traverse_ptr next_tp;
 
-            if (find_next_item(Vcb, &tp, &next_tp, FALSE, NULL))
+            if (find_next_item(Vcb, &tp, &next_tp, false, NULL))
                 tp = next_tp;
             else
                 break;
 
             if (tp.item->key.obj_id == address) {
                 if (tp.item->key.obj_type == TYPE_TREE_BLOCK_REF)
-                    log_tree_checksum_error(Vcb, address, devid, tp.item->key.offset, ei2 ? ei2->level : (UINT8)tp.item->key.offset, ei2 ? &ei2->firstitem : NULL);
+                    log_tree_checksum_error(Vcb, address, devid, tp.item->key.offset, ei2 ? ei2->level : (uint8_t)tp.item->key.offset, ei2 ? &ei2->firstitem : NULL);
                 else if (tp.item->key.obj_type == TYPE_EXTENT_DATA_REF) {
                     EXTENT_DATA_REF* edr;
 
                     if (tp.item->size < sizeof(EXTENT_DATA_REF)) {
-                        ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+                        ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                                                                           tp.item->size, sizeof(EXTENT_DATA_REF));
                         break;
                     }
@@ -598,21 +598,21 @@ static void log_unrecoverable_error(device_extension* Vcb, UINT64 address, UINT6
                     log_file_checksum_error_shared(Vcb, tp.item->key.offset, address, devid, tp.item->key.obj_id);
             } else
                 break;
-        } while (TRUE);
+        } while (true);
     }
 }
 
-static void log_error(device_extension* Vcb, UINT64 addr, UINT64 devid, BOOL metadata, BOOL recoverable, BOOL parity) {
+static void log_error(device_extension* Vcb, uint64_t addr, uint64_t devid, bool metadata, bool recoverable, bool parity) {
     if (recoverable) {
         scrub_error* err;
 
         if (parity) {
-            ERR("recovering from parity error at %llx on device %llx\n", addr, devid);
+            ERR("recovering from parity error at %I64x on device %I64x\n", addr, devid);
         } else {
             if (metadata)
-                ERR("recovering from metadata checksum error at %llx on device %llx\n", addr, devid);
+                ERR("recovering from metadata checksum error at %I64x on device %I64x\n", addr, devid);
             else
-                ERR("recovering from data checksum error at %llx on device %llx\n", addr, devid);
+                ERR("recovering from data checksum error at %I64x on device %I64x\n", addr, devid);
         }
 
         err = ExAllocatePoolWithTag(PagedPool, sizeof(scrub_error), ALLOC_TAG);
@@ -623,7 +623,7 @@ static void log_error(device_extension* Vcb, UINT64 addr, UINT64 devid, BOOL met
 
         err->address = addr;
         err->device = devid;
-        err->recovered = TRUE;
+        err->recovered = true;
         err->is_metadata = metadata;
         err->parity = parity;
 
@@ -632,7 +632,7 @@ static void log_error(device_extension* Vcb, UINT64 addr, UINT64 devid, BOOL met
         else
             RtlZeroMemory(&err->data, sizeof(err->data));
 
-        ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, true);
 
         Vcb->scrub.num_errors++;
         InsertTailList(&Vcb->scrub.errors, &err->list_entry);
@@ -640,20 +640,16 @@ static void log_error(device_extension* Vcb, UINT64 addr, UINT64 devid, BOOL met
         ExReleaseResourceLite(&Vcb->scrub.stats_lock);
     } else {
         if (metadata)
-            ERR("unrecoverable metadata checksum error at %llx\n", addr);
+            ERR("unrecoverable metadata checksum error at %I64x\n", addr);
         else
-            ERR("unrecoverable data checksum error at %llx\n", addr);
+            ERR("unrecoverable data checksum error at %I64x\n", addr);
 
         log_unrecoverable_error(Vcb, addr, devid);
     }
 }
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI scrub_read_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#else
-static NTSTATUS scrub_read_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#endif
+static NTSTATUS __stdcall scrub_read_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
     scrub_context_stripe* stripe = conptr;
     scrub_context* context = (scrub_context*)stripe->context;
     ULONG left = InterlockedDecrement(&context->stripes_left);
@@ -663,17 +659,17 @@ static NTSTATUS scrub_read_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVO
     stripe->iosb = Irp->IoStatus;
 
     if (left == 0)
-        KeSetEvent(&context->Event, 0, FALSE);
+        KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
 
-static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset, UINT32* csum, scrub_context* context) {
+static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, uint64_t offset, uint32_t* csum, scrub_context* context) {
     NTSTATUS Status;
-    BOOL csum_error = FALSE;
+    bool csum_error = false;
     ULONG i;
     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
-    UINT16 present_devices = 0;
+    uint16_t present_devices = 0;
 
     if (csum) {
         ULONG good_stripe = 0xffffffff;
@@ -686,15 +682,15 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
                 if (good_stripe != 0xffffffff) {
                     if (RtlCompareMemory(context->stripes[i].buf, context->stripes[good_stripe].buf,
                                         context->stripes[good_stripe].length) != context->stripes[i].length) {
-                        context->stripes[i].csum_error = TRUE;
-                        csum_error = TRUE;
+                        context->stripes[i].csum_error = true;
+                        csum_error = true;
                         log_device_error(Vcb, c->devices[i], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                     }
                 } else {
                     Status = check_csum(Vcb, context->stripes[i].buf, context->stripes[i].length / Vcb->superblock.sector_size, csum);
                     if (Status == STATUS_CRC_ERROR) {
-                        context->stripes[i].csum_error = TRUE;
-                        csum_error = TRUE;
+                        context->stripes[i].csum_error = true;
+                        csum_error = true;
                         log_device_error(Vcb, c->devices[i], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                     } else if (!NT_SUCCESS(Status)) {
                         ERR("check_csum returned %08x\n", Status);
@@ -715,18 +711,18 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
                 if (good_stripe != 0xffffffff) {
                     if (RtlCompareMemory(context->stripes[i].buf, context->stripes[good_stripe].buf,
                                          context->stripes[good_stripe].length) != context->stripes[i].length) {
-                        context->stripes[i].csum_error = TRUE;
-                        csum_error = TRUE;
+                        context->stripes[i].csum_error = true;
+                        csum_error = true;
                         log_device_error(Vcb, c->devices[i], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                     }
                 } else {
                     for (j = 0; j < context->stripes[i].length / Vcb->superblock.node_size; j++) {
                         tree_header* th = (tree_header*)&context->stripes[i].buf[j * Vcb->superblock.node_size];
-                        UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                        uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-                        if (crc32 != *((UINT32*)th->csum) || th->address != offset + UInt32x32To64(j, Vcb->superblock.node_size)) {
-                            context->stripes[i].csum_error = TRUE;
-                            csum_error = TRUE;
+                        if (crc32 != *((uint32_t*)th->csum) || th->address != offset + UInt32x32To64(j, Vcb->superblock.node_size)) {
+                            context->stripes[i].csum_error = true;
+                            csum_error = true;
                             log_device_error(Vcb, c->devices[i], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                         }
                     }
@@ -746,7 +742,7 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
     for (i = 0; i < c->chunk_item->num_stripes; i++) {
         if (context->stripes[i].csum_error) {
             if (csum) {
-                context->stripes[i].bad_csums = ExAllocatePoolWithTag(PagedPool, context->stripes[i].length * sizeof(UINT32) / Vcb->superblock.sector_size, ALLOC_TAG);
+                context->stripes[i].bad_csums = ExAllocatePoolWithTag(PagedPool, context->stripes[i].length * sizeof(uint32_t) / Vcb->superblock.sector_size, ALLOC_TAG);
                 if (!context->stripes[i].bad_csums) {
                     ERR("out of memory\n");
                     return STATUS_INSUFFICIENT_RESOURCES;
@@ -760,7 +756,7 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
             } else {
                 ULONG j;
 
-                context->stripes[i].bad_csums = ExAllocatePoolWithTag(PagedPool, context->stripes[i].length * sizeof(UINT32) / Vcb->superblock.node_size, ALLOC_TAG);
+                context->stripes[i].bad_csums = ExAllocatePoolWithTag(PagedPool, context->stripes[i].length * sizeof(uint32_t) / Vcb->superblock.node_size, ALLOC_TAG);
                 if (!context->stripes[i].bad_csums) {
                     ERR("out of memory\n");
                     return STATUS_INSUFFICIENT_RESOURCES;
@@ -768,7 +764,7 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
 
                 for (j = 0; j < context->stripes[i].length / Vcb->superblock.node_size; j++) {
                     tree_header* th = (tree_header*)&context->stripes[i].buf[j * Vcb->superblock.node_size];
-                    UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                    uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
                     context->stripes[i].bad_csums[j] = crc32;
                 }
@@ -796,19 +792,19 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
                     if (csum) {
                         for (j = 0; j < context->stripes[i].length / Vcb->superblock.sector_size; j++) {
                             if (context->stripes[i].bad_csums[j] != csum[j]) {
-                                UINT64 addr = offset + UInt32x32To64(j, Vcb->superblock.sector_size);
+                                uint64_t addr = offset + UInt32x32To64(j, Vcb->superblock.sector_size);
 
-                                log_error(Vcb, addr, c->devices[i]->devitem.dev_id, FALSE, TRUE, FALSE);
+                                log_error(Vcb, addr, c->devices[i]->devitem.dev_id, false, true, false);
                                 log_device_error(Vcb, c->devices[i], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                             }
                         }
                     } else {
                         for (j = 0; j < context->stripes[i].length / Vcb->superblock.node_size; j++) {
                             tree_header* th = (tree_header*)&context->stripes[i].buf[j * Vcb->superblock.node_size];
-                            UINT64 addr = offset + UInt32x32To64(j, Vcb->superblock.node_size);
+                            uint64_t addr = offset + UInt32x32To64(j, Vcb->superblock.node_size);
 
-                            if (context->stripes[i].bad_csums[j] != *((UINT32*)th->csum) || th->address != addr) {
-                                log_error(Vcb, addr, c->devices[i]->devitem.dev_id, TRUE, TRUE, FALSE);
+                            if (context->stripes[i].bad_csums[j] != *((uint32_t*)th->csum) || th->address != addr) {
+                                log_error(Vcb, addr, c->devices[i]->devitem.dev_id, true, true, false);
                                 log_device_error(Vcb, c->devices[i], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                             }
                         }
@@ -820,7 +816,7 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
 
             for (i = 0; i < c->chunk_item->num_stripes; i++) {
                 if (context->stripes[i].csum_error && !c->devices[i]->readonly) {
-                    Status = write_data_phys(c->devices[i]->devobj, cis[i].offset + offset - c->offset,
+                    Status = write_data_phys(c->devices[i]->devobj, c->devices[i]->fileobj, cis[i].offset + offset - c->offset,
                                              context->stripes[good_stripe].buf, context->stripes[i].length);
 
                     if (!NT_SUCCESS(Status)) {
@@ -844,24 +840,24 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
                     for (j = 0; j < context->stripes[i].length / Vcb->superblock.sector_size; j++) {
                         if (context->stripes[i].bad_csums[j] != csum[j]) {
                             ULONG k;
-                            UINT64 addr = offset + UInt32x32To64(j, Vcb->superblock.sector_size);
-                            BOOL recovered = FALSE;
+                            uint64_t addr = offset + UInt32x32To64(j, Vcb->superblock.sector_size);
+                            bool recovered = false;
 
                             for (k = 0; k < c->chunk_item->num_stripes; k++) {
                                 if (i != k && c->devices[k]->devobj && context->stripes[k].bad_csums[j] == csum[j]) {
-                                    log_error(Vcb, addr, c->devices[i]->devitem.dev_id, FALSE, TRUE, FALSE);
+                                    log_error(Vcb, addr, c->devices[i]->devitem.dev_id, false, true, false);
                                     log_device_error(Vcb, c->devices[i], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
 
                                     RtlCopyMemory(context->stripes[i].buf + (j * Vcb->superblock.sector_size),
                                                   context->stripes[k].buf + (j * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
-                                    recovered = TRUE;
+                                    recovered = true;
                                     break;
                                 }
                             }
 
                             if (!recovered) {
-                                log_error(Vcb, addr, c->devices[i]->devitem.dev_id, FALSE, FALSE, FALSE);
+                                log_error(Vcb, addr, c->devices[i]->devitem.dev_id, false, false, false);
                                 log_device_error(Vcb, c->devices[i], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                             }
                         }
@@ -869,30 +865,30 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
                 } else {
                     for (j = 0; j < context->stripes[i].length / Vcb->superblock.node_size; j++) {
                         tree_header* th = (tree_header*)&context->stripes[i].buf[j * Vcb->superblock.node_size];
-                        UINT64 addr = offset + UInt32x32To64(j, Vcb->superblock.node_size);
+                        uint64_t addr = offset + UInt32x32To64(j, Vcb->superblock.node_size);
 
-                        if (context->stripes[i].bad_csums[j] != *((UINT32*)th->csum) || th->address != addr) {
+                        if (context->stripes[i].bad_csums[j] != *((uint32_t*)th->csum) || th->address != addr) {
                             ULONG k;
-                            BOOL recovered = FALSE;
+                            bool recovered = false;
 
                             for (k = 0; k < c->chunk_item->num_stripes; k++) {
                                 if (i != k && c->devices[k]->devobj) {
                                     tree_header* th2 = (tree_header*)&context->stripes[k].buf[j * Vcb->superblock.node_size];
 
-                                    if (context->stripes[k].bad_csums[j] == *((UINT32*)th2->csum) && th2->address == addr) {
-                                        log_error(Vcb, addr, c->devices[i]->devitem.dev_id, TRUE, TRUE, FALSE);
+                                    if (context->stripes[k].bad_csums[j] == *((uint32_t*)th2->csum) && th2->address == addr) {
+                                        log_error(Vcb, addr, c->devices[i]->devitem.dev_id, true, true, false);
                                         log_device_error(Vcb, c->devices[i], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
 
                                         RtlCopyMemory(th, th2, Vcb->superblock.node_size);
 
-                                        recovered = TRUE;
+                                        recovered = true;
                                         break;
                                     }
                                 }
                             }
 
                             if (!recovered) {
-                                log_error(Vcb, addr, c->devices[i]->devitem.dev_id, TRUE, FALSE, FALSE);
+                                log_error(Vcb, addr, c->devices[i]->devitem.dev_id, true, false, false);
                                 log_device_error(Vcb, c->devices[i], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                             }
                         }
@@ -905,7 +901,7 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
 
         for (i = 0; i < c->chunk_item->num_stripes; i++) {
             if (c->devices[i]->devobj && !c->devices[i]->readonly) {
-                Status = write_data_phys(c->devices[i]->devobj, cis[i].offset + offset - c->offset,
+                Status = write_data_phys(c->devices[i]->devobj, c->devices[i]->fileobj, cis[i].offset + offset - c->offset,
                                          context->stripes[i].buf, context->stripes[i].length);
                 if (!NT_SUCCESS(Status)) {
                     ERR("write_data_phys returned %08x\n", Status);
@@ -925,18 +921,18 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
             if (csum) {
                 for (j = 0; j < context->stripes[i].length / Vcb->superblock.sector_size; j++) {
                     if (context->stripes[i].bad_csums[j] != csum[j]) {
-                        UINT64 addr = offset + UInt32x32To64(j, Vcb->superblock.sector_size);
+                        uint64_t addr = offset + UInt32x32To64(j, Vcb->superblock.sector_size);
 
-                        log_error(Vcb, addr, c->devices[i]->devitem.dev_id, FALSE, FALSE, FALSE);
+                        log_error(Vcb, addr, c->devices[i]->devitem.dev_id, false, false, false);
                     }
                 }
             } else {
                 for (j = 0; j < context->stripes[i].length / Vcb->superblock.node_size; j++) {
                     tree_header* th = (tree_header*)&context->stripes[i].buf[j * Vcb->superblock.node_size];
-                    UINT64 addr = offset + UInt32x32To64(j, Vcb->superblock.node_size);
+                    uint64_t addr = offset + UInt32x32To64(j, Vcb->superblock.node_size);
 
-                    if (context->stripes[i].bad_csums[j] != *((UINT32*)th->csum) || th->address != addr)
-                        log_error(Vcb, addr, c->devices[i]->devitem.dev_id, TRUE, FALSE, FALSE);
+                    if (context->stripes[i].bad_csums[j] != *((uint32_t*)th->csum) || th->address != addr)
+                        log_error(Vcb, addr, c->devices[i]->devitem.dev_id, true, false, false);
                 }
             }
         }
@@ -945,37 +941,37 @@ static NTSTATUS scrub_extent_dup(device_extension* Vcb, chunk* c, UINT64 offset,
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS scrub_extent_raid0(device_extension* Vcb, chunk* c, UINT64 offset, UINT32 length, UINT16 startoffstripe, UINT32* csum, scrub_context* context) {
+static NTSTATUS scrub_extent_raid0(device_extension* Vcb, chunk* c, uint64_t offset, uint32_t length, uint16_t startoffstripe, uint32_t* csum, scrub_context* context) {
     ULONG j;
-    UINT16 stripe;
-    UINT32 pos, *stripeoff;
+    uint16_t stripe;
+    uint32_t pos, *stripeoff;
 
     pos = 0;
-    stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(UINT32) * c->chunk_item->num_stripes, ALLOC_TAG);
+    stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(uint32_t) * c->chunk_item->num_stripes, ALLOC_TAG);
     if (!stripeoff) {
         ERR("out of memory\n");
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    RtlZeroMemory(stripeoff, sizeof(UINT32) * c->chunk_item->num_stripes);
+    RtlZeroMemory(stripeoff, sizeof(uint32_t) * c->chunk_item->num_stripes);
 
     stripe = startoffstripe;
     while (pos < length) {
-        UINT32 readlen;
+        uint32_t readlen;
 
         if (pos == 0)
-            readlen = (UINT32)min(context->stripes[stripe].length, c->chunk_item->stripe_length - (context->stripes[stripe].start % c->chunk_item->stripe_length));
+            readlen = (uint32_t)min(context->stripes[stripe].length, c->chunk_item->stripe_length - (context->stripes[stripe].start % c->chunk_item->stripe_length));
         else
-            readlen = min(length - pos, (UINT32)c->chunk_item->stripe_length);
+            readlen = min(length - pos, (uint32_t)c->chunk_item->stripe_length);
 
         if (csum) {
             for (j = 0; j < readlen; j += Vcb->superblock.sector_size) {
-                UINT32 crc32 = ~calc_crc32c(0xffffffff, context->stripes[stripe].buf + stripeoff[stripe], Vcb->superblock.sector_size);
+                uint32_t crc32 = ~calc_crc32c(0xffffffff, context->stripes[stripe].buf + stripeoff[stripe], Vcb->superblock.sector_size);
 
                 if (crc32 != csum[pos / Vcb->superblock.sector_size]) {
-                    UINT64 addr = offset + pos;
+                    uint64_t addr = offset + pos;
 
-                    log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, FALSE, FALSE, FALSE);
+                    log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, false, false, false);
                     log_device_error(Vcb, c->devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                 }
 
@@ -985,11 +981,11 @@ static NTSTATUS scrub_extent_raid0(device_extension* Vcb, chunk* c, UINT64 offse
         } else {
             for (j = 0; j < readlen; j += Vcb->superblock.node_size) {
                 tree_header* th = (tree_header*)(context->stripes[stripe].buf + stripeoff[stripe]);
-                UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
-                UINT64 addr = offset + pos;
+                uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                uint64_t addr = offset + pos;
 
-                if (crc32 != *((UINT32*)th->csum) || th->address != addr) {
-                    log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, TRUE, FALSE, FALSE);
+                if (crc32 != *((uint32_t*)th->csum) || th->address != addr) {
+                    log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, true, false, false);
                     log_device_error(Vcb, c->devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                 }
 
@@ -1006,35 +1002,35 @@ static NTSTATUS scrub_extent_raid0(device_extension* Vcb, chunk* c, UINT64 offse
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offset, UINT32 length, UINT16 startoffstripe, UINT32* csum, scrub_context* context) {
+static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, uint64_t offset, uint32_t length, uint16_t startoffstripe, uint32_t* csum, scrub_context* context) {
     ULONG j;
-    UINT16 stripe, sub_stripes = max(c->chunk_item->sub_stripes, 1);
-    UINT32 pos, *stripeoff;
-    BOOL csum_error = FALSE;
+    uint16_t stripe, sub_stripes = max(c->chunk_item->sub_stripes, 1);
+    uint32_t pos, *stripeoff;
+    bool csum_error = false;
     NTSTATUS Status;
 
     pos = 0;
-    stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(UINT32) * c->chunk_item->num_stripes / sub_stripes, ALLOC_TAG);
+    stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(uint32_t) * c->chunk_item->num_stripes / sub_stripes, ALLOC_TAG);
     if (!stripeoff) {
         ERR("out of memory\n");
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    RtlZeroMemory(stripeoff, sizeof(UINT32) * c->chunk_item->num_stripes / sub_stripes);
+    RtlZeroMemory(stripeoff, sizeof(uint32_t) * c->chunk_item->num_stripes / sub_stripes);
 
     stripe = startoffstripe;
     while (pos < length) {
-        UINT32 readlen;
+        uint32_t readlen;
 
         if (pos == 0)
-            readlen = (UINT32)min(context->stripes[stripe * sub_stripes].length,
+            readlen = (uint32_t)min(context->stripes[stripe * sub_stripes].length,
                                   c->chunk_item->stripe_length - (context->stripes[stripe * sub_stripes].start % c->chunk_item->stripe_length));
         else
-            readlen = min(length - pos, (UINT32)c->chunk_item->stripe_length);
+            readlen = min(length - pos, (uint32_t)c->chunk_item->stripe_length);
 
         if (csum) {
             ULONG good_stripe = 0xffffffff;
-            UINT16 k;
+            uint16_t k;
 
             for (k = 0; k < sub_stripes; k++) {
                 if (c->devices[(stripe * sub_stripes) + k]->devobj) {
@@ -1043,17 +1039,17 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                         if (RtlCompareMemory(context->stripes[(stripe * sub_stripes) + k].buf + stripeoff[stripe],
                                             context->stripes[(stripe * sub_stripes) + good_stripe].buf + stripeoff[stripe],
                                             readlen) != readlen) {
-                            context->stripes[(stripe * sub_stripes) + k].csum_error = TRUE;
-                            csum_error = TRUE;
+                            context->stripes[(stripe * sub_stripes) + k].csum_error = true;
+                            csum_error = true;
                             log_device_error(Vcb, c->devices[(stripe * sub_stripes) + k], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                         }
                     } else {
                         for (j = 0; j < readlen; j += Vcb->superblock.sector_size) {
-                            UINT32 crc32 = ~calc_crc32c(0xffffffff, context->stripes[(stripe * sub_stripes) + k].buf + stripeoff[stripe] + j, Vcb->superblock.sector_size);
+                            uint32_t crc32 = ~calc_crc32c(0xffffffff, context->stripes[(stripe * sub_stripes) + k].buf + stripeoff[stripe] + j, Vcb->superblock.sector_size);
 
                             if (crc32 != csum[(pos + j) / Vcb->superblock.sector_size]) {
-                                csum_error = TRUE;
-                                context->stripes[(stripe * sub_stripes) + k].csum_error = TRUE;
+                                csum_error = true;
+                                context->stripes[(stripe * sub_stripes) + k].csum_error = true;
                                 log_device_error(Vcb, c->devices[(stripe * sub_stripes) + k], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                                 break;
                             }
@@ -1069,7 +1065,7 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
             stripeoff[stripe] += readlen;
         } else {
             ULONG good_stripe = 0xffffffff;
-            UINT16 k;
+            uint16_t k;
 
             for (k = 0; k < sub_stripes; k++) {
                 if (c->devices[(stripe * sub_stripes) + k]->devobj) {
@@ -1078,19 +1074,19 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                         if (RtlCompareMemory(context->stripes[(stripe * sub_stripes) + k].buf + stripeoff[stripe],
                                             context->stripes[(stripe * sub_stripes) + good_stripe].buf + stripeoff[stripe],
                                             readlen) != readlen) {
-                            context->stripes[(stripe * sub_stripes) + k].csum_error = TRUE;
-                            csum_error = TRUE;
+                            context->stripes[(stripe * sub_stripes) + k].csum_error = true;
+                            csum_error = true;
                             log_device_error(Vcb, c->devices[(stripe * sub_stripes) + k], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                         }
                     } else {
                         for (j = 0; j < readlen; j += Vcb->superblock.node_size) {
                             tree_header* th = (tree_header*)(context->stripes[(stripe * sub_stripes) + k].buf + stripeoff[stripe] + j);
-                            UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
-                            UINT64 addr = offset + pos + j;
+                            uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                            uint64_t addr = offset + pos + j;
 
-                            if (crc32 != *((UINT32*)th->csum) || th->address != addr) {
-                                csum_error = TRUE;
-                                context->stripes[(stripe * sub_stripes) + k].csum_error = TRUE;
+                            if (crc32 != *((uint32_t*)th->csum) || th->address != addr) {
+                                csum_error = true;
+                                context->stripes[(stripe * sub_stripes) + k].csum_error = true;
                                 log_device_error(Vcb, c->devices[(stripe * sub_stripes) + k], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                                 break;
                             }
@@ -1116,8 +1112,8 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
 
     for (j = 0; j < c->chunk_item->num_stripes; j += sub_stripes) {
         ULONG goodstripe = 0xffffffff;
-        UINT16 k;
-        BOOL hasbadstripe = FALSE;
+        uint16_t k;
+        bool hasbadstripe = false;
 
         if (context->stripes[j].length == 0)
             continue;
@@ -1127,7 +1123,7 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                 if (!context->stripes[j + k].csum_error)
                     goodstripe = k;
                 else
-                    hasbadstripe = TRUE;
+                    hasbadstripe = true;
             }
         }
 
@@ -1135,20 +1131,20 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
             if (goodstripe != 0xffffffff) {
                 for (k = 0; k < sub_stripes; k++) {
                     if (c->devices[j + k]->devobj && context->stripes[j + k].csum_error) {
-                        UINT32 so = 0;
-                        BOOL recovered = FALSE;
+                        uint32_t so = 0;
+                        bool recovered = false;
 
                         pos = 0;
 
                         stripe = startoffstripe;
                         while (pos < length) {
-                            UINT32 readlen;
+                            uint32_t readlen;
 
                             if (pos == 0)
-                                readlen = (UINT32)min(context->stripes[stripe * sub_stripes].length,
+                                readlen = (uint32_t)min(context->stripes[stripe * sub_stripes].length,
                                               c->chunk_item->stripe_length - (context->stripes[stripe * sub_stripes].start % c->chunk_item->stripe_length));
                             else
-                                readlen = min(length - pos, (UINT32)c->chunk_item->stripe_length);
+                                readlen = min(length - pos, (uint32_t)c->chunk_item->stripe_length);
 
                             if (stripe == j / sub_stripes) {
                                 if (csum) {
@@ -1158,11 +1154,11 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                                         if (RtlCompareMemory(context->stripes[j + k].buf + so,
                                                              context->stripes[j + goodstripe].buf + so,
                                                              Vcb->superblock.sector_size) != Vcb->superblock.sector_size) {
-                                            UINT64 addr = offset + pos;
+                                            uint64_t addr = offset + pos;
 
-                                            log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, FALSE, TRUE, FALSE);
+                                            log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, false, true, false);
 
-                                            recovered = TRUE;
+                                            recovered = true;
                                         }
 
                                         pos += Vcb->superblock.sector_size;
@@ -1175,11 +1171,11 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                                         if (RtlCompareMemory(context->stripes[j + k].buf + so,
                                                             context->stripes[j + goodstripe].buf + so,
                                                             Vcb->superblock.node_size) != Vcb->superblock.node_size) {
-                                            UINT64 addr = offset + pos;
+                                            uint64_t addr = offset + pos;
 
-                                            log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, TRUE, TRUE, FALSE);
+                                            log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, true, true, false);
 
-                                            recovered = TRUE;
+                                            recovered = true;
                                         }
 
                                         pos += Vcb->superblock.node_size;
@@ -1198,7 +1194,7 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                             if (!c->devices[j + k]->readonly) {
                                 CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
 
-                                Status = write_data_phys(c->devices[j + k]->devobj, cis[j + k].offset + offset - c->offset,
+                                Status = write_data_phys(c->devices[j + k]->devobj, c->devices[j + k]->fileobj, cis[j + k].offset + offset - c->offset,
                                                          context->stripes[j + goodstripe].buf, context->stripes[j + goodstripe].length);
 
                                 if (!NT_SUCCESS(Status)) {
@@ -1211,13 +1207,13 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                     }
                 }
             } else {
-                UINT32 so = 0;
-                BOOL recovered = FALSE;
+                uint32_t so = 0;
+                bool recovered = false;
 
                 if (csum) {
                     for (k = 0; k < sub_stripes; k++) {
                         if (c->devices[j + k]->devobj) {
-                            context->stripes[j + k].bad_csums = ExAllocatePoolWithTag(PagedPool, context->stripes[j + k].length * sizeof(UINT32) / Vcb->superblock.sector_size, ALLOC_TAG);
+                            context->stripes[j + k].bad_csums = ExAllocatePoolWithTag(PagedPool, context->stripes[j + k].length * sizeof(uint32_t) / Vcb->superblock.sector_size, ALLOC_TAG);
                             if (!context->stripes[j + k].bad_csums) {
                                 ERR("out of memory\n");
                                 Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1236,7 +1232,7 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                         if (c->devices[j + k]->devobj) {
                             ULONG l;
 
-                            context->stripes[j + k].bad_csums = ExAllocatePoolWithTag(PagedPool, context->stripes[j + k].length * sizeof(UINT32) / Vcb->superblock.node_size, ALLOC_TAG);
+                            context->stripes[j + k].bad_csums = ExAllocatePoolWithTag(PagedPool, context->stripes[j + k].length * sizeof(uint32_t) / Vcb->superblock.node_size, ALLOC_TAG);
                             if (!context->stripes[j + k].bad_csums) {
                                 ERR("out of memory\n");
                                 Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1245,7 +1241,7 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
 
                             for (l = 0; l < context->stripes[j + k].length / Vcb->superblock.node_size; l++) {
                                 tree_header* th = (tree_header*)&context->stripes[j + k].buf[l * Vcb->superblock.node_size];
-                                UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                                uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
                                 context->stripes[j + k].bad_csums[l] = crc32;
                             }
@@ -1257,27 +1253,27 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
 
                 stripe = startoffstripe;
                 while (pos < length) {
-                    UINT32 readlen;
+                    uint32_t readlen;
 
                     if (pos == 0)
-                        readlen = (UINT32)min(context->stripes[stripe * sub_stripes].length,
+                        readlen = (uint32_t)min(context->stripes[stripe * sub_stripes].length,
                                       c->chunk_item->stripe_length - (context->stripes[stripe * sub_stripes].start % c->chunk_item->stripe_length));
                     else
-                        readlen = min(length - pos, (UINT32)c->chunk_item->stripe_length);
+                        readlen = min(length - pos, (uint32_t)c->chunk_item->stripe_length);
 
                     if (stripe == j / sub_stripes) {
                         ULONG l;
 
                         if (csum) {
                             for (l = 0; l < readlen; l += Vcb->superblock.sector_size) {
-                                UINT32 crc32 = csum[pos / Vcb->superblock.sector_size];
-                                BOOL has_error = FALSE;
+                                uint32_t crc32 = csum[pos / Vcb->superblock.sector_size];
+                                bool has_error = false;
 
                                 goodstripe = 0xffffffff;
                                 for (k = 0; k < sub_stripes; k++) {
                                     if (c->devices[j + k]->devobj) {
                                         if (context->stripes[j + k].bad_csums[so / Vcb->superblock.sector_size] != crc32)
-                                            has_error = TRUE;
+                                            has_error = true;
                                         else
                                             goodstripe = k;
                                     }
@@ -1287,22 +1283,22 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                                     if (goodstripe != 0xffffffff) {
                                         for (k = 0; k < sub_stripes; k++) {
                                             if (c->devices[j + k]->devobj && context->stripes[j + k].bad_csums[so / Vcb->superblock.sector_size] != crc32) {
-                                                UINT64 addr = offset + pos;
+                                                uint64_t addr = offset + pos;
 
-                                                log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, FALSE, TRUE, FALSE);
+                                                log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, false, true, false);
 
-                                                recovered = TRUE;
+                                                recovered = true;
 
                                                 RtlCopyMemory(context->stripes[j + k].buf + so, context->stripes[j + goodstripe].buf + so,
                                                               Vcb->superblock.sector_size);
                                             }
                                         }
                                     } else {
-                                        UINT64 addr = offset + pos;
+                                        uint64_t addr = offset + pos;
 
                                         for (k = 0; k < sub_stripes; k++) {
                                             if (c->devices[j + j]->devobj) {
-                                                log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, FALSE, FALSE, FALSE);
+                                                log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, false, false, false);
                                                 log_device_error(Vcb, c->devices[j + k], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                                             }
                                         }
@@ -1317,23 +1313,23 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                                 for (k = 0; k < sub_stripes; k++) {
                                     if (c->devices[j + k]->devobj) {
                                         tree_header* th = (tree_header*)&context->stripes[j + k].buf[so];
-                                        UINT64 addr = offset + pos;
+                                        uint64_t addr = offset + pos;
 
-                                        if (context->stripes[j + k].bad_csums[so / Vcb->superblock.node_size] != *((UINT32*)th->csum) || th->address != addr) {
+                                        if (context->stripes[j + k].bad_csums[so / Vcb->superblock.node_size] != *((uint32_t*)th->csum) || th->address != addr) {
                                             ULONG m;
 
-                                            recovered = FALSE;
+                                            recovered = false;
 
                                             for (m = 0; m < sub_stripes; m++) {
                                                 if (m != k) {
                                                     tree_header* th2 = (tree_header*)&context->stripes[j + m].buf[so];
 
-                                                    if (context->stripes[j + m].bad_csums[so / Vcb->superblock.node_size] == *((UINT32*)th2->csum) && th2->address == addr) {
-                                                        log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, TRUE, TRUE, FALSE);
+                                                    if (context->stripes[j + m].bad_csums[so / Vcb->superblock.node_size] == *((uint32_t*)th2->csum) && th2->address == addr) {
+                                                        log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, true, true, false);
 
                                                         RtlCopyMemory(th, th2, Vcb->superblock.node_size);
 
-                                                        recovered = TRUE;
+                                                        recovered = true;
                                                         break;
                                                     } else
                                                         log_device_error(Vcb, c->devices[j + m], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
@@ -1341,7 +1337,7 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                                             }
 
                                             if (!recovered)
-                                                log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, TRUE, FALSE, FALSE);
+                                                log_error(Vcb, addr, c->devices[j + k]->devitem.dev_id, true, false, false);
                                         }
                                     }
                                 }
@@ -1363,7 +1359,7 @@ static NTSTATUS scrub_extent_raid10(device_extension* Vcb, chunk* c, UINT64 offs
                         if (c->devices[j + k]->devobj && !c->devices[j + k]->readonly) {
                             CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
 
-                            Status = write_data_phys(c->devices[j + k]->devobj, cis[j + k].offset + offset - c->offset,
+                            Status = write_data_phys(c->devices[j + k]->devobj, c->devices[j + k]->fileobj, cis[j + k].offset + offset - c->offset,
                                                      context->stripes[j + k].buf, context->stripes[j + k].length);
 
                             if (!NT_SUCCESS(Status)) {
@@ -1386,14 +1382,14 @@ end:
     return Status;
 }
 
-static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG type, UINT64 offset, UINT32 size, UINT32* csum) {
+static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG type, uint64_t offset, uint32_t size, uint32_t* csum) {
     ULONG i;
     scrub_context context;
     CHUNK_ITEM_STRIPE* cis;
     NTSTATUS Status;
-    UINT16 startoffstripe, num_missing, allowed_missing;
+    uint16_t startoffstripe, num_missing, allowed_missing;
 
-    TRACE("(%p, %p, %llx, %llx, %p)\n", Vcb, c, offset, size, csum);
+    TRACE("(%p, %p, %I64x, %I64x, %p)\n", Vcb, c, offset, size, csum);
 
     context.stripes = ExAllocatePoolWithTag(NonPagedPool, sizeof(scrub_context_stripe) * c->chunk_item->num_stripes, ALLOC_TAG);
     if (!context.stripes) {
@@ -1409,8 +1405,8 @@ static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG type, UINT64
     cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
 
     if (type == BLOCK_FLAG_RAID0) {
-        UINT64 startoff, endoff;
-        UINT16 endoffstripe;
+        uint64_t startoff, endoff;
+        uint16_t endoffstripe;
 
         get_raid0_offset(offset - c->offset, c->chunk_item->stripe_length, c->chunk_item->num_stripes, &startoff, &startoffstripe);
         get_raid0_offset(offset + size - c->offset - 1, c->chunk_item->stripe_length, c->chunk_item->num_stripes, &endoff, &endoffstripe);
@@ -1424,23 +1420,23 @@ static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG type, UINT64
                 context.stripes[i].start = startoff - (startoff % c->chunk_item->stripe_length);
 
             if (endoffstripe > i)
-                context.stripes[i].length = (UINT32)(endoff - (endoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length - context.stripes[i].start);
+                context.stripes[i].length = (uint32_t)(endoff - (endoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length - context.stripes[i].start);
             else if (endoffstripe == i)
-                context.stripes[i].length = (UINT32)(endoff + 1 - context.stripes[i].start);
+                context.stripes[i].length = (uint32_t)(endoff + 1 - context.stripes[i].start);
             else
-                context.stripes[i].length = (UINT32)(endoff - (endoff % c->chunk_item->stripe_length) - context.stripes[i].start);
+                context.stripes[i].length = (uint32_t)(endoff - (endoff % c->chunk_item->stripe_length) - context.stripes[i].start);
         }
 
         allowed_missing = 0;
     } else if (type == BLOCK_FLAG_RAID10) {
-        UINT64 startoff, endoff;
-        UINT16 endoffstripe, j, sub_stripes = max(c->chunk_item->sub_stripes, 1);
+        uint64_t startoff, endoff;
+        uint16_t endoffstripe, j, sub_stripes = max(c->chunk_item->sub_stripes, 1);
 
         get_raid0_offset(offset - c->offset, c->chunk_item->stripe_length, c->chunk_item->num_stripes / sub_stripes, &startoff, &startoffstripe);
         get_raid0_offset(offset + size - c->offset - 1, c->chunk_item->stripe_length, c->chunk_item->num_stripes / sub_stripes, &endoff, &endoffstripe);
 
         if ((c->chunk_item->num_stripes % sub_stripes) != 0) {
-            ERR("chunk %llx: num_stripes %x was not a multiple of sub_stripes %x!\n", c->offset, c->chunk_item->num_stripes, sub_stripes);
+            ERR("chunk %I64x: num_stripes %x was not a multiple of sub_stripes %x!\n", c->offset, c->chunk_item->num_stripes, sub_stripes);
             Status = STATUS_INTERNAL_ERROR;
             goto end;
         }
@@ -1457,11 +1453,11 @@ static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG type, UINT64
                 context.stripes[i].start = startoff - (startoff % c->chunk_item->stripe_length);
 
             if (endoffstripe > i)
-                context.stripes[i].length = (UINT32)(endoff - (endoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length - context.stripes[i].start);
+                context.stripes[i].length = (uint32_t)(endoff - (endoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length - context.stripes[i].start);
             else if (endoffstripe == i)
-                context.stripes[i].length = (UINT32)(endoff + 1 - context.stripes[i].start);
+                context.stripes[i].length = (uint32_t)(endoff + 1 - context.stripes[i].start);
             else
-                context.stripes[i].length = (UINT32)(endoff - (endoff % c->chunk_item->stripe_length) - context.stripes[i].start);
+                context.stripes[i].length = (uint32_t)(endoff - (endoff % c->chunk_item->stripe_length) - context.stripes[i].start);
 
             for (j = 1; j < sub_stripes; j++) {
                 context.stripes[i+j].start = context.stripes[i].start;
@@ -1507,7 +1503,7 @@ static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG type, UINT64
                 goto end;
             }
 
-            context.stripes[i].Irp = IoAllocateIrp(c->devices[i]->devobj->StackSize, FALSE);
+            context.stripes[i].Irp = IoAllocateIrp(c->devices[i]->devobj->StackSize, false);
 
             if (!context.stripes[i].Irp) {
                 ERR("IoAllocateIrp failed\n");
@@ -1517,6 +1513,7 @@ static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG type, UINT64
 
             IrpSp = IoGetNextIrpStackLocation(context.stripes[i].Irp);
             IrpSp->MajorFunction = IRP_MJ_READ;
+            IrpSp->FileObject = c->devices[i]->fileobj;
 
             if (c->devices[i]->devobj->Flags & DO_BUFFERED_IO) {
                 context.stripes[i].Irp->AssociatedIrp.SystemBuffer = ExAllocatePoolWithTag(NonPagedPool, context.stripes[i].length, ALLOC_TAG);
@@ -1530,7 +1527,7 @@ static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG type, UINT64
 
                 context.stripes[i].Irp->UserBuffer = context.stripes[i].buf;
             } else if (c->devices[i]->devobj->Flags & DO_DIRECT_IO) {
-                context.stripes[i].Irp->MdlAddress = IoAllocateMdl(context.stripes[i].buf, context.stripes[i].length, FALSE, FALSE, NULL);
+                context.stripes[i].Irp->MdlAddress = IoAllocateMdl(context.stripes[i].buf, context.stripes[i].length, false, false, NULL);
                 if (!context.stripes[i].Irp->MdlAddress) {
                     ERR("IoAllocateMdl failed\n");
                     Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1559,7 +1556,7 @@ static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG type, UINT64
 
             context.stripes[i].Irp->UserIosb = &context.stripes[i].iosb;
 
-            IoSetCompletionRoutine(context.stripes[i].Irp, scrub_read_completion, &context.stripes[i], TRUE, TRUE, TRUE);
+            IoSetCompletionRoutine(context.stripes[i].Irp, scrub_read_completion, &context.stripes[i], true, true, true);
 
             context.stripes_left++;
 
@@ -1573,14 +1570,14 @@ static NTSTATUS scrub_extent(device_extension* Vcb, chunk* c, ULONG type, UINT64
         goto end;
     }
 
-    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&context.Event, NotificationEvent, false);
 
     for (i = 0; i < c->chunk_item->num_stripes; i++) {
         if (c->devices[i]->devobj && context.stripes[i].length > 0)
             IoCallDriver(c->devices[i]->devobj, context.stripes[i].Irp);
     }
 
-    KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+    KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
 
     // return an error if any of the stripes returned an error
     for (i = 0; i < c->chunk_item->num_stripes; i++) {
@@ -1635,13 +1632,23 @@ end:
     return Status;
 }
 
-static NTSTATUS scrub_data_extent(device_extension* Vcb, chunk* c, UINT64 offset, ULONG type, UINT32* csum, RTL_BITMAP* bmp) {
+static NTSTATUS scrub_data_extent(device_extension* Vcb, chunk* c, uint64_t offset, ULONG type, uint32_t* csum, RTL_BITMAP* bmp, ULONG bmplen) {
     NTSTATUS Status;
     ULONG runlength, index;
 
     runlength = RtlFindFirstRunClear(bmp, &index);
 
     while (runlength != 0) {
+        if (index >= bmplen)
+            break;
+
+        if (index + runlength >= bmplen) {
+            runlength = bmplen - index;
+
+            if (runlength == 0)
+                break;
+        }
+
         do {
             ULONG rl;
 
@@ -1667,12 +1674,12 @@ static NTSTATUS scrub_data_extent(device_extension* Vcb, chunk* c, UINT64 offset
 }
 
 typedef struct {
-    UINT8* buf;
+    uint8_t* buf;
     PIRP Irp;
     void* context;
     IO_STATUS_BLOCK iosb;
-    UINT64 offset;
-    BOOL rewrite, missing;
+    uint64_t offset;
+    bool rewrite, missing;
     RTL_BITMAP error;
     ULONG* errorarr;
 } scrub_context_raid56_stripe;
@@ -1684,17 +1691,13 @@ typedef struct {
     RTL_BITMAP alloc;
     RTL_BITMAP has_csum;
     RTL_BITMAP is_tree;
-    UINT32* csum;
-    UINT8* parity_scratch;
-    UINT8* parity_scratch2;
+    uint32_t* csum;
+    uint8_t* parity_scratch;
+    uint8_t* parity_scratch2;
 } scrub_context_raid56;
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI scrub_read_completion_raid56(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#else
-static NTSTATUS scrub_read_completion_raid56(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#endif
+static NTSTATUS __stdcall scrub_read_completion_raid56(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
     scrub_context_raid56_stripe* stripe = conptr;
     scrub_context_raid56* context = (scrub_context_raid56*)stripe->context;
     LONG left = InterlockedDecrement(&context->stripes_left);
@@ -1704,16 +1707,16 @@ static NTSTATUS scrub_read_completion_raid56(PDEVICE_OBJECT DeviceObject, PIRP I
     stripe->iosb = Irp->IoStatus;
 
     if (left == 0)
-        KeSetEvent(&context->Event, 0, FALSE);
+        KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
 
-static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_raid56* context, UINT64 stripe_start, UINT64 bit_start,
-                               UINT64 num, UINT16 missing_devices) {
+static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_raid56* context, uint64_t stripe_start, uint64_t bit_start,
+                               uint64_t num, uint16_t missing_devices) {
     ULONG sectors_per_stripe = (ULONG)(c->chunk_item->stripe_length / Vcb->superblock.sector_size), i, off;
-    UINT16 stripe, parity = (bit_start + num + c->chunk_item->num_stripes - 1) % c->chunk_item->num_stripes;
-    UINT64 stripeoff;
+    uint16_t stripe, parity = (bit_start + num + c->chunk_item->num_stripes - 1) % c->chunk_item->num_stripes;
+    uint64_t stripeoff;
 
     stripe = (parity + 1) % c->chunk_item->num_stripes;
     off = (ULONG)(bit_start + num - stripe_start) * sectors_per_stripe * (c->chunk_item->num_stripes - 1);
@@ -1729,15 +1732,15 @@ static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
             if (c->devices[stripe]->devobj && RtlCheckBit(&context->alloc, off)) {
                 if (RtlCheckBit(&context->is_tree, off)) {
                     tree_header* th = (tree_header*)&context->stripes[stripe].buf[stripeoff * Vcb->superblock.sector_size];
-                    UINT64 addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 1) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
-                    UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                    uint64_t addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 1) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
+                    uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-                    if (crc32 != *((UINT32*)th->csum) || th->address != addr) {
+                    if (crc32 != *((uint32_t*)th->csum) || th->address != addr) {
                         RtlSetBits(&context->stripes[stripe].error, i, Vcb->superblock.node_size / Vcb->superblock.sector_size);
                         log_device_error(Vcb, c->devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
 
                         if (missing_devices > 0)
-                            log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, TRUE, FALSE, FALSE);
+                            log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, true, false, false);
                     }
 
                     off += Vcb->superblock.node_size / Vcb->superblock.sector_size;
@@ -1746,16 +1749,16 @@ static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
 
                     continue;
                 } else if (RtlCheckBit(&context->has_csum, off)) {
-                    UINT32 crc32 = ~calc_crc32c(0xffffffff, context->stripes[stripe].buf + (stripeoff * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
+                    uint32_t crc32 = ~calc_crc32c(0xffffffff, context->stripes[stripe].buf + (stripeoff * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
                     if (crc32 != context->csum[off]) {
                         RtlSetBit(&context->stripes[stripe].error, i);
                         log_device_error(Vcb, c->devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
 
                         if (missing_devices > 0) {
-                            UINT64 addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 1) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
+                            uint64_t addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 1) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
 
-                            log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, FALSE, FALSE, FALSE);
+                            log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, false, false, false);
                         }
                     }
                 }
@@ -1798,15 +1801,15 @@ static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
 
     for (i = 0; i < sectors_per_stripe; i++) {
         ULONG num_errors = 0, bad_off;
-        UINT64 bad_stripe;
-        BOOL alloc = FALSE;
+        uint64_t bad_stripe;
+        bool alloc = false;
 
         stripe = (parity + 1) % c->chunk_item->num_stripes;
         off = (ULONG)((bit_start + num - stripe_start) * sectors_per_stripe * (c->chunk_item->num_stripes - 1)) + i;
 
         while (stripe != parity) {
             if (RtlCheckBit(&context->alloc, off)) {
-                alloc = TRUE;
+                alloc = true;
 
                 if (RtlCheckBit(&context->stripes[stripe].error, i)) {
                     bad_stripe = stripe;
@@ -1826,7 +1829,7 @@ static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
             continue;
 
         if (num_errors == 0 && RtlCheckBit(&context->stripes[parity].error, i)) { // parity error
-            UINT64 addr;
+            uint64_t addr;
 
             do_xor(&context->stripes[parity].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
                    &context->parity_scratch[i * Vcb->superblock.sector_size],
@@ -1835,13 +1838,13 @@ static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
             bad_off = (ULONG)((bit_start + num - stripe_start) * sectors_per_stripe * (c->chunk_item->num_stripes - 1)) + i;
             addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 1) * c->chunk_item->stripe_length) + (bad_off * Vcb->superblock.sector_size);
 
-            context->stripes[parity].rewrite = TRUE;
+            context->stripes[parity].rewrite = true;
 
-            log_error(Vcb, addr, c->devices[parity]->devitem.dev_id, FALSE, TRUE, TRUE);
+            log_error(Vcb, addr, c->devices[parity]->devitem.dev_id, false, true, true);
             log_device_error(Vcb, c->devices[parity], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
         } else if (num_errors == 1) {
-            UINT32 crc32;
-            UINT64 addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 1) * c->chunk_item->stripe_length) + (bad_off * Vcb->superblock.sector_size);
+            uint32_t crc32;
+            uint64_t addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 1) * c->chunk_item->stripe_length) + (bad_off * Vcb->superblock.sector_size);
 
             if (RtlCheckBit(&context->is_tree, bad_off)) {
                 tree_header* th;
@@ -1851,19 +1854,19 @@ static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
                        Vcb->superblock.node_size);
 
                 th = (tree_header*)&context->parity_scratch[i * Vcb->superblock.sector_size];
-                crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-                if (crc32 == *((UINT32*)th->csum) && th->address == addr) {
+                if (crc32 == *((uint32_t*)th->csum) && th->address == addr) {
                     RtlCopyMemory(&context->stripes[bad_stripe].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
                                   &context->parity_scratch[i * Vcb->superblock.sector_size], Vcb->superblock.node_size);
 
-                    context->stripes[bad_stripe].rewrite = TRUE;
+                    context->stripes[bad_stripe].rewrite = true;
 
                     RtlClearBits(&context->stripes[bad_stripe].error, i + 1, (Vcb->superblock.node_size / Vcb->superblock.sector_size) - 1);
 
-                    log_error(Vcb, addr, c->devices[bad_stripe]->devitem.dev_id, TRUE, TRUE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe]->devitem.dev_id, true, true, false);
                 } else
-                    log_error(Vcb, addr, c->devices[bad_stripe]->devitem.dev_id, TRUE, FALSE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe]->devitem.dev_id, true, false, false);
             } else {
                 do_xor(&context->parity_scratch[i * Vcb->superblock.sector_size],
                        &context->stripes[bad_stripe].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
@@ -1875,11 +1878,11 @@ static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
                     RtlCopyMemory(&context->stripes[bad_stripe].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
                                   &context->parity_scratch[i * Vcb->superblock.sector_size], Vcb->superblock.sector_size);
 
-                    context->stripes[bad_stripe].rewrite = TRUE;
+                    context->stripes[bad_stripe].rewrite = true;
 
-                    log_error(Vcb, addr, c->devices[bad_stripe]->devitem.dev_id, FALSE, TRUE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe]->devitem.dev_id, false, true, false);
                 } else
-                    log_error(Vcb, addr, c->devices[bad_stripe]->devitem.dev_id, FALSE, FALSE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe]->devitem.dev_id, false, false, false);
             }
         } else {
             stripe = (parity + 1) % c->chunk_item->num_stripes;
@@ -1888,9 +1891,9 @@ static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
             while (stripe != parity) {
                 if (RtlCheckBit(&context->alloc, off)) {
                     if (RtlCheckBit(&context->stripes[stripe].error, i)) {
-                        UINT64 addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 1) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
+                        uint64_t addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 1) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
 
-                        log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, RtlCheckBit(&context->is_tree, off), FALSE, FALSE);
+                        log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, RtlCheckBit(&context->is_tree, off), false, false);
                     }
                 }
 
@@ -1901,12 +1904,12 @@ static void scrub_raid5_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
     }
 }
 
-static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_raid56* context, UINT64 stripe_start, UINT64 bit_start,
-                               UINT64 num, UINT16 missing_devices) {
+static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_raid56* context, uint64_t stripe_start, uint64_t bit_start,
+                               uint64_t num, uint16_t missing_devices) {
     ULONG sectors_per_stripe = (ULONG)(c->chunk_item->stripe_length / Vcb->superblock.sector_size), i, off;
-    UINT16 stripe, parity1 = (bit_start + num + c->chunk_item->num_stripes - 2) % c->chunk_item->num_stripes;
-    UINT16 parity2 = (parity1 + 1) % c->chunk_item->num_stripes;
-    UINT64 stripeoff;
+    uint16_t stripe, parity1 = (bit_start + num + c->chunk_item->num_stripes - 2) % c->chunk_item->num_stripes;
+    uint16_t parity2 = (parity1 + 1) % c->chunk_item->num_stripes;
+    uint64_t stripeoff;
 
     stripe = (parity1 + 2) % c->chunk_item->num_stripes;
     off = (ULONG)(bit_start + num - stripe_start) * sectors_per_stripe * (c->chunk_item->num_stripes - 2);
@@ -1925,15 +1928,15 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
             if (c->devices[stripe]->devobj && RtlCheckBit(&context->alloc, off)) {
                 if (RtlCheckBit(&context->is_tree, off)) {
                     tree_header* th = (tree_header*)&context->stripes[stripe].buf[stripeoff * Vcb->superblock.sector_size];
-                    UINT64 addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
-                    UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                    uint64_t addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
+                    uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-                    if (crc32 != *((UINT32*)th->csum) || th->address != addr) {
+                    if (crc32 != *((uint32_t*)th->csum) || th->address != addr) {
                         RtlSetBits(&context->stripes[stripe].error, i, Vcb->superblock.node_size / Vcb->superblock.sector_size);
                         log_device_error(Vcb, c->devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
 
                         if (missing_devices == 2)
-                            log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, TRUE, FALSE, FALSE);
+                            log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, true, false, false);
                     }
 
                     off += Vcb->superblock.node_size / Vcb->superblock.sector_size;
@@ -1942,16 +1945,16 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
 
                     continue;
                 } else if (RtlCheckBit(&context->has_csum, off)) {
-                    UINT32 crc32 = ~calc_crc32c(0xffffffff, context->stripes[stripe].buf + (stripeoff * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
+                    uint32_t crc32 = ~calc_crc32c(0xffffffff, context->stripes[stripe].buf + (stripeoff * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
 
                     if (crc32 != context->csum[off]) {
-                        UINT64 addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
+                        uint64_t addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
 
                         RtlSetBit(&context->stripes[stripe].error, i);
                         log_device_error(Vcb, c->devices[stripe], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
 
                         if (missing_devices == 2)
-                            log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, FALSE, FALSE, FALSE);
+                            log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, false, false, false);
                     }
                 }
             }
@@ -1961,7 +1964,7 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
         }
 
         if (c->devices[parity1]->devobj)
-            do_xor(context->parity_scratch, &context->stripes[stripe].buf[num * c->chunk_item->stripe_length], (UINT32)c->chunk_item->stripe_length);
+            do_xor(context->parity_scratch, &context->stripes[stripe].buf[num * c->chunk_item->stripe_length], (uint32_t)c->chunk_item->stripe_length);
 
         stripe = (stripe + 1) % c->chunk_item->num_stripes;
         stripeoff = num * sectors_per_stripe;
@@ -1994,8 +1997,8 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
         stripe = parity1 == 0 ? (c->chunk_item->num_stripes - 1) : (parity1 - 1);
 
         while (stripe != parity2) {
-            galois_double(context->parity_scratch2, (UINT32)c->chunk_item->stripe_length);
-            do_xor(context->parity_scratch2, &context->stripes[stripe].buf[num * c->chunk_item->stripe_length], (UINT32)c->chunk_item->stripe_length);
+            galois_double(context->parity_scratch2, (uint32_t)c->chunk_item->stripe_length);
+            do_xor(context->parity_scratch2, &context->stripes[stripe].buf[num * c->chunk_item->stripe_length], (uint32_t)c->chunk_item->stripe_length);
 
             stripe = stripe == 0 ? (c->chunk_item->num_stripes - 1) : (stripe - 1);
         }
@@ -2014,16 +2017,16 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
 
     for (i = 0; i < sectors_per_stripe; i++) {
         ULONG num_errors = 0;
-        UINT64 bad_stripe1, bad_stripe2;
+        uint64_t bad_stripe1, bad_stripe2;
         ULONG bad_off1, bad_off2;
-        BOOL alloc = FALSE;
+        bool alloc = false;
 
         stripe = (parity1 + 2) % c->chunk_item->num_stripes;
         off = (ULONG)((bit_start + num - stripe_start) * sectors_per_stripe * (c->chunk_item->num_stripes - 2)) + i;
 
         while (stripe != parity1) {
             if (RtlCheckBit(&context->alloc, off)) {
-                alloc = TRUE;
+                alloc = true;
 
                 if (!c->devices[stripe]->devobj || RtlCheckBit(&context->stripes[stripe].error, i)) {
                     if (num_errors == 0) {
@@ -2048,7 +2051,7 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
             continue;
 
         if (num_errors == 0) { // parity error
-            UINT64 addr;
+            uint64_t addr;
 
             if (RtlCheckBit(&context->stripes[parity1].error, i)) {
                 do_xor(&context->stripes[parity1].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
@@ -2058,9 +2061,9 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
                 bad_off1 = (ULONG)((bit_start + num - stripe_start) * sectors_per_stripe * (c->chunk_item->num_stripes - 2)) + i;
                 addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (bad_off1 * Vcb->superblock.sector_size);
 
-                context->stripes[parity1].rewrite = TRUE;
+                context->stripes[parity1].rewrite = true;
 
-                log_error(Vcb, addr, c->devices[parity1]->devitem.dev_id, FALSE, TRUE, TRUE);
+                log_error(Vcb, addr, c->devices[parity1]->devitem.dev_id, false, true, true);
                 log_device_error(Vcb, c->devices[parity1], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
             }
 
@@ -2072,16 +2075,16 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
                 bad_off1 = (ULONG)((bit_start + num - stripe_start) * sectors_per_stripe * (c->chunk_item->num_stripes - 2)) + i;
                 addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (bad_off1 * Vcb->superblock.sector_size);
 
-                context->stripes[parity2].rewrite = TRUE;
+                context->stripes[parity2].rewrite = true;
 
-                log_error(Vcb, addr, c->devices[parity2]->devitem.dev_id, FALSE, TRUE, TRUE);
+                log_error(Vcb, addr, c->devices[parity2]->devitem.dev_id, false, true, true);
                 log_device_error(Vcb, c->devices[parity2], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
             }
         } else if (num_errors == 1) {
-            UINT32 crc32a, crc32b, len;
-            UINT16 stripe_num, bad_stripe_num;
-            UINT64 addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (bad_off1 * Vcb->superblock.sector_size);
-            UINT8* scratch;
+            uint32_t crc32a, crc32b, len;
+            uint16_t stripe_num, bad_stripe_num;
+            uint64_t addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (bad_off1 * Vcb->superblock.sector_size);
+            uint8_t* scratch;
 
             len = RtlCheckBit(&context->is_tree, bad_off1)? Vcb->superblock.node_size : Vcb->superblock.sector_size;
 
@@ -2115,7 +2118,7 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
                 do_xor(scratch, &context->stripes[parity2].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)], len);
 
                 if (bad_stripe_num != 0)
-                    galois_divpower(scratch, (UINT8)bad_stripe_num, len);
+                    galois_divpower(scratch, (uint8_t)bad_stripe_num, len);
             }
 
             if (RtlCheckBit(&context->is_tree, bad_off1)) {
@@ -2123,17 +2126,17 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
 
                 if (c->devices[parity1]->devobj) {
                     th1 = (tree_header*)&context->parity_scratch[i * Vcb->superblock.sector_size];
-                    crc32a = ~calc_crc32c(0xffffffff, (UINT8*)&th1->fs_uuid, Vcb->superblock.node_size - sizeof(th1->csum));
+                    crc32a = ~calc_crc32c(0xffffffff, (uint8_t*)&th1->fs_uuid, Vcb->superblock.node_size - sizeof(th1->csum));
                 }
 
                 if (c->devices[parity2]->devobj) {
                     th2 = (tree_header*)scratch;
-                    crc32b = ~calc_crc32c(0xffffffff, (UINT8*)&th2->fs_uuid, Vcb->superblock.node_size - sizeof(th2->csum));
+                    crc32b = ~calc_crc32c(0xffffffff, (uint8_t*)&th2->fs_uuid, Vcb->superblock.node_size - sizeof(th2->csum));
                 }
 
-                if ((c->devices[parity1]->devobj && crc32a == *((UINT32*)th1->csum) && th1->address == addr) ||
-                    (c->devices[parity2]->devobj && crc32b == *((UINT32*)th2->csum) && th2->address == addr)) {
-                    if (!c->devices[parity1]->devobj || crc32a != *((UINT32*)th1->csum) || th1->address != addr) {
+                if ((c->devices[parity1]->devobj && crc32a == *((uint32_t*)th1->csum) && th1->address == addr) ||
+                    (c->devices[parity2]->devobj && crc32b == *((uint32_t*)th2->csum) && th2->address == addr)) {
+                    if (!c->devices[parity1]->devobj || crc32a != *((uint32_t*)th1->csum) || th1->address != addr) {
                         RtlCopyMemory(&context->stripes[bad_stripe1].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
                                       scratch, Vcb->superblock.node_size);
 
@@ -2156,16 +2159,16 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
                                 stripe = (stripe + 1) % c->chunk_item->num_stripes;
                             }
 
-                            context->stripes[parity1].rewrite = TRUE;
+                            context->stripes[parity1].rewrite = true;
 
-                            log_error(Vcb, addr, c->devices[parity1]->devitem.dev_id, FALSE, TRUE, TRUE);
+                            log_error(Vcb, addr, c->devices[parity1]->devitem.dev_id, false, true, true);
                             log_device_error(Vcb, c->devices[parity1], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                         }
                     } else {
                         RtlCopyMemory(&context->stripes[bad_stripe1].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
                                       &context->parity_scratch[i * Vcb->superblock.sector_size], Vcb->superblock.node_size);
 
-                        if (!c->devices[parity2]->devobj || crc32b != *((UINT32*)th2->csum) || th2->address != addr) {
+                        if (!c->devices[parity2]->devobj || crc32b != *((uint32_t*)th2->csum) || th2->address != addr) {
                             // fix parity 2
                             stripe = parity1 == 0 ? (c->chunk_item->num_stripes - 1) : (parity1 - 1);
 
@@ -2186,21 +2189,21 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
                                     stripe = stripe == 0 ? (c->chunk_item->num_stripes - 1) : (stripe - 1);
                                 }
 
-                                context->stripes[parity2].rewrite = TRUE;
+                                context->stripes[parity2].rewrite = true;
 
-                                log_error(Vcb, addr, c->devices[parity2]->devitem.dev_id, FALSE, TRUE, TRUE);
+                                log_error(Vcb, addr, c->devices[parity2]->devitem.dev_id, false, true, true);
                                 log_device_error(Vcb, c->devices[parity2], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                             }
                         }
                     }
 
-                    context->stripes[bad_stripe1].rewrite = TRUE;
+                    context->stripes[bad_stripe1].rewrite = true;
 
                     RtlClearBits(&context->stripes[bad_stripe1].error, i + 1, (Vcb->superblock.node_size / Vcb->superblock.sector_size) - 1);
 
-                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, TRUE, TRUE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, true, true, false);
                 } else
-                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, TRUE, FALSE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, true, false, false);
             } else {
                 if (c->devices[parity1]->devobj)
                     crc32a = ~calc_crc32c(0xffffffff, &context->parity_scratch[i * Vcb->superblock.sector_size], Vcb->superblock.sector_size);
@@ -2232,9 +2235,9 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
                                 stripe = (stripe + 1) % c->chunk_item->num_stripes;
                             }
 
-                            context->stripes[parity1].rewrite = TRUE;
+                            context->stripes[parity1].rewrite = true;
 
-                            log_error(Vcb, addr, c->devices[parity1]->devitem.dev_id, FALSE, TRUE, TRUE);
+                            log_error(Vcb, addr, c->devices[parity1]->devitem.dev_id, false, true, true);
                             log_device_error(Vcb, c->devices[parity1], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                         }
                     } else {
@@ -2261,27 +2264,27 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
                                 stripe = stripe == 0 ? (c->chunk_item->num_stripes - 1) : (stripe - 1);
                             }
 
-                            context->stripes[parity2].rewrite = TRUE;
+                            context->stripes[parity2].rewrite = true;
 
-                            log_error(Vcb, addr, c->devices[parity2]->devitem.dev_id, FALSE, TRUE, TRUE);
+                            log_error(Vcb, addr, c->devices[parity2]->devitem.dev_id, false, true, true);
                             log_device_error(Vcb, c->devices[parity2], BTRFS_DEV_STAT_CORRUPTION_ERRORS);
                         }
                     }
 
-                    context->stripes[bad_stripe1].rewrite = TRUE;
+                    context->stripes[bad_stripe1].rewrite = true;
 
-                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, FALSE, TRUE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, false, true, false);
                 } else
-                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, FALSE, FALSE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, false, false, false);
             }
 
             ExFreePool(scratch);
         } else if (num_errors == 2 && missing_devices == 0) {
-            UINT16 x, y, k;
-            UINT64 addr;
-            UINT32 len = (RtlCheckBit(&context->is_tree, bad_off1) || RtlCheckBit(&context->is_tree, bad_off2)) ? Vcb->superblock.node_size : Vcb->superblock.sector_size;
-            UINT8 gyx, gx, denom, a, b, *p, *q, *pxy, *qxy;
-            UINT32 j;
+            uint16_t x, y, k;
+            uint64_t addr;
+            uint32_t len = (RtlCheckBit(&context->is_tree, bad_off1) || RtlCheckBit(&context->is_tree, bad_off2)) ? Vcb->superblock.node_size : Vcb->superblock.sector_size;
+            uint8_t gyx, gx, denom, a, b, *p, *q, *pxy, *qxy;
+            uint32_t j;
 
             stripe = parity1 == 0 ? (c->chunk_item->num_stripes - 1) : (parity1 - 1);
 
@@ -2352,62 +2355,62 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
 
             if (RtlCheckBit(&context->is_tree, bad_off1)) {
                 tree_header* th = (tree_header*)&context->parity_scratch[i * Vcb->superblock.sector_size];
-                UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-                if (crc32 == *((UINT32*)th->csum) && th->address == addr) {
+                if (crc32 == *((uint32_t*)th->csum) && th->address == addr) {
                     RtlCopyMemory(&context->stripes[bad_stripe1].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
                                   &context->parity_scratch[i * Vcb->superblock.sector_size], Vcb->superblock.node_size);
 
-                    context->stripes[bad_stripe1].rewrite = TRUE;
+                    context->stripes[bad_stripe1].rewrite = true;
 
                     RtlClearBits(&context->stripes[bad_stripe1].error, i + 1, (Vcb->superblock.node_size / Vcb->superblock.sector_size) - 1);
 
-                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, TRUE, TRUE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, true, true, false);
                 } else
-                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, TRUE, FALSE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, true, false, false);
             } else {
-                UINT32 crc32 = ~calc_crc32c(0xffffffff, &context->parity_scratch[i * Vcb->superblock.sector_size], Vcb->superblock.sector_size);
+                uint32_t crc32 = ~calc_crc32c(0xffffffff, &context->parity_scratch[i * Vcb->superblock.sector_size], Vcb->superblock.sector_size);
 
                 if (crc32 == context->csum[bad_off1]) {
                     RtlCopyMemory(&context->stripes[bad_stripe1].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
                                   &context->parity_scratch[i * Vcb->superblock.sector_size], Vcb->superblock.sector_size);
 
-                    context->stripes[bad_stripe1].rewrite = TRUE;
+                    context->stripes[bad_stripe1].rewrite = true;
 
-                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, FALSE, TRUE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, false, true, false);
                 } else
-                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, FALSE, FALSE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe1]->devitem.dev_id, false, false, false);
             }
 
             addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (bad_off2 * Vcb->superblock.sector_size);
 
             if (RtlCheckBit(&context->is_tree, bad_off2)) {
                 tree_header* th = (tree_header*)&context->parity_scratch2[i * Vcb->superblock.sector_size];
-                UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
+                uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
 
-                if (crc32 == *((UINT32*)th->csum) && th->address == addr) {
+                if (crc32 == *((uint32_t*)th->csum) && th->address == addr) {
                     RtlCopyMemory(&context->stripes[bad_stripe2].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
                                   &context->parity_scratch2[i * Vcb->superblock.sector_size], Vcb->superblock.node_size);
 
-                    context->stripes[bad_stripe2].rewrite = TRUE;
+                    context->stripes[bad_stripe2].rewrite = true;
 
                     RtlClearBits(&context->stripes[bad_stripe2].error, i + 1, (Vcb->superblock.node_size / Vcb->superblock.sector_size) - 1);
 
-                    log_error(Vcb, addr, c->devices[bad_stripe2]->devitem.dev_id, TRUE, TRUE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe2]->devitem.dev_id, true, true, false);
                 } else
-                    log_error(Vcb, addr, c->devices[bad_stripe2]->devitem.dev_id, TRUE, FALSE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe2]->devitem.dev_id, true, false, false);
             } else {
-                UINT32 crc32 = ~calc_crc32c(0xffffffff, &context->parity_scratch2[i * Vcb->superblock.sector_size], Vcb->superblock.sector_size);
+                uint32_t crc32 = ~calc_crc32c(0xffffffff, &context->parity_scratch2[i * Vcb->superblock.sector_size], Vcb->superblock.sector_size);
 
                 if (crc32 == context->csum[bad_off2]) {
                     RtlCopyMemory(&context->stripes[bad_stripe2].buf[(num * c->chunk_item->stripe_length) + (i * Vcb->superblock.sector_size)],
                                   &context->parity_scratch2[i * Vcb->superblock.sector_size], Vcb->superblock.sector_size);
 
-                    context->stripes[bad_stripe2].rewrite = TRUE;
+                    context->stripes[bad_stripe2].rewrite = true;
 
-                    log_error(Vcb, addr, c->devices[bad_stripe2]->devitem.dev_id, FALSE, TRUE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe2]->devitem.dev_id, false, true, false);
                 } else
-                    log_error(Vcb, addr, c->devices[bad_stripe2]->devitem.dev_id, FALSE, FALSE, FALSE);
+                    log_error(Vcb, addr, c->devices[bad_stripe2]->devitem.dev_id, false, false, false);
             }
         } else {
             stripe = (parity2 + 1) % c->chunk_item->num_stripes;
@@ -2416,9 +2419,9 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
             while (stripe != parity1) {
                 if (c->devices[stripe]->devobj && RtlCheckBit(&context->alloc, off)) {
                     if (RtlCheckBit(&context->stripes[stripe].error, i)) {
-                        UINT64 addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
+                        uint64_t addr = c->offset + (stripe_start * (c->chunk_item->num_stripes - 2) * c->chunk_item->stripe_length) + (off * Vcb->superblock.sector_size);
 
-                        log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, RtlCheckBit(&context->is_tree, off), FALSE, FALSE);
+                        log_error(Vcb, addr, c->devices[stripe]->devitem.dev_id, RtlCheckBit(&context->is_tree, off), false, false);
                     }
                 }
 
@@ -2429,19 +2432,19 @@ static void scrub_raid6_stripe(device_extension* Vcb, chunk* c, scrub_context_ra
     }
 }
 
-static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, UINT64 stripe_start, UINT64 stripe_end) {
+static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, uint64_t stripe_start, uint64_t stripe_end) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
-    BOOL b;
-    UINT64 run_start, run_end, full_stripe_len, stripe;
-    UINT32 max_read, num_sectors;
+    bool b;
+    uint64_t run_start, run_end, full_stripe_len, stripe;
+    uint32_t max_read, num_sectors;
     ULONG arrlen, *allocarr, *csumarr = NULL, *treearr, num_parity_stripes = c->chunk_item->type & BLOCK_FLAG_RAID6 ? 2 : 1;
     scrub_context_raid56 context;
-    UINT16 i;
+    uint16_t i;
     CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
 
-    TRACE("(%p, %p, %llx, %llx)\n", Vcb, c, stripe_start, stripe_end);
+    TRACE("(%p, %p, %I64x, %I64x)\n", Vcb, c, stripe_start, stripe_end);
 
     full_stripe_len = (c->chunk_item->num_stripes - num_parity_stripes) * c->chunk_item->stripe_length;
     run_start = c->offset + (stripe_start * full_stripe_len);
@@ -2451,13 +2454,13 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
     searchkey.obj_type = TYPE_METADATA_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
     }
 
-    num_sectors = (UINT32)((stripe_end - stripe_start + 1) * full_stripe_len / Vcb->superblock.sector_size);
+    num_sectors = (uint32_t)((stripe_end - stripe_start + 1) * full_stripe_len / Vcb->superblock.sector_size);
     arrlen = (ULONG)sector_align((num_sectors / 8) + 1, sizeof(ULONG));
 
     allocarr = ExAllocatePoolWithTag(PagedPool, arrlen, ALLOC_TAG);
@@ -2500,7 +2503,7 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
         RtlInitializeBitMap(&context.has_csum, csumarr, num_sectors);
         RtlClearAllBits(&context.has_csum);
 
-        context.csum = ExAllocatePoolWithTag(PagedPool, num_sectors * sizeof(UINT32), ALLOC_TAG);
+        context.csum = ExAllocatePoolWithTag(PagedPool, num_sectors * sizeof(uint32_t), ALLOC_TAG);
         if (!context.csum) {
             ERR("out of memory\n");
             ExFreePool(allocarr);
@@ -2535,41 +2538,41 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
             break;
 
         if (tp.item->key.obj_type == TYPE_EXTENT_ITEM || tp.item->key.obj_type == TYPE_METADATA_ITEM) {
-            UINT64 size = tp.item->key.obj_type == TYPE_METADATA_ITEM ? Vcb->superblock.node_size : tp.item->key.offset;
+            uint64_t size = tp.item->key.obj_type == TYPE_METADATA_ITEM ? Vcb->superblock.node_size : tp.item->key.offset;
 
             if (tp.item->key.obj_id + size > run_start) {
-                UINT64 extent_start = max(run_start, tp.item->key.obj_id);
-                UINT64 extent_end = min(tp.item->key.obj_id + size, run_end);
-                BOOL extent_is_tree = FALSE;
+                uint64_t extent_start = max(run_start, tp.item->key.obj_id);
+                uint64_t extent_end = min(tp.item->key.obj_id + size, run_end);
+                bool extent_is_tree = false;
 
                 RtlSetBits(&context.alloc, (ULONG)((extent_start - run_start) / Vcb->superblock.sector_size), (ULONG)((extent_end - extent_start) / Vcb->superblock.sector_size));
 
                 if (tp.item->key.obj_type == TYPE_METADATA_ITEM)
-                    extent_is_tree = TRUE;
+                    extent_is_tree = true;
                 else {
                     EXTENT_ITEM* ei = (EXTENT_ITEM*)tp.item->data;
 
                     if (tp.item->size < sizeof(EXTENT_ITEM)) {
-                        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
+                        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
                         Status = STATUS_INTERNAL_ERROR;
                         goto end;
                     }
 
                     if (ei->flags & EXTENT_ITEM_TREE_BLOCK)
-                        extent_is_tree = TRUE;
+                        extent_is_tree = true;
                 }
 
                 if (extent_is_tree)
                     RtlSetBits(&context.is_tree, (ULONG)((extent_start - run_start) / Vcb->superblock.sector_size), (ULONG)((extent_end - extent_start) / Vcb->superblock.sector_size));
                 else if (c->chunk_item->type & BLOCK_FLAG_DATA) {
                     traverse_ptr tp2;
-                    BOOL b2;
+                    bool b2;
 
                     searchkey.obj_id = EXTENT_CSUM_ID;
                     searchkey.obj_type = TYPE_EXTENT_CSUM;
                     searchkey.offset = extent_start;
 
-                    Status = find_item(Vcb, Vcb->checksum_root, &tp2, &searchkey, FALSE, NULL);
+                    Status = find_item(Vcb, Vcb->checksum_root, &tp2, &searchkey, false, NULL);
                     if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND) {
                         ERR("find_item returned %08x\n", Status);
                         goto end;
@@ -2582,17 +2585,17 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
                             break;
 
                         if (tp2.item->key.offset >= extent_start) {
-                            UINT64 csum_start = max(extent_start, tp2.item->key.offset);
-                            UINT64 csum_end = min(extent_end, tp2.item->key.offset + (tp2.item->size * Vcb->superblock.sector_size / sizeof(UINT32)));
+                            uint64_t csum_start = max(extent_start, tp2.item->key.offset);
+                            uint64_t csum_end = min(extent_end, tp2.item->key.offset + (tp2.item->size * Vcb->superblock.sector_size / sizeof(uint32_t)));
 
                             RtlSetBits(&context.has_csum, (ULONG)((csum_start - run_start) / Vcb->superblock.sector_size), (ULONG)((csum_end - csum_start) / Vcb->superblock.sector_size));
 
                             RtlCopyMemory(&context.csum[(csum_start - run_start) / Vcb->superblock.sector_size],
-                                          tp2.item->data + ((csum_start - tp2.item->key.offset) * sizeof(UINT32) / Vcb->superblock.sector_size),
-                                          (ULONG)((csum_end - csum_start) * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                          tp2.item->data + ((csum_start - tp2.item->key.offset) * sizeof(uint32_t) / Vcb->superblock.sector_size),
+                                          (ULONG)((csum_end - csum_start) * sizeof(uint32_t) / Vcb->superblock.sector_size));
                         }
 
-                        b2 = find_next_item(Vcb, &tp2, &next_tp2, FALSE, NULL);
+                        b2 = find_next_item(Vcb, &tp2, &next_tp2, false, NULL);
 
                         if (b2)
                             tp2 = next_tp2;
@@ -2601,7 +2604,7 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
             }
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, NULL);
+        b = find_next_item(Vcb, &tp, &next_tp, false, NULL);
 
         if (b)
             tp = next_tp;
@@ -2614,12 +2617,12 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
         goto end;
     }
 
-    max_read = (UINT32)min(1048576 / c->chunk_item->stripe_length, stripe_end - stripe_start + 1); // only process 1 MB of data at a time
+    max_read = (uint32_t)min(1048576 / c->chunk_item->stripe_length, stripe_end - stripe_start + 1); // only process 1 MB of data at a time
 
     for (i = 0; i < c->chunk_item->num_stripes; i++) {
         context.stripes[i].buf = ExAllocatePoolWithTag(PagedPool, (ULONG)(max_read * c->chunk_item->stripe_length), ALLOC_TAG);
         if (!context.stripes[i].buf) {
-            UINT64 j;
+            uint64_t j;
 
             ERR("out of memory\n");
 
@@ -2634,7 +2637,7 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
 
         context.stripes[i].errorarr = ExAllocatePoolWithTag(PagedPool, (ULONG)sector_align(((c->chunk_item->stripe_length / Vcb->superblock.sector_size) / 8) + 1, sizeof(ULONG)), ALLOC_TAG);
         if (!context.stripes[i].errorarr) {
-            UINT64 j;
+            uint64_t j;
 
             ERR("out of memory\n");
 
@@ -2652,7 +2655,7 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
         RtlInitializeBitMap(&context.stripes[i].error, context.stripes[i].errorarr, (ULONG)(c->chunk_item->stripe_length / Vcb->superblock.sector_size));
 
         context.stripes[i].context = &context;
-        context.stripes[i].rewrite = FALSE;
+        context.stripes[i].rewrite = false;
     }
 
     stripe = stripe_start;
@@ -2663,8 +2666,8 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
 
     do {
         ULONG read_stripes;
-        UINT16 missing_devices = 0;
-        BOOL need_wait = FALSE;
+        uint16_t missing_devices = 0;
+        bool need_wait = false;
 
         if (max_read < stripe_end + 1 - stripe)
             read_stripes = max_read;
@@ -2678,7 +2681,7 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
             if (c->devices[i]->devobj) {
                 PIO_STACK_LOCATION IrpSp;
 
-                context.stripes[i].Irp = IoAllocateIrp(c->devices[i]->devobj->StackSize, FALSE);
+                context.stripes[i].Irp = IoAllocateIrp(c->devices[i]->devobj->StackSize, false);
 
                 if (!context.stripes[i].Irp) {
                     ERR("IoAllocateIrp failed\n");
@@ -2690,6 +2693,7 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
 
                 IrpSp = IoGetNextIrpStackLocation(context.stripes[i].Irp);
                 IrpSp->MajorFunction = IRP_MJ_READ;
+                IrpSp->FileObject = c->devices[i]->fileobj;
 
                 if (c->devices[i]->devobj->Flags & DO_BUFFERED_IO) {
                     context.stripes[i].Irp->AssociatedIrp.SystemBuffer = ExAllocatePoolWithTag(NonPagedPool, (ULONG)(read_stripes * c->chunk_item->stripe_length), ALLOC_TAG);
@@ -2703,7 +2707,7 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
 
                     context.stripes[i].Irp->UserBuffer = context.stripes[i].buf;
                 } else if (c->devices[i]->devobj->Flags & DO_DIRECT_IO) {
-                    context.stripes[i].Irp->MdlAddress = IoAllocateMdl(context.stripes[i].buf, (ULONG)(read_stripes * c->chunk_item->stripe_length), FALSE, FALSE, NULL);
+                    context.stripes[i].Irp->MdlAddress = IoAllocateMdl(context.stripes[i].buf, (ULONG)(read_stripes * c->chunk_item->stripe_length), false, false, NULL);
                     if (!context.stripes[i].Irp->MdlAddress) {
                         ERR("IoAllocateMdl failed\n");
                         Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2732,15 +2736,15 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
                 IrpSp->Parameters.Read.ByteOffset.QuadPart = cis[i].offset + context.stripes[i].offset;
 
                 context.stripes[i].Irp->UserIosb = &context.stripes[i].iosb;
-                context.stripes[i].missing = FALSE;
+                context.stripes[i].missing = false;
 
-                IoSetCompletionRoutine(context.stripes[i].Irp, scrub_read_completion_raid56, &context.stripes[i], TRUE, TRUE, TRUE);
+                IoSetCompletionRoutine(context.stripes[i].Irp, scrub_read_completion_raid56, &context.stripes[i], true, true, true);
 
                 Vcb->scrub.data_scrubbed += read_stripes * c->chunk_item->stripe_length;
-                need_wait = TRUE;
+                need_wait = true;
             } else {
                 context.stripes[i].Irp = NULL;
-                context.stripes[i].missing = TRUE;
+                context.stripes[i].missing = true;
                 missing_devices++;
                 InterlockedDecrement(&context.stripes_left);
             }
@@ -2757,14 +2761,14 @@ static NTSTATUS scrub_chunk_raid56_stripe_run(device_extension* Vcb, chunk* c, U
         }
 
         if (need_wait) {
-            KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+            KeInitializeEvent(&context.Event, NotificationEvent, false);
 
             for (i = 0; i < c->chunk_item->num_stripes; i++) {
                 if (c->devices[i]->devobj)
                     IoCallDriver(c->devices[i]->devobj, context.stripes[i].Irp);
             }
 
-            KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+            KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
         }
 
         // return an error if any of the stripes returned an error
@@ -2798,8 +2802,8 @@ end3:
                 context.stripes[i].Irp = NULL;
 
                 if (context.stripes[i].rewrite) {
-                    Status = write_data_phys(c->devices[i]->devobj, cis[i].offset + context.stripes[i].offset,
-                                             context.stripes[i].buf, (UINT32)(read_stripes * c->chunk_item->stripe_length));
+                    Status = write_data_phys(c->devices[i]->devobj, c->devices[i]->fileobj, cis[i].offset + context.stripes[i].offset,
+                                             context.stripes[i].buf, (uint32_t)(read_stripes * c->chunk_item->stripe_length));
 
                     if (!NT_SUCCESS(Status)) {
                         ERR("write_data_phys returned %08x\n", Status);
@@ -2839,12 +2843,12 @@ end:
     return Status;
 }
 
-static NTSTATUS scrub_chunk_raid56(device_extension* Vcb, chunk* c, UINT64* offset, BOOL* changed) {
+static NTSTATUS scrub_chunk_raid56(device_extension* Vcb, chunk* c, uint64_t* offset, bool* changed) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
-    BOOL b;
-    UINT64 full_stripe_len, stripe, stripe_start, stripe_end, total_data = 0;
+    bool b;
+    uint64_t full_stripe_len, stripe, stripe_start, stripe_end, total_data = 0;
     ULONG num_extents = 0, num_parity_stripes = c->chunk_item->type & BLOCK_FLAG_RAID6 ? 2 : 1;
 
     full_stripe_len = (c->chunk_item->num_stripes - num_parity_stripes) * c->chunk_item->stripe_length;
@@ -2856,13 +2860,13 @@ static NTSTATUS scrub_chunk_raid56(device_extension* Vcb, chunk* c, UINT64* offs
     searchkey.obj_type = TYPE_METADATA_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
     }
 
-    *changed = FALSE;
+    *changed = false;
 
     do {
         traverse_ptr next_tp;
@@ -2871,12 +2875,12 @@ static NTSTATUS scrub_chunk_raid56(device_extension* Vcb, chunk* c, UINT64* offs
             break;
 
         if (tp.item->key.obj_id >= *offset && (tp.item->key.obj_type == TYPE_EXTENT_ITEM || tp.item->key.obj_type == TYPE_METADATA_ITEM)) {
-            UINT64 size = tp.item->key.obj_type == TYPE_METADATA_ITEM ? Vcb->superblock.node_size : tp.item->key.offset;
+            uint64_t size = tp.item->key.obj_type == TYPE_METADATA_ITEM ? Vcb->superblock.node_size : tp.item->key.offset;
 
-            TRACE("%llx\n", tp.item->key.obj_id);
+            TRACE("%I64x\n", tp.item->key.obj_id);
 
             if (size < Vcb->superblock.sector_size) {
-                ERR("extent %llx has size less than sector_size (%llx < %x)\n", tp.item->key.obj_id, Vcb->superblock.sector_size);
+                ERR("extent %I64x has size less than sector_size (%I64x < %x)\n", tp.item->key.obj_id, Vcb->superblock.sector_size);
                 return STATUS_INTERNAL_ERROR;
             }
 
@@ -2897,7 +2901,7 @@ static NTSTATUS scrub_chunk_raid56(device_extension* Vcb, chunk* c, UINT64* offs
 
             stripe_end = (tp.item->key.obj_id + size - 1 - c->offset) / full_stripe_len;
 
-            *changed = TRUE;
+            *changed = true;
 
             total_data += size;
             num_extents++;
@@ -2907,7 +2911,7 @@ static NTSTATUS scrub_chunk_raid56(device_extension* Vcb, chunk* c, UINT64* offs
                 break;
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, NULL);
+        b = find_next_item(Vcb, &tp, &next_tp, false, NULL);
 
         if (b)
             tp = next_tp;
@@ -2926,17 +2930,17 @@ static NTSTATUS scrub_chunk_raid56(device_extension* Vcb, chunk* c, UINT64* offs
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, UINT64* offset, BOOL* changed) {
+static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, uint64_t* offset, bool* changed) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
-    BOOL b = FALSE, tree_run = FALSE;
+    bool b = false, tree_run = false;
     ULONG type, num_extents = 0;
-    UINT64 total_data = 0, tree_run_start, tree_run_end;
+    uint64_t total_data = 0, tree_run_start, tree_run_end;
 
-    TRACE("chunk %llx\n", c->offset);
+    TRACE("chunk %I64x\n", c->offset);
 
-    ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
     if (c->chunk_item->type & BLOCK_FLAG_DUPLICATE)
         type = BLOCK_FLAG_DUPLICATE;
@@ -2959,7 +2963,7 @@ static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, UINT64* offset, BOO
     searchkey.obj_type = TYPE_METADATA_ITEM;
     searchkey.offset = 0xffffffffffffffff;
 
-    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("error - find_item returned %08x\n", Status);
         goto end;
@@ -2972,33 +2976,33 @@ static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, UINT64* offset, BOO
             break;
 
         if (tp.item->key.obj_id >= *offset && (tp.item->key.obj_type == TYPE_EXTENT_ITEM || tp.item->key.obj_type == TYPE_METADATA_ITEM)) {
-            UINT64 size = tp.item->key.obj_type == TYPE_METADATA_ITEM ? Vcb->superblock.node_size : tp.item->key.offset;
-            BOOL is_tree;
-            UINT32* csum = NULL;
+            uint64_t size = tp.item->key.obj_type == TYPE_METADATA_ITEM ? Vcb->superblock.node_size : tp.item->key.offset;
+            bool is_tree;
+            uint32_t* csum = NULL;
             RTL_BITMAP bmp;
-            ULONG* bmparr = NULL;
+            ULONG* bmparr = NULL, bmplen;
 
-            TRACE("%llx\n", tp.item->key.obj_id);
+            TRACE("%I64x\n", tp.item->key.obj_id);
 
-            is_tree = FALSE;
+            is_tree = false;
 
             if (tp.item->key.obj_type == TYPE_METADATA_ITEM)
-                is_tree = TRUE;
+                is_tree = true;
             else {
                 EXTENT_ITEM* ei = (EXTENT_ITEM*)tp.item->data;
 
                 if (tp.item->size < sizeof(EXTENT_ITEM)) {
-                    ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
+                    ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
                     Status = STATUS_INTERNAL_ERROR;
                     goto end;
                 }
 
                 if (ei->flags & EXTENT_ITEM_TREE_BLOCK)
-                    is_tree = TRUE;
+                    is_tree = true;
             }
 
             if (size < Vcb->superblock.sector_size) {
-                ERR("extent %llx has size less than sector_size (%llx < %x)\n", tp.item->key.obj_id, Vcb->superblock.sector_size);
+                ERR("extent %I64x has size less than sector_size (%I64x < %x)\n", tp.item->key.obj_id, Vcb->superblock.sector_size);
                 Status = STATUS_INTERNAL_ERROR;
                 goto end;
             }
@@ -3007,14 +3011,16 @@ static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, UINT64* offset, BOO
             if (!is_tree) {
                 traverse_ptr tp2;
 
-                csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(sizeof(UINT32) * size / Vcb->superblock.sector_size), ALLOC_TAG);
+                csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(sizeof(uint32_t) * size / Vcb->superblock.sector_size), ALLOC_TAG);
                 if (!csum) {
                     ERR("out of memory\n");
                     Status = STATUS_INSUFFICIENT_RESOURCES;
                     goto end;
                 }
 
-                bmparr = ExAllocatePoolWithTag(PagedPool, (ULONG)(sector_align(((size / Vcb->superblock.sector_size) >> 3) + 1, sizeof(ULONG))), ALLOC_TAG);
+                bmplen = (ULONG)(size / Vcb->superblock.sector_size);
+
+                bmparr = ExAllocatePoolWithTag(PagedPool, (ULONG)(sector_align((bmplen >> 3) + 1, sizeof(ULONG))), ALLOC_TAG);
                 if (!bmparr) {
                     ERR("out of memory\n");
                     ExFreePool(csum);
@@ -3022,14 +3028,14 @@ static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, UINT64* offset, BOO
                     goto end;
                 }
 
-                RtlInitializeBitMap(&bmp, bmparr, (ULONG)(size / Vcb->superblock.sector_size));
+                RtlInitializeBitMap(&bmp, bmparr, bmplen);
                 RtlSetAllBits(&bmp); // 1 = no csum, 0 = csum
 
                 searchkey.obj_id = EXTENT_CSUM_ID;
                 searchkey.obj_type = TYPE_EXTENT_CSUM;
                 searchkey.offset = tp.item->key.obj_id;
 
-                Status = find_item(Vcb, Vcb->checksum_root, &tp2, &searchkey, FALSE, NULL);
+                Status = find_item(Vcb, Vcb->checksum_root, &tp2, &searchkey, false, NULL);
                 if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND) {
                     ERR("find_item returned %08x\n", Status);
                     ExFreePool(csum);
@@ -3044,13 +3050,13 @@ static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, UINT64* offset, BOO
                         if (tp2.item->key.obj_type == TYPE_EXTENT_CSUM) {
                             if (tp2.item->key.offset >= tp.item->key.obj_id + size)
                                 break;
-                            else if (tp2.item->size >= sizeof(UINT32) && tp2.item->key.offset + (tp2.item->size * Vcb->superblock.sector_size / sizeof(UINT32)) >= tp.item->key.obj_id) {
-                                UINT64 cs = max(tp.item->key.obj_id, tp2.item->key.offset);
-                                UINT64 ce = min(tp.item->key.obj_id + size, tp2.item->key.offset + (tp2.item->size * Vcb->superblock.sector_size / sizeof(UINT32)));
+                            else if (tp2.item->size >= sizeof(uint32_t) && tp2.item->key.offset + (tp2.item->size * Vcb->superblock.sector_size / sizeof(uint32_t)) >= tp.item->key.obj_id) {
+                                uint64_t cs = max(tp.item->key.obj_id, tp2.item->key.offset);
+                                uint64_t ce = min(tp.item->key.obj_id + size, tp2.item->key.offset + (tp2.item->size * Vcb->superblock.sector_size / sizeof(uint32_t)));
 
                                 RtlCopyMemory(csum + ((cs - tp.item->key.obj_id) / Vcb->superblock.sector_size),
-                                              tp2.item->data + ((cs - tp2.item->key.offset) * sizeof(UINT32) / Vcb->superblock.sector_size),
-                                              (ULONG)((ce - cs) * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                              tp2.item->data + ((cs - tp2.item->key.offset) * sizeof(uint32_t) / Vcb->superblock.sector_size),
+                                              (ULONG)((ce - cs) * sizeof(uint32_t) / Vcb->superblock.sector_size));
 
                                 RtlClearBits(&bmp, (ULONG)((cs - tp.item->key.obj_id) / Vcb->superblock.sector_size), (ULONG)((ce - cs) / Vcb->superblock.sector_size));
 
@@ -3059,24 +3065,24 @@ static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, UINT64* offset, BOO
                             }
                         }
 
-                        if (find_next_item(Vcb, &tp2, &next_tp2, FALSE, NULL))
+                        if (find_next_item(Vcb, &tp2, &next_tp2, false, NULL))
                             tp2 = next_tp2;
                         else
                             break;
-                    } while (TRUE);
+                    } while (true);
                 }
             }
 
             if (tree_run) {
                 if (!is_tree || tp.item->key.obj_id > tree_run_end) {
-                    Status = scrub_extent(Vcb, c, type, tree_run_start, (UINT32)(tree_run_end - tree_run_start), NULL);
+                    Status = scrub_extent(Vcb, c, type, tree_run_start, (uint32_t)(tree_run_end - tree_run_start), NULL);
                     if (!NT_SUCCESS(Status)) {
                         ERR("scrub_extent returned %08x\n", Status);
                         goto end;
                     }
 
                     if (!is_tree)
-                        tree_run = FALSE;
+                        tree_run = false;
                     else {
                         tree_run_start = tp.item->key.obj_id;
                         tree_run_end = tp.item->key.obj_id + Vcb->superblock.node_size;
@@ -3084,13 +3090,13 @@ static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, UINT64* offset, BOO
                 } else
                     tree_run_end = tp.item->key.obj_id + Vcb->superblock.node_size;
             } else if (is_tree) {
-                tree_run = TRUE;
+                tree_run = true;
                 tree_run_start = tp.item->key.obj_id;
                 tree_run_end = tp.item->key.obj_id + Vcb->superblock.node_size;
             }
 
             if (!is_tree) {
-                Status = scrub_data_extent(Vcb, c, tp.item->key.obj_id, type, csum, &bmp);
+                Status = scrub_data_extent(Vcb, c, tp.item->key.obj_id, type, csum, &bmp, bmplen);
                 if (!NT_SUCCESS(Status)) {
                     ERR("scrub_data_extent returned %08x\n", Status);
                     ExFreePool(csum);
@@ -3103,7 +3109,7 @@ static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, UINT64* offset, BOO
             }
 
             *offset = tp.item->key.obj_id + size;
-            *changed = TRUE;
+            *changed = true;
 
             total_data += size;
             num_extents++;
@@ -3113,14 +3119,14 @@ static NTSTATUS scrub_chunk(device_extension* Vcb, chunk* c, UINT64* offset, BOO
                 break;
         }
 
-        b = find_next_item(Vcb, &tp, &next_tp, FALSE, NULL);
+        b = find_next_item(Vcb, &tp, &next_tp, false, NULL);
 
         if (b)
             tp = next_tp;
     } while (b);
 
     if (tree_run) {
-        Status = scrub_extent(Vcb, c, type, tree_run_start, (UINT32)(tree_run_end - tree_run_start), NULL);
+        Status = scrub_extent(Vcb, c, type, tree_run_start, (uint32_t)(tree_run_end - tree_run_start), NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("scrub_extent returned %08x\n", Status);
             goto end;
@@ -3136,21 +3142,17 @@ end:
 }
 
 _Function_class_(KSTART_ROUTINE)
-#ifdef __REACTOS__
-static void NTAPI scrub_thread(void* context) {
-#else
-static void scrub_thread(void* context) {
-#endif
+static void __stdcall scrub_thread(void* context) {
     device_extension* Vcb = context;
     LIST_ENTRY chunks, *le;
     NTSTATUS Status;
     LARGE_INTEGER time;
 
-    KeInitializeEvent(&Vcb->scrub.finished, NotificationEvent, FALSE);
+    KeInitializeEvent(&Vcb->scrub.finished, NotificationEvent, false);
 
     InitializeListHead(&chunks);
 
-    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
     if (Vcb->need_write && !Vcb->readonly)
         Status = do_write(Vcb, NULL);
@@ -3168,7 +3170,7 @@ static void scrub_thread(void* context) {
 
     ExConvertExclusiveToSharedLite(&Vcb->tree_lock);
 
-    ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, true);
 
     KeQuerySystemTime(&Vcb->scrub.start_time);
     Vcb->scrub.finish_time.QuadPart = 0;
@@ -3184,7 +3186,7 @@ static void scrub_thread(void* context) {
         ExFreePool(err);
     }
 
-    ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
     le = Vcb->chunks.Flink;
     while (le != &Vcb->chunks) {
@@ -3211,21 +3213,21 @@ static void scrub_thread(void* context) {
 
     while (!IsListEmpty(&chunks)) {
         chunk* c = CONTAINING_RECORD(RemoveHeadList(&chunks), chunk, list_entry_balance);
-        UINT64 offset = c->offset;
-        BOOL changed;
+        uint64_t offset = c->offset;
+        bool changed;
 
-        c->reloc = TRUE;
+        c->reloc = true;
 
-        KeWaitForSingleObject(&Vcb->scrub.event, Executive, KernelMode, FALSE, NULL);
+        KeWaitForSingleObject(&Vcb->scrub.event, Executive, KernelMode, false, NULL);
 
         if (!Vcb->scrub.stopping) {
             do {
-                changed = FALSE;
+                changed = false;
 
                 Status = scrub_chunk(Vcb, c, &offset, &changed);
                 if (!NT_SUCCESS(Status)) {
                     ERR("scrub_chunk returned %08x\n", Status);
-                    Vcb->scrub.stopping = TRUE;
+                    Vcb->scrub.stopping = true;
                     Vcb->scrub.error = Status;
                     break;
                 }
@@ -3233,11 +3235,11 @@ static void scrub_thread(void* context) {
                 if (offset == c->offset + c->chunk_item->size || Vcb->scrub.stopping)
                     break;
 
-                KeWaitForSingleObject(&Vcb->scrub.event, Executive, KernelMode, FALSE, NULL);
+                KeWaitForSingleObject(&Vcb->scrub.event, Executive, KernelMode, false, NULL);
             } while (changed);
         }
 
-        ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&Vcb->scrub.stats_lock, true);
 
         if (!Vcb->scrub.stopping)
             Vcb->scrub.chunks_left--;
@@ -3247,7 +3249,7 @@ static void scrub_thread(void* context) {
 
         ExReleaseResource(&Vcb->scrub.stats_lock);
 
-        c->reloc = FALSE;
+        c->reloc = false;
         c->list_entry_balance.Flink = NULL;
     }
 
@@ -3258,7 +3260,7 @@ end:
     ZwClose(Vcb->scrub.thread);
     Vcb->scrub.thread = NULL;
 
-    KeSetEvent(&Vcb->scrub.finished, 0, FALSE);
+    KeSetEvent(&Vcb->scrub.finished, 0, false);
 }
 
 NTSTATUS start_scrub(device_extension* Vcb, KPROCESSOR_MODE processor_mode) {
@@ -3285,8 +3287,8 @@ NTSTATUS start_scrub(device_extension* Vcb, KPROCESSOR_MODE processor_mode) {
     if (Vcb->readonly)
         return STATUS_MEDIA_WRITE_PROTECTED;
 
-    Vcb->scrub.stopping = FALSE;
-    Vcb->scrub.paused = FALSE;
+    Vcb->scrub.stopping = false;
+    Vcb->scrub.paused = false;
     Vcb->scrub.error = STATUS_SUCCESS;
     KeInitializeEvent(&Vcb->scrub.event, NotificationEvent, !Vcb->scrub.paused);
 
@@ -3312,7 +3314,7 @@ NTSTATUS query_scrub(device_extension* Vcb, KPROCESSOR_MODE processor_mode, void
     if (length < offsetof(btrfs_query_scrub, errors))
         return STATUS_BUFFER_TOO_SMALL;
 
-    ExAcquireResourceSharedLite(&Vcb->scrub.stats_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->scrub.stats_lock, true);
 
     if (Vcb->scrub.thread && Vcb->scrub.chunks_left > 0)
         bqs->status = Vcb->scrub.paused ? BTRFS_SCRUB_PAUSED : BTRFS_SCRUB_RUNNING;
@@ -3366,7 +3368,7 @@ NTSTATUS query_scrub(device_extension* Vcb, KPROCESSOR_MODE processor_mode, void
                 lastlen = offsetof(btrfs_scrub_error, data.filename) + bse->data.filename_length;
 
             bse->next_entry = lastlen;
-            bse = (btrfs_scrub_error*)(((UINT8*)bse) + lastlen);
+            bse = (btrfs_scrub_error*)(((uint8_t*)bse) + lastlen);
         }
 
         bse->next_entry = 0;
@@ -3411,7 +3413,7 @@ NTSTATUS pause_scrub(device_extension* Vcb, KPROCESSOR_MODE processor_mode) {
     if (Vcb->scrub.paused)
         return STATUS_DEVICE_NOT_READY;
 
-    Vcb->scrub.paused = TRUE;
+    Vcb->scrub.paused = true;
     KeClearEvent(&Vcb->scrub.event);
 
     KeQuerySystemTime(&time);
@@ -3430,8 +3432,8 @@ NTSTATUS resume_scrub(device_extension* Vcb, KPROCESSOR_MODE processor_mode) {
     if (!Vcb->scrub.paused)
         return STATUS_DEVICE_NOT_READY;
 
-    Vcb->scrub.paused = FALSE;
-    KeSetEvent(&Vcb->scrub.event, 0, FALSE);
+    Vcb->scrub.paused = false;
+    KeSetEvent(&Vcb->scrub.event, 0, false);
 
     KeQuerySystemTime(&Vcb->scrub.resume_time);
 
@@ -3445,9 +3447,9 @@ NTSTATUS stop_scrub(device_extension* Vcb, KPROCESSOR_MODE processor_mode) {
     if (!Vcb->scrub.thread)
         return STATUS_DEVICE_NOT_READY;
 
-    Vcb->scrub.paused = FALSE;
-    Vcb->scrub.stopping = TRUE;
-    KeSetEvent(&Vcb->scrub.event, 0, FALSE);
+    Vcb->scrub.paused = false;
+    Vcb->scrub.stopping = true;
+    KeSetEvent(&Vcb->scrub.event, 0, false);
 
     return STATUS_SUCCESS;
 }
diff --git a/drivers/filesystems/btrfs/search.c b/drivers/filesystems/btrfs/search.c
index 67a43871bb4..a1a4217aec9 100644
--- a/drivers/filesystems/btrfs/search.c
+++ b/drivers/filesystems/btrfs/search.c
@@ -17,12 +17,10 @@
 
 #include "btrfs_drv.h"
 
-#ifndef __REACTOS__
 #include <ntddk.h>
 #include <ntifs.h>
 #include <mountmgr.h>
 #include <windef.h>
-#endif
 #include <ntddstor.h>
 #include <ntdddisk.h>
 
@@ -34,27 +32,29 @@ extern LIST_ENTRY pdo_list;
 extern UNICODE_STRING registry_path;
 extern KEVENT mountmgr_thread_event;
 extern HANDLE mountmgr_thread_handle;
-extern BOOL shutting_down;
+extern bool shutting_down;
+extern PDEVICE_OBJECT busobj;
+extern tIoUnregisterPlugPlayNotificationEx fIoUnregisterPlugPlayNotificationEx;
 
 typedef void (*pnp_callback)(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath);
 
 extern PDEVICE_OBJECT master_devobj;
 
-static BOOL fs_ignored(BTRFS_UUID* uuid) {
+static bool fs_ignored(BTRFS_UUID* uuid) {
     UNICODE_STRING path, ignoreus;
     NTSTATUS Status;
     OBJECT_ATTRIBUTES oa;
     KEY_VALUE_FULL_INFORMATION* kvfi;
     ULONG dispos, retlen, kvfilen, i, j;
     HANDLE h;
-    BOOL ret = FALSE;
+    bool ret = false;
 
     path.Length = path.MaximumLength = registry_path.Length + (37 * sizeof(WCHAR));
 
     path.Buffer = ExAllocatePoolWithTag(PagedPool, path.Length, ALLOC_TAG);
     if (!path.Buffer) {
         ERR("out of memory\n");
-        return FALSE;
+        return false;
     }
 
     RtlCopyMemory(path.Buffer, registry_path.Buffer, registry_path.Length);
@@ -83,7 +83,7 @@ static BOOL fs_ignored(BTRFS_UUID* uuid) {
     if (!NT_SUCCESS(Status)) {
         TRACE("ZwCreateKey returned %08x\n", Status);
         ExFreePool(path.Buffer);
-        return FALSE;
+        return false;
     }
 
     RtlInitUnicodeString(&ignoreus, L"Ignore");
@@ -94,13 +94,13 @@ static BOOL fs_ignored(BTRFS_UUID* uuid) {
         ERR("out of memory\n");
         ZwClose(h);
         ExFreePool(path.Buffer);
-        return FALSE;
+        return false;
     }
 
     Status = ZwQueryValueKey(h, &ignoreus, KeyValueFullInformation, kvfi, kvfilen, &retlen);
     if (NT_SUCCESS(Status)) {
-        if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(UINT32)) {
-            UINT32* pr = (UINT32*)((UINT8*)kvfi + kvfi->DataOffset);
+        if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(uint32_t)) {
+            uint32_t* pr = (uint32_t*)((uint8_t*)kvfi + kvfi->DataOffset);
 
             ret = *pr;
         }
@@ -113,12 +113,12 @@ static BOOL fs_ignored(BTRFS_UUID* uuid) {
     return ret;
 }
 
-static void test_vol(PDEVICE_OBJECT mountmgr, PDEVICE_OBJECT DeviceObject, PUNICODE_STRING devpath,
-                     DWORD disk_num, DWORD part_num, UINT64 length) {
+static void test_vol(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
+                     PUNICODE_STRING devpath, DWORD disk_num, DWORD part_num, uint64_t length) {
     NTSTATUS Status;
     ULONG toread;
-    UINT8* data = NULL;
-    UINT32 sector_size;
+    uint8_t* data = NULL;
+    uint32_t sector_size;
 
     TRACE("%.*S\n", devpath->Length / sizeof(WCHAR), devpath->Buffer);
 
@@ -129,7 +129,7 @@ static void test_vol(PDEVICE_OBJECT mountmgr, PDEVICE_OBJECT DeviceObject, PUNIC
         IO_STATUS_BLOCK iosb;
 
         Status = dev_ioctl(DeviceObject, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
-                           &geometry, sizeof(DISK_GEOMETRY), TRUE, &iosb);
+                           &geometry, sizeof(DISK_GEOMETRY), true, &iosb);
 
         if (!NT_SUCCESS(Status)) {
             ERR("%.*S had a sector size of 0, and IOCTL_DISK_GET_DRIVE_GEOMETRY returned %08x\n",
@@ -157,13 +157,13 @@ static void test_vol(PDEVICE_OBJECT mountmgr, PDEVICE_OBJECT DeviceObject, PUNIC
         goto deref;
     }
 
-    Status = sync_read_phys(DeviceObject, superblock_addrs[0], toread, data, TRUE);
+    Status = sync_read_phys(DeviceObject, FileObject, superblock_addrs[0], toread, data, true);
 
     if (NT_SUCCESS(Status) && ((superblock*)data)->magic == BTRFS_MAGIC) {
         superblock* sb = (superblock*)data;
-        UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
+        uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
 
-        if (crc32 != *((UINT32*)sb->checksum))
+        if (crc32 != *((uint32_t*)sb->checksum))
             ERR("checksum error on superblock\n");
         else {
             TRACE("volume found\n");
@@ -178,12 +178,12 @@ static void test_vol(PDEVICE_OBJECT mountmgr, PDEVICE_OBJECT DeviceObject, PUNIC
                 }
 
                 while (superblock_addrs[i] > 0 && length >= superblock_addrs[i] + toread) {
-                    Status = sync_read_phys(DeviceObject, superblock_addrs[i], toread, (PUCHAR)sb2, TRUE);
+                    Status = sync_read_phys(DeviceObject, FileObject, superblock_addrs[i], toread, (PUCHAR)sb2, true);
 
                     if (NT_SUCCESS(Status) && sb2->magic == BTRFS_MAGIC) {
-                        crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb2->uuid, (ULONG)sizeof(superblock) - sizeof(sb2->checksum));
+                        crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb2->uuid, (ULONG)sizeof(superblock) - sizeof(sb2->checksum));
 
-                        if (crc32 == *((UINT32*)sb2->checksum) && sb2->generation > sb->generation)
+                        if (crc32 == *((uint32_t*)sb2->checksum) && sb2->generation > sb->generation)
                             RtlCopyMemory(sb, sb2, toread);
                     }
 
@@ -195,7 +195,7 @@ static void test_vol(PDEVICE_OBJECT mountmgr, PDEVICE_OBJECT DeviceObject, PUNIC
 
             if (!fs_ignored(&sb->uuid)) {
                 DeviceObject->Flags &= ~DO_VERIFY_VOLUME;
-                add_volume_device(sb, mountmgr, devpath, length, disk_num, part_num);
+                add_volume_device(sb, devpath, length, disk_num, part_num);
             }
         }
     }
@@ -227,7 +227,7 @@ NTSTATUS remove_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath) {
     mmp->DeviceNameLength = devpath->Length;
     RtlCopyMemory(&mmp[1], devpath->Buffer, devpath->Length);
 
-    Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_DELETE_POINTS, mmp, mmpsize, &mmps1, sizeof(MOUNTMGR_MOUNT_POINTS), FALSE, NULL);
+    Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_DELETE_POINTS, mmp, mmpsize, &mmps1, sizeof(MOUNTMGR_MOUNT_POINTS), false, NULL);
 
     if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
         ERR("IOCTL_MOUNTMGR_DELETE_POINTS 1 returned %08x\n", Status);
@@ -247,7 +247,7 @@ NTSTATUS remove_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath) {
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_DELETE_POINTS, mmp, mmpsize, mmps2, mmps1.Size, FALSE, NULL);
+    Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_DELETE_POINTS, mmp, mmpsize, mmps2, mmps1.Size, false, NULL);
 
     if (!NT_SUCCESS(Status))
         ERR("IOCTL_MOUNTMGR_DELETE_POINTS 2 returned %08x\n", Status);
@@ -259,29 +259,20 @@ NTSTATUS remove_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath) {
 }
 
 void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
-    PFILE_OBJECT FileObject, mountmgrfo;
-    PDEVICE_OBJECT devobj, mountmgr;
+    PFILE_OBJECT fileobj;
+    PDEVICE_OBJECT devobj;
     NTSTATUS Status;
     STORAGE_DEVICE_NUMBER sdn;
     ULONG dlisize;
     DRIVE_LAYOUT_INFORMATION_EX* dli = NULL;
     IO_STATUS_BLOCK iosb;
     GET_LENGTH_INFORMATION gli;
-    UNICODE_STRING mmdevpath;
 
     UNUSED(DriverObject);
 
-    Status = IoGetDeviceObjectPointer(devpath, FILE_READ_ATTRIBUTES, &FileObject, &devobj);
-    if (!NT_SUCCESS(Status)) {
-        ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
-        return;
-    }
-
-    RtlInitUnicodeString(&mmdevpath, MOUNTMGR_DEVICE_NAME);
-    Status = IoGetDeviceObjectPointer(&mmdevpath, FILE_READ_ATTRIBUTES, &mountmgrfo, &mountmgr);
+    Status = IoGetDeviceObjectPointer(devpath, FILE_READ_ATTRIBUTES, &fileobj, &devobj);
     if (!NT_SUCCESS(Status)) {
         ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
-        ObDereferenceObject(FileObject);
         return;
     }
 
@@ -300,7 +291,7 @@ void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
         }
 
         Status = dev_ioctl(devobj, IOCTL_DISK_GET_DRIVE_LAYOUT_EX, NULL, 0,
-                           dli, dlisize, TRUE, &iosb);
+                           dli, dlisize, true, &iosb);
     } while (Status == STATUS_BUFFER_TOO_SMALL);
 
     // only consider disk as a potential filesystem if it has no partitions
@@ -312,7 +303,7 @@ void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
     ExFreePool(dli);
 
     Status = dev_ioctl(devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
-                        &gli, sizeof(gli), TRUE, NULL);
+                        &gli, sizeof(gli), true, NULL);
 
     if (!NT_SUCCESS(Status)) {
         ERR("error reading length information: %08x\n", Status);
@@ -320,7 +311,7 @@ void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
     }
 
     Status = dev_ioctl(devobj, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0,
-                       &sdn, sizeof(STORAGE_DEVICE_NUMBER), TRUE, NULL);
+                       &sdn, sizeof(STORAGE_DEVICE_NUMBER), true, NULL);
     if (!NT_SUCCESS(Status)) {
         TRACE("IOCTL_STORAGE_GET_DEVICE_NUMBER returned %08x\n", Status);
         sdn.DeviceNumber = 0xffffffff;
@@ -328,25 +319,24 @@ void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
     } else
         TRACE("DeviceType = %u, DeviceNumber = %u, PartitionNumber = %u\n", sdn.DeviceType, sdn.DeviceNumber, sdn.PartitionNumber);
 
-    test_vol(mountmgr, devobj, devpath, sdn.DeviceNumber, sdn.PartitionNumber, gli.Length.QuadPart);
+    test_vol(devobj, fileobj, devpath, sdn.DeviceNumber, sdn.PartitionNumber, gli.Length.QuadPart);
 
 end:
-    ObDereferenceObject(FileObject);
-    ObDereferenceObject(mountmgrfo);
+    ObDereferenceObject(fileobj);
 }
 
 void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lock) _Releases_exclusive_lock_(_Curr_->child_lock) _In_ volume_device_extension* vde,
-                         _In_ volume_child* vc, _In_ BOOL skip_dev) {
+                         _In_ volume_child* vc, _In_ bool skip_dev) {
     NTSTATUS Status;
     pdo_device_extension* pdode = vde->pdode;
     device_extension* Vcb = vde->mounted_device ? vde->mounted_device->DeviceExtension : NULL;
 
-    if (vc->notification_entry)
-#ifdef __REACTOS__
-        IoUnregisterPlugPlayNotification(vc->notification_entry);
-#else
-        IoUnregisterPlugPlayNotificationEx(vc->notification_entry);
-#endif
+    if (vc->notification_entry) {
+        if (fIoUnregisterPlugPlayNotificationEx)
+            fIoUnregisterPlugPlayNotificationEx(vc->notification_entry);
+        else
+            IoUnregisterPlugPlayNotification(vc->notification_entry);
+    }
 
     if (vde->mounted_device && (!Vcb || !Vcb->options.allow_degraded)) {
         Status = pnp_surprise_removal(vde->mounted_device, NULL);
@@ -355,7 +345,7 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
     }
 
     if (!Vcb || !Vcb->options.allow_degraded) {
-        Status = IoSetDeviceInterfaceState(&vde->bus_name, FALSE);
+        Status = IoSetDeviceInterfaceState(&vde->bus_name, false);
         if (!NT_SUCCESS(Status))
             WARN("IoSetDeviceInterfaceState returned %08x\n", Status);
     }
@@ -380,7 +370,7 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
                     if (vc2->had_drive_letter) { // re-add entry to mountmgr
                         MOUNTDEV_NAME mdn;
 
-                        Status = dev_ioctl(vc2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), TRUE, NULL);
+                        Status = dev_ioctl(vc2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), true, NULL);
                         if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
                             ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
                         else {
@@ -391,7 +381,7 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
                             if (!mdn2)
                                 ERR("out of memory\n");
                             else {
-                                Status = dev_ioctl(vc2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, TRUE, NULL);
+                                Status = dev_ioctl(vc2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, true, NULL);
                                 if (!NT_SUCCESS(Status))
                                     ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
                                 else {
@@ -416,7 +406,7 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
                 ObDereferenceObject(FileObject);
             }
         } else if (!skip_dev) {
-            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
             le = Vcb->devices.Flink;
             while (le != &Vcb->devices) {
@@ -458,13 +448,13 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
     pdode->children_loaded--;
 
     if (pdode->children_loaded == 0) { // remove volume device
-        BOOL remove = FALSE;
+        bool remove = false;
 
         RemoveEntryList(&pdode->list_entry);
 
-        vde->removing = TRUE;
+        vde->removing = true;
 
-        Status = IoSetDeviceInterfaceState(&vde->bus_name, FALSE);
+        Status = IoSetDeviceInterfaceState(&vde->bus_name, false);
         if (!NT_SUCCESS(Status))
             WARN("IoSetDeviceInterfaceState returned %08x\n", Status);
 
@@ -472,14 +462,14 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
             IoDetachDevice(vde->pdo);
 
         if (vde->open_count == 0)
-            remove = TRUE;
+            remove = true;
 
         ExReleaseResourceLite(&pdode->child_lock);
 
         if (!no_pnp) {
-            control_device_extension* cde = master_devobj->DeviceExtension;
+            bus_device_extension* bde = busobj->DeviceExtension;
 
-            IoInvalidateDeviceRelations(cde->buspdo, BusRelations);
+            IoInvalidateDeviceRelations(bde->buspdo, BusRelations);
         }
 
         if (remove) {
@@ -499,15 +489,14 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
 
 void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
     STORAGE_DEVICE_NUMBER sdn;
-    PFILE_OBJECT FileObject, mountmgrfo;
-    UNICODE_STRING mmdevpath;
-    PDEVICE_OBJECT devobj, mountmgr;
+    PFILE_OBJECT fileobj;
+    PDEVICE_OBJECT devobj;
     GET_LENGTH_INFORMATION gli;
     NTSTATUS Status;
 
     TRACE("%.*S\n", devpath->Length / sizeof(WCHAR), devpath->Buffer);
 
-    Status = IoGetDeviceObjectPointer(devpath, FILE_READ_ATTRIBUTES, &FileObject, &devobj);
+    Status = IoGetDeviceObjectPointer(devpath, FILE_READ_ATTRIBUTES, &fileobj, &devobj);
     if (!NT_SUCCESS(Status)) {
         ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
         return;
@@ -518,14 +507,14 @@ void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
     if (devobj->DriverObject == DriverObject)
         goto end;
 
-    Status = dev_ioctl(devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli), TRUE, NULL);
+    Status = dev_ioctl(devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli), true, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("IOCTL_DISK_GET_LENGTH_INFO returned %08x\n", Status);
         goto end;
     }
 
     Status = dev_ioctl(devobj, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0,
-                       &sdn, sizeof(STORAGE_DEVICE_NUMBER), TRUE, NULL);
+                       &sdn, sizeof(STORAGE_DEVICE_NUMBER), true, NULL);
     if (!NT_SUCCESS(Status)) {
         TRACE("IOCTL_STORAGE_GET_DEVICE_NUMBER returned %08x\n", Status);
         sdn.DeviceNumber = 0xffffffff;
@@ -537,16 +526,16 @@ void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
     if (sdn.DeviceNumber != 0xffffffff && sdn.PartitionNumber != 0) {
         LIST_ENTRY* le;
 
-        ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&pdo_list_lock, true);
 
         le = pdo_list.Flink;
         while (le != &pdo_list) {
             pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
             LIST_ENTRY* le2;
-            BOOL changed = FALSE;
+            bool changed = false;
 
             if (pdode->vde) {
-                ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
+                ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
 
                 le2 = pdode->children.Flink;
                 while (le2 != &pdode->children) {
@@ -556,8 +545,8 @@ void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
                     if (vc->disk_num == sdn.DeviceNumber && vc->part_num == 0) {
                         TRACE("removing device\n");
 
-                        remove_volume_child(pdode->vde, vc, FALSE);
-                        changed = TRUE;
+                        remove_volume_child(pdode->vde, vc, false);
+                        changed = true;
 
                         break;
                     }
@@ -577,19 +566,10 @@ void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
         ExReleaseResourceLite(&pdo_list_lock);
     }
 
-    RtlInitUnicodeString(&mmdevpath, MOUNTMGR_DEVICE_NAME);
-    Status = IoGetDeviceObjectPointer(&mmdevpath, FILE_READ_ATTRIBUTES, &mountmgrfo, &mountmgr);
-    if (!NT_SUCCESS(Status)) {
-        ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
-        goto end;
-    }
-
-    test_vol(mountmgr, devobj, devpath, sdn.DeviceNumber, sdn.PartitionNumber, gli.Length.QuadPart);
-
-    ObDereferenceObject(mountmgrfo);
+    test_vol(devobj, fileobj, devpath, sdn.DeviceNumber, sdn.PartitionNumber, gli.Length.QuadPart);
 
 end:
-    ObDereferenceObject(FileObject);
+    ObDereferenceObject(fileobj);
 }
 
 void volume_removal(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
@@ -609,16 +589,16 @@ void volume_removal(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
         devpath2.MaximumLength -= 3 * sizeof(WCHAR);
     }
 
-    ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&pdo_list_lock, true);
 
     le = pdo_list.Flink;
     while (le != &pdo_list) {
         pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
         LIST_ENTRY* le2;
-        BOOL changed = FALSE;
+        bool changed = false;
 
         if (pdode->vde) {
-            ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
+            ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
 
             le2 = pdode->children.Flink;
             while (le2 != &pdode->children) {
@@ -628,8 +608,8 @@ void volume_removal(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
                 if (vc->pnp_name.Length == devpath2.Length && RtlCompareMemory(vc->pnp_name.Buffer, devpath2.Buffer, devpath2.Length) == devpath2.Length) {
                     TRACE("removing device\n");
 
-                    remove_volume_child(pdode->vde, vc, FALSE);
-                    changed = TRUE;
+                    remove_volume_child(pdode->vde, vc, false);
+                    changed = true;
 
                     break;
                 }
@@ -657,11 +637,7 @@ typedef struct {
 } pnp_callback_context;
 
 _Function_class_(IO_WORKITEM_ROUTINE)
-#ifdef __REACTOS__
-static void NTAPI do_pnp_callback(PDEVICE_OBJECT DeviceObject, PVOID con) {
-#else
-static void do_pnp_callback(PDEVICE_OBJECT DeviceObject, PVOID con) {
-#endif
+static void __stdcall do_pnp_callback(PDEVICE_OBJECT DeviceObject, PVOID con) {
     pnp_callback_context* context = con;
 
     UNUSED(DeviceObject);
@@ -713,11 +689,7 @@ static void enqueue_pnp_callback(PDRIVER_OBJECT DriverObject, PUNICODE_STRING na
 }
 
 _Function_class_(DRIVER_NOTIFICATION_CALLBACK_ROUTINE)
-#ifdef __REACTOS__
-NTSTATUS NTAPI volume_notification(PVOID NotificationStructure, PVOID Context) {
-#else
-NTSTATUS volume_notification(PVOID NotificationStructure, PVOID Context) {
-#endif
+NTSTATUS __stdcall volume_notification(PVOID NotificationStructure, PVOID Context) {
     DEVICE_INTERFACE_CHANGE_NOTIFICATION* dicn = (DEVICE_INTERFACE_CHANGE_NOTIFICATION*)NotificationStructure;
     PDRIVER_OBJECT DriverObject = (PDRIVER_OBJECT)Context;
 
@@ -730,11 +702,7 @@ NTSTATUS volume_notification(PVOID NotificationStructure, PVOID Context) {
 }
 
 _Function_class_(DRIVER_NOTIFICATION_CALLBACK_ROUTINE)
-#ifdef __REACTOS__
-NTSTATUS NTAPI pnp_notification(PVOID NotificationStructure, PVOID Context) {
-#else
-NTSTATUS pnp_notification(PVOID NotificationStructure, PVOID Context) {
-#endif
+NTSTATUS __stdcall pnp_notification(PVOID NotificationStructure, PVOID Context) {
     DEVICE_INTERFACE_CHANGE_NOTIFICATION* dicn = (DEVICE_INTERFACE_CHANGE_NOTIFICATION*)NotificationStructure;
     PDRIVER_OBJECT DriverObject = (PDRIVER_OBJECT)Context;
 
@@ -749,16 +717,17 @@ NTSTATUS pnp_notification(PVOID NotificationStructure, PVOID Context) {
 static void mountmgr_process_drive(PDEVICE_OBJECT mountmgr, PUNICODE_STRING device_name) {
     NTSTATUS Status;
     LIST_ENTRY* le;
-    BOOL done = FALSE;
+    bool need_remove = false;
+    volume_child* vc2 = NULL;
 
-    ExAcquireResourceSharedLite(&pdo_list_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdo_list_lock, true);
 
     le = pdo_list.Flink;
     while (le != &pdo_list) {
         pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
         LIST_ENTRY* le2;
 
-        ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+        ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
         le2 = pdode->children.Flink;
 
@@ -768,7 +737,7 @@ static void mountmgr_process_drive(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devi
             if (vc->devobj) {
                 MOUNTDEV_NAME mdn;
 
-                Status = dev_ioctl(vc->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), TRUE, NULL);
+                Status = dev_ioctl(vc->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), true, NULL);
                 if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
                     ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
                 else {
@@ -779,18 +748,13 @@ static void mountmgr_process_drive(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devi
                     if (!mdn2)
                         ERR("out of memory\n");
                     else {
-                        Status = dev_ioctl(vc->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, TRUE, NULL);
+                        Status = dev_ioctl(vc->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, true, NULL);
                         if (!NT_SUCCESS(Status))
                             ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
                         else {
                             if (mdn2->NameLength == device_name->Length && RtlCompareMemory(mdn2->Name, device_name->Buffer, device_name->Length) == device_name->Length) {
-                                Status = remove_drive_letter(mountmgr, device_name);
-                                if (!NT_SUCCESS(Status))
-                                    ERR("remove_drive_letter returned %08x\n", Status);
-                                else
-                                    vc->had_drive_letter = TRUE;
-
-                                done = TRUE;
+                                vc2 = vc;
+                                need_remove = true;
                                 break;
                             }
                         }
@@ -805,13 +769,21 @@ static void mountmgr_process_drive(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devi
 
         ExReleaseResourceLite(&pdode->child_lock);
 
-        if (done)
+        if (need_remove)
             break;
 
         le = le->Flink;
     }
 
     ExReleaseResourceLite(&pdo_list_lock);
+
+    if (need_remove) {
+        Status = remove_drive_letter(mountmgr, device_name);
+        if (!NT_SUCCESS(Status))
+            ERR("remove_drive_letter returned %08x\n", Status);
+        else
+            vc2->had_drive_letter = true;
+    }
 }
 
 static void mountmgr_updated(PDEVICE_OBJECT mountmgr, MOUNTMGR_MOUNT_POINTS* mmps) {
@@ -823,7 +795,7 @@ static void mountmgr_updated(PDEVICE_OBJECT mountmgr, MOUNTMGR_MOUNT_POINTS* mmp
         UNICODE_STRING symlink, device_name;
 
         if (mmps->MountPoints[i].SymbolicLinkNameOffset != 0) {
-            symlink.Buffer = (WCHAR*)(((UINT8*)mmps) + mmps->MountPoints[i].SymbolicLinkNameOffset);
+            symlink.Buffer = (WCHAR*)(((uint8_t*)mmps) + mmps->MountPoints[i].SymbolicLinkNameOffset);
             symlink.Length = symlink.MaximumLength = mmps->MountPoints[i].SymbolicLinkNameLength;
         } else {
             symlink.Buffer = NULL;
@@ -831,7 +803,7 @@ static void mountmgr_updated(PDEVICE_OBJECT mountmgr, MOUNTMGR_MOUNT_POINTS* mmp
         }
 
         if (mmps->MountPoints[i].DeviceNameOffset != 0) {
-            device_name.Buffer = (WCHAR*)(((UINT8*)mmps) + mmps->MountPoints[i].DeviceNameOffset);
+            device_name.Buffer = (WCHAR*)(((uint8_t*)mmps) + mmps->MountPoints[i].DeviceNameOffset);
             device_name.Length = device_name.MaximumLength = mmps->MountPoints[i].DeviceNameLength;
         } else {
             device_name.Buffer = NULL;
@@ -845,11 +817,7 @@ static void mountmgr_updated(PDEVICE_OBJECT mountmgr, MOUNTMGR_MOUNT_POINTS* mmp
 }
 
 _Function_class_(KSTART_ROUTINE)
-#ifdef __REACTOS__
-void NTAPI mountmgr_thread(_In_ void* context) {
-#else
-void mountmgr_thread(_In_ void* context) {
-#endif
+void __stdcall mountmgr_thread(_In_ void* context) {
     UNICODE_STRING mmdevpath;
     NTSTATUS Status;
     PFILE_OBJECT FileObject;
@@ -867,7 +835,7 @@ void mountmgr_thread(_In_ void* context) {
 
     mcni.EpicNumber = 0;
 
-    while (TRUE) {
+    while (true) {
         PIRP Irp;
         MOUNTMGR_MOUNT_POINT mmp;
         MOUNTMGR_MOUNT_POINTS mmps;
@@ -876,7 +844,7 @@ void mountmgr_thread(_In_ void* context) {
         KeClearEvent(&mountmgr_thread_event);
 
         Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_CHANGE_NOTIFY, mountmgr, &mcni, sizeof(MOUNTMGR_CHANGE_NOTIFY_INFO),
-                                            &mcni, sizeof(MOUNTMGR_CHANGE_NOTIFY_INFO), FALSE, &mountmgr_thread_event, &iosb);
+                                            &mcni, sizeof(MOUNTMGR_CHANGE_NOTIFY_INFO), false, &mountmgr_thread_event, &iosb);
 
         if (!Irp) {
             ERR("out of memory\n");
@@ -886,7 +854,7 @@ void mountmgr_thread(_In_ void* context) {
         Status = IoCallDriver(mountmgr, Irp);
 
         if (Status == STATUS_PENDING) {
-            KeWaitForSingleObject(&mountmgr_thread_event, Executive, KernelMode, FALSE, NULL);
+            KeWaitForSingleObject(&mountmgr_thread_event, Executive, KernelMode, false, NULL);
             Status = iosb.Status;
         }
 
@@ -903,7 +871,7 @@ void mountmgr_thread(_In_ void* context) {
         RtlZeroMemory(&mmp, sizeof(MOUNTMGR_MOUNT_POINT));
 
         Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_QUERY_POINTS, &mmp, sizeof(MOUNTMGR_MOUNT_POINT), &mmps, sizeof(MOUNTMGR_MOUNT_POINTS),
-                           FALSE, NULL);
+                           false, NULL);
 
         if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
             ERR("IOCTL_MOUNTMGR_QUERY_POINTS 1 returned %08x\n", Status);
@@ -917,7 +885,7 @@ void mountmgr_thread(_In_ void* context) {
             }
 
             Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_QUERY_POINTS, &mmp, sizeof(MOUNTMGR_MOUNT_POINTS), mmps2, mmps.Size,
-                               FALSE, NULL);
+                               false, NULL);
             if (!NT_SUCCESS(Status))
                 ERR("IOCTL_MOUNTMGR_QUERY_POINTS returned %08x\n", Status);
             else
diff --git a/drivers/filesystems/btrfs/security.c b/drivers/filesystems/btrfs/security.c
index e934cb47ee8..42ff987723a 100644
--- a/drivers/filesystems/btrfs/security.c
+++ b/drivers/filesystems/btrfs/security.c
@@ -24,7 +24,7 @@ typedef struct {
     UCHAR revision;
     UCHAR elements;
     UCHAR auth[6];
-    UINT32 nums[8];
+    uint32_t nums[8];
 } sid_header;
 
 static sid_header sid_BA = { 1, 2, SECURITY_NT_AUTHORITY, {32, 544}}; // BUILTIN\Administrators
@@ -53,10 +53,10 @@ static dacl def_dacls[] = {
 extern LIST_ENTRY uid_map_list, gid_map_list;
 extern ERESOURCE mapping_lock;
 
-void add_user_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 uid) {
+void add_user_mapping(WCHAR* sidstring, ULONG sidstringlength, uint32_t uid) {
     unsigned int i, np;
-    UINT8 numdashes;
-    UINT64 val;
+    uint8_t numdashes;
+    uint64_t val;
     ULONG sidsize;
     sid_header* sid;
     uid_map* um;
@@ -106,17 +106,17 @@ void add_user_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 uid) {
         }
 
         i++;
-        TRACE("val = %u, i = %u, ssl = %u\n", (UINT32)val, i, sidstringlength);
+        TRACE("val = %u, i = %u, ssl = %u\n", (uint32_t)val, i, sidstringlength);
 
         if (np == 0) {
-            sid->auth[0] = (UINT8)((val & 0xff0000000000) >> 40);
-            sid->auth[1] = (UINT8)((val & 0xff00000000) >> 32);
-            sid->auth[2] = (UINT8)((val & 0xff000000) >> 24);
-            sid->auth[3] = (UINT8)((val & 0xff0000) >> 16);
-            sid->auth[4] = (UINT8)((val & 0xff00) >> 8);
+            sid->auth[0] = (uint8_t)((val & 0xff0000000000) >> 40);
+            sid->auth[1] = (uint8_t)((val & 0xff00000000) >> 32);
+            sid->auth[2] = (uint8_t)((val & 0xff000000) >> 24);
+            sid->auth[3] = (uint8_t)((val & 0xff0000) >> 16);
+            sid->auth[4] = (uint8_t)((val & 0xff00) >> 8);
             sid->auth[5] = val & 0xff;
         } else {
-            sid->nums[np-1] = (UINT32)val;
+            sid->nums[np-1] = (uint32_t)val;
         }
 
         np++;
@@ -142,10 +142,10 @@ void add_user_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 uid) {
     InsertTailList(&uid_map_list, &um->listentry);
 }
 
-void add_group_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 gid) {
+void add_group_mapping(WCHAR* sidstring, ULONG sidstringlength, uint32_t gid) {
     unsigned int i, np;
-    UINT8 numdashes;
-    UINT64 val;
+    uint8_t numdashes;
+    uint64_t val;
     ULONG sidsize;
     sid_header* sid;
     gid_map* gm;
@@ -191,17 +191,17 @@ void add_group_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 gid) {
         }
 
         i++;
-        TRACE("val = %u, i = %u, ssl = %u\n", (UINT32)val, i, sidstringlength);
+        TRACE("val = %u, i = %u, ssl = %u\n", (uint32_t)val, i, sidstringlength);
 
         if (np == 0) {
-            sid->auth[0] = (UINT8)((val & 0xff0000000000) >> 40);
-            sid->auth[1] = (UINT8)((val & 0xff00000000) >> 32);
-            sid->auth[2] = (UINT8)((val & 0xff000000) >> 24);
-            sid->auth[3] = (UINT8)((val & 0xff0000) >> 16);
-            sid->auth[4] = (UINT8)((val & 0xff00) >> 8);
+            sid->auth[0] = (uint8_t)((val & 0xff0000000000) >> 40);
+            sid->auth[1] = (uint8_t)((val & 0xff00000000) >> 32);
+            sid->auth[2] = (uint8_t)((val & 0xff000000) >> 24);
+            sid->auth[3] = (uint8_t)((val & 0xff0000) >> 16);
+            sid->auth[4] = (uint8_t)((val & 0xff00) >> 8);
             sid->auth[5] = val & 0xff;
         } else
-            sid->nums[np-1] = (UINT32)val;
+            sid->nums[np-1] = (uint32_t)val;
 
         np++;
 
@@ -226,12 +226,12 @@ void add_group_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 gid) {
     InsertTailList(&gid_map_list, &gm->listentry);
 }
 
-NTSTATUS uid_to_sid(UINT32 uid, PSID* sid) {
+NTSTATUS uid_to_sid(uint32_t uid, PSID* sid) {
     LIST_ENTRY* le;
     sid_header* sh;
     UCHAR els;
 
-    ExAcquireResourceSharedLite(&mapping_lock, TRUE);
+    ExAcquireResourceSharedLite(&mapping_lock, true);
 
     le = uid_map_list.Flink;
     while (le != &uid_map_list) {
@@ -261,7 +261,7 @@ NTSTATUS uid_to_sid(UINT32 uid, PSID* sid) {
 
         els = 1;
 
-        sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header) + ((els - 1) * sizeof(UINT32)), ALLOC_TAG);
+        sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header) + ((els - 1) * sizeof(uint32_t)), ALLOC_TAG);
         if (!sh) {
             ERR("out of memory\n");
             *sid = NULL;
@@ -307,11 +307,11 @@ NTSTATUS uid_to_sid(UINT32 uid, PSID* sid) {
     return STATUS_SUCCESS;
 }
 
-UINT32 sid_to_uid(PSID sid) {
+uint32_t sid_to_uid(PSID sid) {
     LIST_ENTRY* le;
     sid_header* sh = sid;
 
-    ExAcquireResourceSharedLite(&mapping_lock, TRUE);
+    ExAcquireResourceSharedLite(&mapping_lock, true);
 
     le = uid_map_list.Flink;
     while (le != &uid_map_list) {
@@ -338,7 +338,7 @@ UINT32 sid_to_uid(PSID sid) {
     return UID_NOBODY;
 }
 
-static void gid_to_sid(UINT32 gid, PSID* sid) {
+static void gid_to_sid(uint32_t gid, PSID* sid) {
     sid_header* sh;
     UCHAR els;
 
@@ -346,7 +346,7 @@ static void gid_to_sid(UINT32 gid, PSID* sid) {
 
     // fallback to S-1-22-2-X, Samba's SID scheme
     els = 2;
-    sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header) + ((els - 1) * sizeof(UINT32)), ALLOC_TAG);
+    sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header) + ((els - 1) * sizeof(uint32_t)), ALLOC_TAG);
     if (!sh) {
         ERR("out of memory\n");
         *sid = NULL;
@@ -370,7 +370,7 @@ static void gid_to_sid(UINT32 gid, PSID* sid) {
 }
 
 static ACL* load_default_acl() {
-    UINT16 size, i;
+    uint16_t size, i;
     ACL* acl;
     ACCESS_ALLOWED_ACE* aaa;
 
@@ -378,7 +378,7 @@ static ACL* load_default_acl() {
     i = 0;
     while (def_dacls[i].sid) {
         size += sizeof(ACCESS_ALLOWED_ACE);
-        size += 8 + (def_dacls[i].sid->elements * sizeof(UINT32)) - sizeof(ULONG);
+        size += 8 + (def_dacls[i].sid->elements * sizeof(uint32_t)) - sizeof(ULONG);
         i++;
     }
 
@@ -399,12 +399,12 @@ static ACL* load_default_acl() {
     while (def_dacls[i].sid) {
         aaa->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
         aaa->Header.AceFlags = def_dacls[i].flags;
-        aaa->Header.AceSize = sizeof(ACCESS_ALLOWED_ACE) - sizeof(ULONG) + 8 + (def_dacls[i].sid->elements * sizeof(UINT32));
+        aaa->Header.AceSize = sizeof(ACCESS_ALLOWED_ACE) - sizeof(ULONG) + 8 + (def_dacls[i].sid->elements * sizeof(uint32_t));
         aaa->Mask = def_dacls[i].mask;
 
-        RtlCopyMemory(&aaa->SidStart, def_dacls[i].sid, 8 + (def_dacls[i].sid->elements * sizeof(UINT32)));
+        RtlCopyMemory(&aaa->SidStart, def_dacls[i].sid, 8 + (def_dacls[i].sid->elements * sizeof(uint32_t)));
 
-        aaa = (ACCESS_ALLOWED_ACE*)((UINT8*)aaa + aaa->Header.AceSize);
+        aaa = (ACCESS_ALLOWED_ACE*)((uint8_t*)aaa + aaa->Header.AceSize);
 
         i++;
     }
@@ -432,7 +432,7 @@ static void get_top_level_sd(fcb* fcb) {
         goto end;
     }
 
-    RtlSetOwnerSecurityDescriptor(&sd, usersid, FALSE);
+    RtlSetOwnerSecurityDescriptor(&sd, usersid, false);
 
     if (!NT_SUCCESS(Status)) {
         ERR("RtlSetOwnerSecurityDescriptor returned %08x\n", Status);
@@ -446,7 +446,7 @@ static void get_top_level_sd(fcb* fcb) {
         goto end;
     }
 
-    RtlSetGroupSecurityDescriptor(&sd, groupsid, FALSE);
+    RtlSetGroupSecurityDescriptor(&sd, groupsid, false);
 
     if (!NT_SUCCESS(Status)) {
         ERR("RtlSetGroupSecurityDescriptor returned %08x\n", Status);
@@ -460,7 +460,7 @@ static void get_top_level_sd(fcb* fcb) {
         goto end;
     }
 
-    Status = RtlSetDaclSecurityDescriptor(&sd, TRUE, acl, FALSE);
+    Status = RtlSetDaclSecurityDescriptor(&sd, true, acl, false);
 
     if (!NT_SUCCESS(Status)) {
         ERR("RtlSetDaclSecurityDescriptor returned %08x\n", Status);
@@ -508,13 +508,13 @@ end:
         ExFreePool(groupsid);
 }
 
-void fcb_get_sd(fcb* fcb, struct _fcb* parent, BOOL look_for_xattr, PIRP Irp) {
+void fcb_get_sd(fcb* fcb, struct _fcb* parent, bool look_for_xattr, PIRP Irp) {
     NTSTATUS Status;
     PSID usersid = NULL, groupsid = NULL;
     SECURITY_SUBJECT_CONTEXT subjcont;
     ULONG buflen;
 
-    if (look_for_xattr && get_xattr(fcb->Vcb, fcb->subvol, fcb->inode, EA_NTACL, EA_NTACL_HASH, (UINT8**)&fcb->sd, (UINT16*)&buflen, Irp))
+    if (look_for_xattr && get_xattr(fcb->Vcb, fcb->subvol, fcb->inode, EA_NTACL, EA_NTACL_HASH, (uint8_t**)&fcb->sd, (uint16_t*)&buflen, Irp))
         return;
 
     if (!parent) {
@@ -536,7 +536,7 @@ void fcb_get_sd(fcb* fcb, struct _fcb* parent, BOOL look_for_xattr, PIRP Irp) {
         return;
     }
 
-    RtlSetOwnerSecurityDescriptor(&fcb->sd, usersid, FALSE);
+    RtlSetOwnerSecurityDescriptor(&fcb->sd, usersid, false);
 
     gid_to_sid(fcb->inode_item.st_gid, &groupsid);
     if (!groupsid) {
@@ -544,7 +544,7 @@ void fcb_get_sd(fcb* fcb, struct _fcb* parent, BOOL look_for_xattr, PIRP Irp) {
         return;
     }
 
-    RtlSetGroupSecurityDescriptor(&fcb->sd, groupsid, FALSE);
+    RtlSetGroupSecurityDescriptor(&fcb->sd, groupsid, false);
 
     ExFreePool(usersid);
     ExFreePool(groupsid);
@@ -578,13 +578,13 @@ static NTSTATUS get_file_security(PFILE_OBJECT FileObject, SECURITY_DESCRIPTOR*
 
 _Dispatch_type_(IRP_MJ_QUERY_SECURITY)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_query_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
+NTSTATUS __stdcall drv_query_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     NTSTATUS Status;
     SECURITY_DESCRIPTOR* sd;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     device_extension* Vcb = DeviceObject->DeviceExtension;
     ULONG buflen;
-    BOOL top_level;
+    bool top_level;
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     ccb* ccb = FileObject ? FileObject->FsContext2 : NULL;
 
@@ -696,7 +696,7 @@ static NTSTATUS set_file_security(device_extension* Vcb, PFILE_OBJECT FileObject
     if (!fcb || !ccb)
         return STATUS_INVALID_PARAMETER;
 
-    ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
+    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
     if (is_subvol_readonly(fcb->subvol, Irp)) {
         Status = STATUS_ACCESS_DENIED;
@@ -724,9 +724,9 @@ static NTSTATUS set_file_security(device_extension* Vcb, PFILE_OBJECT FileObject
 
     fcb->inode_item.sequence++;
 
-    fcb->sd_dirty = TRUE;
-    fcb->sd_deleted = FALSE;
-    fcb->inode_item_changed = TRUE;
+    fcb->sd_dirty = true;
+    fcb->sd_deleted = false;
+    fcb->inode_item_changed = true;
 
     fcb->subvol->root_item.ctransid = Vcb->superblock.generation;
     fcb->subvol->root_item.ctime = now;
@@ -743,14 +743,14 @@ end:
 
 _Dispatch_type_(IRP_MJ_SET_SECURITY)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
+NTSTATUS __stdcall drv_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     ccb* ccb = FileObject ? FileObject->FsContext2 : NULL;
     device_extension* Vcb = DeviceObject->DeviceExtension;
     ULONG access_req = 0;
-    BOOL top_level;
+    bool top_level;
 
     FsRtlEnterFileSystem();
 
@@ -820,7 +820,7 @@ end:
     return Status;
 }
 
-static BOOL search_for_gid(fcb* fcb, PSID sid) {
+static bool search_for_gid(fcb* fcb, PSID sid) {
     LIST_ENTRY* le;
 
     le = gid_map_list.Flink;
@@ -829,13 +829,13 @@ static BOOL search_for_gid(fcb* fcb, PSID sid) {
 
         if (RtlEqualSid(sid, gm->sid)) {
             fcb->inode_item.st_gid = gm->gid;
-            return TRUE;
+            return true;
         }
 
         le = le->Flink;
     }
 
-    return FALSE;
+    return false;
 }
 
 void find_gid(struct _fcb* fcb, struct _fcb* parfcb, PSECURITY_SUBJECT_CONTEXT subjcont) {
@@ -849,7 +849,7 @@ void find_gid(struct _fcb* fcb, struct _fcb* parfcb, PSECURITY_SUBJECT_CONTEXT s
         return;
     }
 
-    ExAcquireResourceSharedLite(&mapping_lock, TRUE);
+    ExAcquireResourceSharedLite(&mapping_lock, true);
 
     if (!subjcont || !subjcont->PrimaryToken || IsListEmpty(&gid_map_list)) {
         ExReleaseResourceLite(&mapping_lock);
diff --git a/drivers/filesystems/btrfs/send.c b/drivers/filesystems/btrfs/send.c
index 260612a1552..4737be0a85a 100644
--- a/drivers/filesystems/btrfs/send.c
+++ b/drivers/filesystems/btrfs/send.c
@@ -19,21 +19,21 @@
 
 typedef struct send_dir {
     LIST_ENTRY list_entry;
-    UINT64 inode;
-    BOOL dummy;
+    uint64_t inode;
+    bool dummy;
     BTRFS_TIME atime;
     BTRFS_TIME mtime;
     BTRFS_TIME ctime;
     struct send_dir* parent;
-    UINT16 namelen;
+    uint16_t namelen;
     char* name;
     LIST_ENTRY deleted_children;
 } send_dir;
 
 typedef struct {
     LIST_ENTRY list_entry;
-    UINT64 inode;
-    BOOL dir;
+    uint64_t inode;
+    bool dir;
     send_dir* sd;
     char tmpname[64];
 } orphan;
@@ -47,18 +47,18 @@ typedef struct {
 typedef struct {
     LIST_ENTRY list_entry;
     send_dir* sd;
-    UINT16 namelen;
+    uint16_t namelen;
     char name[1];
 } ref;
 
 typedef struct {
     send_dir* sd;
-    UINT64 last_child_inode;
+    uint64_t last_child_inode;
     LIST_ENTRY list_entry;
 } pending_rmdir;
 
 typedef struct {
-    UINT64 offset;
+    uint64_t offset;
     LIST_ENTRY list_entry;
     ULONG datalen;
     EXTENT_DATA data;
@@ -68,7 +68,7 @@ typedef struct {
     device_extension* Vcb;
     root* root;
     root* parent;
-    UINT8* data;
+    uint8_t* data;
     ULONG datalen;
     ULONG num_clones;
     root** clones;
@@ -80,22 +80,22 @@ typedef struct {
     send_info* send;
 
     struct {
-        UINT64 inode;
-        BOOL deleting;
-        BOOL new;
-        UINT64 gen;
-        UINT64 uid;
-        UINT64 olduid;
-        UINT64 gid;
-        UINT64 oldgid;
-        UINT64 mode;
-        UINT64 oldmode;
-        UINT64 size;
-        UINT64 flags;
+        uint64_t inode;
+        bool deleting;
+        bool new;
+        uint64_t gen;
+        uint64_t uid;
+        uint64_t olduid;
+        uint64_t gid;
+        uint64_t oldgid;
+        uint64_t mode;
+        uint64_t oldmode;
+        uint64_t size;
+        uint64_t flags;
         BTRFS_TIME atime;
         BTRFS_TIME mtime;
         BTRFS_TIME ctime;
-        BOOL file;
+        bool file;
         char* path;
         orphan* o;
         send_dir* sd;
@@ -109,10 +109,10 @@ typedef struct {
 #define MAX_SEND_WRITE 0xc000 // 48 KB
 #define SEND_BUFFER_LENGTH 0x100000 // 1 MB
 
-static NTSTATUS find_send_dir(send_context* context, UINT64 dir, UINT64 generation, send_dir** psd, BOOL* added_dummy);
+static NTSTATUS find_send_dir(send_context* context, uint64_t dir, uint64_t generation, send_dir** psd, bool* added_dummy);
 static NTSTATUS wait_for_flush(send_context* context, traverse_ptr* tp1, traverse_ptr* tp2);
 
-static void send_command(send_context* context, UINT16 cmd) {
+static void send_command(send_context* context, uint16_t cmd) {
     btrfs_send_command* bsc = (btrfs_send_command*)&context->data[context->datalen];
 
     bsc->cmd = cmd;
@@ -125,10 +125,10 @@ static void send_command_finish(send_context* context, ULONG pos) {
     btrfs_send_command* bsc = (btrfs_send_command*)&context->data[pos];
 
     bsc->length = context->datalen - pos - sizeof(btrfs_send_command);
-    bsc->csum = calc_crc32c(0, (UINT8*)bsc, context->datalen - pos);
+    bsc->csum = calc_crc32c(0, (uint8_t*)bsc, context->datalen - pos);
 }
 
-static void send_add_tlv(send_context* context, UINT16 type, void* data, UINT16 length) {
+static void send_add_tlv(send_context* context, uint16_t type, void* data, uint16_t length) {
     btrfs_send_tlv* tlv = (btrfs_send_tlv*)&context->data[context->datalen];
 
     tlv->type = type;
@@ -140,7 +140,7 @@ static void send_add_tlv(send_context* context, UINT16 type, void* data, UINT16
     context->datalen += sizeof(btrfs_send_tlv) + length;
 }
 
-static char* uint64_to_char(UINT64 num, char* buf) {
+static char* uint64_to_char(uint64_t num, char* buf) {
     char *tmp, tmp2[20];
 
     if (num == 0) {
@@ -160,9 +160,9 @@ static char* uint64_to_char(UINT64 num, char* buf) {
     return &buf[tmp2 + sizeof(tmp2) - tmp];
 }
 
-static NTSTATUS get_orphan_name(send_context* context, UINT64 inode, UINT64 generation, char* name) {
+static NTSTATUS get_orphan_name(send_context* context, uint64_t inode, uint64_t generation, char* name) {
     char *ptr, *ptr2;
-    UINT64 index = 0;
+    uint64_t index = 0;
     KEY searchkey;
 
     name[0] = 'o';
@@ -183,9 +183,9 @@ static NTSTATUS get_orphan_name(send_context* context, UINT64 inode, UINT64 gene
         ptr = uint64_to_char(index, ptr);
         *ptr = 0;
 
-        searchkey.offset = calc_crc32c(0xfffffffe, (UINT8*)name, (ULONG)(ptr - name));
+        searchkey.offset = calc_crc32c(0xfffffffe, (uint8_t*)name, (ULONG)(ptr - name));
 
-        Status = find_item(context->Vcb, context->root, &tp, &searchkey, FALSE, NULL);
+        Status = find_item(context->Vcb, context->root, &tp, &searchkey, false, NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
             return Status;
@@ -195,7 +195,7 @@ static NTSTATUS get_orphan_name(send_context* context, UINT64 inode, UINT64 gene
             goto cont;
 
         if (context->parent) {
-            Status = find_item(context->Vcb, context->parent, &tp, &searchkey, FALSE, NULL);
+            Status = find_item(context->Vcb, context->parent, &tp, &searchkey, false, NULL);
             if (!NT_SUCCESS(Status)) {
                 ERR("find_item returned %08x\n", Status);
                 return Status;
@@ -210,7 +210,7 @@ static NTSTATUS get_orphan_name(send_context* context, UINT64 inode, UINT64 gene
 cont:
         index++;
         ptr = ptr2;
-    } while (TRUE);
+    } while (true);
 }
 
 static void add_orphan(send_context* context, orphan* o) {
@@ -231,7 +231,7 @@ static void add_orphan(send_context* context, orphan* o) {
     InsertTailList(&context->orphans, &o->list_entry);
 }
 
-static NTSTATUS send_read_symlink(send_context* context, UINT64 inode, char** link, UINT16* linklen) {
+static NTSTATUS send_read_symlink(send_context* context, uint64_t inode, char** link, uint16_t* linklen) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
@@ -241,19 +241,19 @@ static NTSTATUS send_read_symlink(send_context* context, UINT64 inode, char** li
     searchkey.obj_type = TYPE_EXTENT_DATA;
     searchkey.offset = 0;
 
-    Status = find_item(context->Vcb, context->root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(context->Vcb, context->root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
     }
 
     if (keycmp(tp.item->key, searchkey)) {
-        ERR("could not find (%llx,%x,%llx)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+        ERR("could not find (%I64x,%x,%I64x)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
         return STATUS_INTERNAL_ERROR;
     }
 
     if (tp.item->size < sizeof(EXTENT_DATA)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
             tp.item->size, sizeof(EXTENT_DATA));
         return STATUS_INTERNAL_ERROR;
     }
@@ -268,13 +268,13 @@ static NTSTATUS send_read_symlink(send_context* context, UINT64 inode, char** li
     }
 
     if (tp.item->size < offsetof(EXTENT_DATA, data[0]) + ed->decoded_size) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
             tp.item->size, offsetof(EXTENT_DATA, data[0]) + ed->decoded_size);
         return STATUS_INTERNAL_ERROR;
     }
 
     *link = (char*)ed->data;
-    *linklen = (UINT16)ed->decoded_size;
+    *linklen = (uint16_t)ed->decoded_size;
 
     return STATUS_SUCCESS;
 }
@@ -287,13 +287,13 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
         INODE_ITEM* ii2 = (INODE_ITEM*)tp2->item->data;
 
         if (tp2->item->size < sizeof(INODE_ITEM)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
                 tp2->item->size, sizeof(INODE_ITEM));
             return STATUS_INTERNAL_ERROR;
         }
 
         context->lastinode.inode = tp2->item->key.obj_id;
-        context->lastinode.deleting = TRUE;
+        context->lastinode.deleting = true;
         context->lastinode.gen = ii2->generation;
         context->lastinode.mode = ii2->st_mode;
         context->lastinode.flags = ii2->flags;
@@ -306,13 +306,13 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
     ii = (INODE_ITEM*)tp->item->data;
 
     if (tp->item->size < sizeof(INODE_ITEM)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
             tp->item->size, sizeof(INODE_ITEM));
         return STATUS_INTERNAL_ERROR;
     }
 
     context->lastinode.inode = tp->item->key.obj_id;
-    context->lastinode.deleting = FALSE;
+    context->lastinode.deleting = false;
     context->lastinode.gen = ii->generation;
     context->lastinode.uid = ii->st_uid;
     context->lastinode.gid = ii->st_gid;
@@ -322,7 +322,7 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
     context->lastinode.mtime = ii->st_mtime;
     context->lastinode.ctime = ii->st_ctime;
     context->lastinode.flags = ii->flags;
-    context->lastinode.file = FALSE;
+    context->lastinode.file = false;
     context->lastinode.o = NULL;
     context->lastinode.sd = NULL;
 
@@ -336,7 +336,7 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
         LIST_ENTRY* le;
 
         if (tp2->item->size < sizeof(INODE_ITEM)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
                 tp2->item->size, sizeof(INODE_ITEM));
             return STATUS_INTERNAL_ERROR;
         }
@@ -346,9 +346,9 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
         context->lastinode.oldgid = ii2->st_gid;
 
         if ((ii2->st_mode & __S_IFREG) == __S_IFREG && (ii2->st_mode & __S_IFLNK) != __S_IFLNK && (ii2->st_mode & __S_IFSOCK) != __S_IFSOCK)
-            context->lastinode.file = TRUE;
+            context->lastinode.file = true;
 
-        context->lastinode.new = FALSE;
+        context->lastinode.new = false;
 
         le = context->orphans.Flink;
         while (le != &context->orphans) {
@@ -363,7 +363,7 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
             le = le->Flink;
         }
     } else
-        context->lastinode.new = TRUE;
+        context->lastinode.new = true;
 
     if (tp->item->key.obj_id == SUBVOL_ROOT_INODE) {
         send_dir* sd;
@@ -380,7 +380,7 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
         context->root_dir = sd;
     } else if (!tp2) {
         ULONG pos = context->datalen;
-        UINT16 cmd;
+        uint16_t cmd;
         send_dir* sd;
 
         char name[64];
@@ -399,7 +399,7 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
                     o2->sd->atime = ii->st_atime;
                     o2->sd->mtime = ii->st_mtime;
                     o2->sd->ctime = ii->st_ctime;
-                    o2->sd->dummy = FALSE;
+                    o2->sd->dummy = false;
                     return STATUS_SUCCESS;
                 } else if (o2->inode > tp->item->key.obj_id)
                     break;
@@ -420,7 +420,7 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
             cmd = BTRFS_SEND_CMD_MKFIFO;
         else {
             cmd = BTRFS_SEND_CMD_MKFILE;
-            context->lastinode.file = TRUE;
+            context->lastinode.file = true;
         }
 
         send_command(context, cmd);
@@ -431,17 +431,17 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
             return Status;
         }
 
-        send_add_tlv(context, BTRFS_SEND_TLV_PATH, name, (UINT16)strlen(name));
-        send_add_tlv(context, BTRFS_SEND_TLV_INODE, &tp->item->key.obj_id, sizeof(UINT64));
+        send_add_tlv(context, BTRFS_SEND_TLV_PATH, name, (uint16_t)strlen(name));
+        send_add_tlv(context, BTRFS_SEND_TLV_INODE, &tp->item->key.obj_id, sizeof(uint64_t));
 
         if (cmd == BTRFS_SEND_CMD_MKNOD || cmd == BTRFS_SEND_CMD_MKFIFO || cmd == BTRFS_SEND_CMD_MKSOCK) {
-            UINT64 rdev = makedev((ii->st_rdev & 0xFFFFFFFFFFF) >> 20, ii->st_rdev & 0xFFFFF), mode = ii->st_mode;
+            uint64_t rdev = makedev((ii->st_rdev & 0xFFFFFFFFFFF) >> 20, ii->st_rdev & 0xFFFFF), mode = ii->st_mode;
 
-            send_add_tlv(context, BTRFS_SEND_TLV_RDEV, &rdev, sizeof(UINT64));
-            send_add_tlv(context, BTRFS_SEND_TLV_MODE, &mode, sizeof(UINT64));
+            send_add_tlv(context, BTRFS_SEND_TLV_RDEV, &rdev, sizeof(uint64_t));
+            send_add_tlv(context, BTRFS_SEND_TLV_MODE, &mode, sizeof(uint64_t));
         } else if (cmd == BTRFS_SEND_CMD_SYMLINK && ii->st_size > 0) {
             char* link;
-            UINT16 linklen;
+            uint16_t linklen;
 
             Status = send_read_symlink(context, tp->item->key.obj_id, &link, &linklen);
             if (!NT_SUCCESS(Status)) {
@@ -461,7 +461,7 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
                 return Status;
             }
 
-            sd->dummy = FALSE;
+            sd->dummy = false;
         } else
             sd = NULL;
 
@@ -474,7 +474,7 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
         }
 
         o->inode = tp->item->key.obj_id;
-        o->dir = (ii->st_mode & __S_IFDIR && ii->st_size > 0) ? TRUE : FALSE;
+        o->dir = (ii->st_mode & __S_IFDIR && ii->st_size > 0) ? true : false;
         strcpy(o->tmpname, name);
         o->sd = sd;
         add_orphan(context, o);
@@ -493,7 +493,7 @@ static NTSTATUS send_inode(send_context* context, traverse_ptr* tp, traverse_ptr
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS send_add_dir(send_context* context, UINT64 inode, send_dir* parent, char* name, UINT16 namelen, BOOL dummy, LIST_ENTRY* lastentry, send_dir** psd) {
+static NTSTATUS send_add_dir(send_context* context, uint64_t inode, send_dir* parent, char* name, uint16_t namelen, bool dummy, LIST_ENTRY* lastentry, send_dir** psd) {
     LIST_ENTRY* le;
     send_dir* sd = ExAllocatePoolWithTag(PagedPool, sizeof(send_dir), ALLOC_TAG);
 
@@ -556,8 +556,8 @@ static NTSTATUS send_add_dir(send_context* context, UINT64 inode, send_dir* pare
     return STATUS_SUCCESS;
 }
 
-static __inline UINT16 find_path_len(send_dir* parent, UINT16 namelen) {
-    UINT16 len = namelen;
+static __inline uint16_t find_path_len(send_dir* parent, uint16_t namelen) {
+    uint16_t len = namelen;
 
     while (parent && parent->namelen > 0) {
         len += parent->namelen + 1;
@@ -582,8 +582,8 @@ static void find_path(char* path, send_dir* parent, char* name, ULONG namelen) {
     }
 }
 
-static void send_add_tlv_path(send_context* context, UINT16 type, send_dir* parent, char* name, UINT16 namelen) {
-    UINT16 len = find_path_len(parent, namelen);
+static void send_add_tlv_path(send_context* context, uint16_t type, send_dir* parent, char* name, uint16_t namelen) {
+    uint16_t len = find_path_len(parent, namelen);
 
     send_add_tlv(context, type, NULL, len);
 
@@ -591,13 +591,13 @@ static void send_add_tlv_path(send_context* context, UINT16 type, send_dir* pare
         find_path((char*)&context->data[context->datalen - len], parent, name, namelen);
 }
 
-static NTSTATUS found_path(send_context* context, send_dir* parent, char* name, UINT16 namelen) {
+static NTSTATUS found_path(send_context* context, send_dir* parent, char* name, uint16_t namelen) {
     ULONG pos = context->datalen;
 
     if (context->lastinode.o) {
         send_command(context, BTRFS_SEND_CMD_RENAME);
 
-        send_add_tlv_path(context, BTRFS_SEND_TLV_PATH, context->root_dir, context->lastinode.o->tmpname, (UINT16)strlen(context->lastinode.o->tmpname));
+        send_add_tlv_path(context, BTRFS_SEND_TLV_PATH, context->root_dir, context->lastinode.o->tmpname, (uint16_t)strlen(context->lastinode.o->tmpname));
 
         send_add_tlv_path(context, BTRFS_SEND_TLV_PATH_TO, parent, name, namelen);
 
@@ -607,13 +607,13 @@ static NTSTATUS found_path(send_context* context, send_dir* parent, char* name,
 
         send_add_tlv_path(context, BTRFS_SEND_TLV_PATH, parent, name, namelen);
 
-        send_add_tlv(context, BTRFS_SEND_TLV_PATH_LINK, context->lastinode.path, context->lastinode.path ? (UINT16)strlen(context->lastinode.path) : 0);
+        send_add_tlv(context, BTRFS_SEND_TLV_PATH_LINK, context->lastinode.path, context->lastinode.path ? (uint16_t)strlen(context->lastinode.path) : 0);
 
         send_command_finish(context, pos);
     }
 
     if (context->lastinode.o) {
-        UINT16 pathlen;
+        uint16_t pathlen;
 
         if (context->lastinode.o->sd) {
             if (context->lastinode.o->sd->name)
@@ -666,7 +666,7 @@ static void send_utimes_command_dir(send_context* context, send_dir* sd, BTRFS_T
     send_command_finish(context, pos);
 }
 
-static NTSTATUS find_send_dir(send_context* context, UINT64 dir, UINT64 generation, send_dir** psd, BOOL* added_dummy) {
+static NTSTATUS find_send_dir(send_context* context, uint64_t dir, uint64_t generation, send_dir** psd, bool* added_dummy) {
     NTSTATUS Status;
     LIST_ENTRY* le;
     char name[64];
@@ -681,7 +681,7 @@ static NTSTATUS find_send_dir(send_context* context, UINT64 dir, UINT64 generati
             *psd = sd2;
 
             if (added_dummy)
-                *added_dummy = FALSE;
+                *added_dummy = false;
 
             return STATUS_SUCCESS;
         }
@@ -690,14 +690,14 @@ static NTSTATUS find_send_dir(send_context* context, UINT64 dir, UINT64 generati
     }
 
     if (dir == SUBVOL_ROOT_INODE) {
-        Status = send_add_dir(context, dir, NULL, NULL, 0, FALSE, le, psd);
+        Status = send_add_dir(context, dir, NULL, NULL, 0, false, le, psd);
         if (!NT_SUCCESS(Status)) {
             ERR("send_add_dir returned %08x\n", Status);
             return Status;
         }
 
         if (added_dummy)
-            *added_dummy = FALSE;
+            *added_dummy = false;
 
         return STATUS_SUCCESS;
     }
@@ -710,7 +710,7 @@ static NTSTATUS find_send_dir(send_context* context, UINT64 dir, UINT64 generati
         searchkey.obj_type = TYPE_INODE_REF; // directories should never have an extiref
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(context->Vcb, context->parent, &tp, &searchkey, FALSE, NULL);
+        Status = find_item(context->Vcb, context->parent, &tp, &searchkey, false, NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
             return Status;
@@ -721,7 +721,7 @@ static NTSTATUS find_send_dir(send_context* context, UINT64 dir, UINT64 generati
             send_dir* parent;
 
             if (tp.item->size < sizeof(INODE_REF) || tp.item->size < offsetof(INODE_REF, name[0]) + ir->n) {
-                ERR("(%llx,%x,%llx) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                ERR("(%I64x,%x,%I64x) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
                 return STATUS_INTERNAL_ERROR;
             }
 
@@ -735,14 +735,14 @@ static NTSTATUS find_send_dir(send_context* context, UINT64 dir, UINT64 generati
                 }
             }
 
-            Status = send_add_dir(context, dir, parent, ir->name, ir->n, TRUE, NULL, psd);
+            Status = send_add_dir(context, dir, parent, ir->name, ir->n, true, NULL, psd);
             if (!NT_SUCCESS(Status)) {
                 ERR("send_add_dir returned %08x\n", Status);
                 return Status;
             }
 
             if (added_dummy)
-                *added_dummy = FALSE;
+                *added_dummy = false;
 
             return STATUS_SUCCESS;
         }
@@ -754,24 +754,24 @@ static NTSTATUS find_send_dir(send_context* context, UINT64 dir, UINT64 generati
         return Status;
     }
 
-    Status = send_add_dir(context, dir, NULL, name, (UINT16)strlen(name), TRUE, le, psd);
+    Status = send_add_dir(context, dir, NULL, name, (uint16_t)strlen(name), true, le, psd);
     if (!NT_SUCCESS(Status)) {
         ERR("send_add_dir returned %08x\n", Status);
         return Status;
     }
 
     if (added_dummy)
-        *added_dummy = TRUE;
+        *added_dummy = true;
 
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS send_inode_ref(send_context* context, traverse_ptr* tp, BOOL tree2) {
+static NTSTATUS send_inode_ref(send_context* context, traverse_ptr* tp, bool tree2) {
     NTSTATUS Status;
-    UINT64 inode = tp ? tp->item->key.obj_id : 0, dir = tp ? tp->item->key.offset : 0;
+    uint64_t inode = tp ? tp->item->key.obj_id : 0, dir = tp ? tp->item->key.offset : 0;
     LIST_ENTRY* le;
     INODE_REF* ir;
-    UINT16 len;
+    uint16_t len;
     send_dir* sd = NULL;
     orphan* o2 = NULL;
 
@@ -779,13 +779,13 @@ static NTSTATUS send_inode_ref(send_context* context, traverse_ptr* tp, BOOL tre
         return STATUS_SUCCESS;
 
     if (tp->item->size < sizeof(INODE_REF)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
             tp->item->size, sizeof(INODE_REF));
         return STATUS_INTERNAL_ERROR;
     }
 
     if (dir != SUBVOL_ROOT_INODE) {
-        BOOL added_dummy;
+        bool added_dummy;
 
         Status = find_send_dir(context, dir, context->root->root_item.ctransid, &sd, &added_dummy);
         if (!NT_SUCCESS(Status)) {
@@ -795,14 +795,14 @@ static NTSTATUS send_inode_ref(send_context* context, traverse_ptr* tp, BOOL tre
 
         // directory has higher inode number than file, so might need to be created
         if (added_dummy) {
-            BOOL found = FALSE;
+            bool found = false;
 
             le = context->orphans.Flink;
             while (le != &context->orphans) {
                 o2 = CONTAINING_RECORD(le, orphan, list_entry);
 
                 if (o2->inode == dir) {
-                    found = TRUE;
+                    found = true;
                     break;
                 } else if (o2->inode > dir)
                     break;
@@ -817,7 +817,7 @@ static NTSTATUS send_inode_ref(send_context* context, traverse_ptr* tp, BOOL tre
 
                 send_add_tlv_path(context, BTRFS_SEND_TLV_PATH, NULL, sd->name, sd->namelen);
 
-                send_add_tlv(context, BTRFS_SEND_TLV_INODE, &dir, sizeof(UINT64));
+                send_add_tlv(context, BTRFS_SEND_TLV_INODE, &dir, sizeof(uint64_t));
 
                 send_command_finish(context, pos);
 
@@ -828,7 +828,7 @@ static NTSTATUS send_inode_ref(send_context* context, traverse_ptr* tp, BOOL tre
                 }
 
                 o2->inode = dir;
-                o2->dir = TRUE;
+                o2->dir = true;
                 memcpy(o2->tmpname, sd->name, sd->namelen);
                 o2->tmpname[sd->namelen] = 0;
                 o2->sd = sd;
@@ -845,7 +845,7 @@ static NTSTATUS send_inode_ref(send_context* context, traverse_ptr* tp, BOOL tre
         ref* r;
 
         if (len < sizeof(INODE_REF) || len < offsetof(INODE_REF, name[0]) + ir->n) {
-            ERR("(%llx,%x,%llx) was truncated\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset);
+            ERR("(%I64x,%x,%I64x) was truncated\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset);
             return STATUS_INTERNAL_ERROR;
         }
 
@@ -861,19 +861,19 @@ static NTSTATUS send_inode_ref(send_context* context, traverse_ptr* tp, BOOL tre
 
         InsertTailList(tree2 ? &context->lastinode.oldrefs : &context->lastinode.refs, &r->list_entry);
 
-        len -= (UINT16)offsetof(INODE_REF, name[0]) + ir->n;
+        len -= (uint16_t)offsetof(INODE_REF, name[0]) + ir->n;
         ir = (INODE_REF*)&ir->name[ir->n];
     }
 
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS send_inode_extref(send_context* context, traverse_ptr* tp, BOOL tree2) {
+static NTSTATUS send_inode_extref(send_context* context, traverse_ptr* tp, bool tree2) {
     INODE_EXTREF* ier;
-    UINT16 len;
+    uint16_t len;
 
     if (tp->item->size < sizeof(INODE_EXTREF)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
             tp->item->size, sizeof(INODE_EXTREF));
         return STATUS_INTERNAL_ERROR;
     }
@@ -888,13 +888,13 @@ static NTSTATUS send_inode_extref(send_context* context, traverse_ptr* tp, BOOL
         ref* r;
 
         if (len < sizeof(INODE_EXTREF) || len < offsetof(INODE_EXTREF, name[0]) + ier->n) {
-            ERR("(%llx,%x,%llx) was truncated\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset);
+            ERR("(%I64x,%x,%I64x) was truncated\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (ier->dir != SUBVOL_ROOT_INODE) {
             LIST_ENTRY* le;
-            BOOL added_dummy;
+            bool added_dummy;
 
             Status = find_send_dir(context, ier->dir, context->root->root_item.ctransid, &sd, &added_dummy);
             if (!NT_SUCCESS(Status)) {
@@ -904,14 +904,14 @@ static NTSTATUS send_inode_extref(send_context* context, traverse_ptr* tp, BOOL
 
             // directory has higher inode number than file, so might need to be created
             if (added_dummy) {
-                BOOL found = FALSE;
+                bool found = false;
 
                 le = context->orphans.Flink;
                 while (le != &context->orphans) {
                     o2 = CONTAINING_RECORD(le, orphan, list_entry);
 
                     if (o2->inode == ier->dir) {
-                        found = TRUE;
+                        found = true;
                         break;
                     } else if (o2->inode > ier->dir)
                         break;
@@ -925,7 +925,7 @@ static NTSTATUS send_inode_extref(send_context* context, traverse_ptr* tp, BOOL
                     send_command(context, BTRFS_SEND_CMD_MKDIR);
 
                     send_add_tlv_path(context, BTRFS_SEND_TLV_PATH, NULL, sd->name, sd->namelen);
-                    send_add_tlv(context, BTRFS_SEND_TLV_INODE, &ier->dir, sizeof(UINT64));
+                    send_add_tlv(context, BTRFS_SEND_TLV_INODE, &ier->dir, sizeof(uint64_t));
 
                     send_command_finish(context, pos);
 
@@ -936,7 +936,7 @@ static NTSTATUS send_inode_extref(send_context* context, traverse_ptr* tp, BOOL
                     }
 
                     o2->inode = ier->dir;
-                    o2->dir = TRUE;
+                    o2->dir = true;
                     memcpy(o2->tmpname, sd->name, sd->namelen);
                     o2->tmpname[sd->namelen] = 0;
                     o2->sd = sd;
@@ -958,7 +958,7 @@ static NTSTATUS send_inode_extref(send_context* context, traverse_ptr* tp, BOOL
 
         InsertTailList(tree2 ? &context->lastinode.oldrefs : &context->lastinode.refs, &r->list_entry);
 
-        len -= (UINT16)offsetof(INODE_EXTREF, name[0]) + ier->n;
+        len -= (uint16_t)offsetof(INODE_EXTREF, name[0]) + ier->n;
         ier = (INODE_EXTREF*)&ier->name[ier->n];
     }
 
@@ -973,38 +973,38 @@ static void send_subvol_header(send_context* context, root* r, file_ref* fr) {
     send_add_tlv(context, BTRFS_SEND_TLV_PATH, fr->dc->utf8.Buffer, fr->dc->utf8.Length);
 
     send_add_tlv(context, BTRFS_SEND_TLV_UUID, r->root_item.rtransid == 0 ? &r->root_item.uuid : &r->root_item.received_uuid, sizeof(BTRFS_UUID));
-    send_add_tlv(context, BTRFS_SEND_TLV_TRANSID, &r->root_item.ctransid, sizeof(UINT64));
+    send_add_tlv(context, BTRFS_SEND_TLV_TRANSID, &r->root_item.ctransid, sizeof(uint64_t));
 
     if (context->parent) {
         send_add_tlv(context, BTRFS_SEND_TLV_CLONE_UUID,
                      context->parent->root_item.rtransid == 0 ? &context->parent->root_item.uuid : &context->parent->root_item.received_uuid, sizeof(BTRFS_UUID));
-        send_add_tlv(context, BTRFS_SEND_TLV_CLONE_CTRANSID, &context->parent->root_item.ctransid, sizeof(UINT64));
+        send_add_tlv(context, BTRFS_SEND_TLV_CLONE_CTRANSID, &context->parent->root_item.ctransid, sizeof(uint64_t));
     }
 
     send_command_finish(context, pos);
 }
 
-static void send_chown_command(send_context* context, char* path, UINT64 uid, UINT64 gid) {
+static void send_chown_command(send_context* context, char* path, uint64_t uid, uint64_t gid) {
     ULONG pos = context->datalen;
 
     send_command(context, BTRFS_SEND_CMD_CHOWN);
 
-    send_add_tlv(context, BTRFS_SEND_TLV_PATH, path, path ? (UINT16)strlen(path) : 0);
-    send_add_tlv(context, BTRFS_SEND_TLV_UID, &uid, sizeof(UINT64));
-    send_add_tlv(context, BTRFS_SEND_TLV_GID, &gid, sizeof(UINT64));
+    send_add_tlv(context, BTRFS_SEND_TLV_PATH, path, path ? (uint16_t)strlen(path) : 0);
+    send_add_tlv(context, BTRFS_SEND_TLV_UID, &uid, sizeof(uint64_t));
+    send_add_tlv(context, BTRFS_SEND_TLV_GID, &gid, sizeof(uint64_t));
 
     send_command_finish(context, pos);
 }
 
-static void send_chmod_command(send_context* context, char* path, UINT64 mode) {
+static void send_chmod_command(send_context* context, char* path, uint64_t mode) {
     ULONG pos = context->datalen;
 
     send_command(context, BTRFS_SEND_CMD_CHMOD);
 
     mode &= 07777;
 
-    send_add_tlv(context, BTRFS_SEND_TLV_PATH, path, path ? (UINT16)strlen(path) : 0);
-    send_add_tlv(context, BTRFS_SEND_TLV_MODE, &mode, sizeof(UINT64));
+    send_add_tlv(context, BTRFS_SEND_TLV_PATH, path, path ? (uint16_t)strlen(path) : 0);
+    send_add_tlv(context, BTRFS_SEND_TLV_MODE, &mode, sizeof(uint64_t));
 
     send_command_finish(context, pos);
 }
@@ -1014,7 +1014,7 @@ static void send_utimes_command(send_context* context, char* path, BTRFS_TIME* a
 
     send_command(context, BTRFS_SEND_CMD_UTIMES);
 
-    send_add_tlv(context, BTRFS_SEND_TLV_PATH, path, path ? (UINT16)strlen(path) : 0);
+    send_add_tlv(context, BTRFS_SEND_TLV_PATH, path, path ? (uint16_t)strlen(path) : 0);
     send_add_tlv(context, BTRFS_SEND_TLV_ATIME, atime, sizeof(BTRFS_TIME));
     send_add_tlv(context, BTRFS_SEND_TLV_MTIME, mtime, sizeof(BTRFS_TIME));
     send_add_tlv(context, BTRFS_SEND_TLV_CTIME, ctime, sizeof(BTRFS_TIME));
@@ -1022,20 +1022,20 @@ static void send_utimes_command(send_context* context, char* path, BTRFS_TIME* a
     send_command_finish(context, pos);
 }
 
-static void send_truncate_command(send_context* context, char* path, UINT64 size) {
+static void send_truncate_command(send_context* context, char* path, uint64_t size) {
     ULONG pos = context->datalen;
 
     send_command(context, BTRFS_SEND_CMD_TRUNCATE);
 
-    send_add_tlv(context, BTRFS_SEND_TLV_PATH, path, path ? (UINT16)strlen(path) : 0);
-    send_add_tlv(context, BTRFS_SEND_TLV_SIZE, &size, sizeof(UINT64));
+    send_add_tlv(context, BTRFS_SEND_TLV_PATH, path, path ? (uint16_t)strlen(path) : 0);
+    send_add_tlv(context, BTRFS_SEND_TLV_SIZE, &size, sizeof(uint64_t));
 
     send_command_finish(context, pos);
 }
 
-static NTSTATUS send_unlink_command(send_context* context, send_dir* parent, UINT16 namelen, char* name) {
+static NTSTATUS send_unlink_command(send_context* context, send_dir* parent, uint16_t namelen, char* name) {
     ULONG pos = context->datalen;
-    UINT16 pathlen;
+    uint16_t pathlen;
 
     send_command(context, BTRFS_SEND_CMD_UNLINK);
 
@@ -1049,7 +1049,7 @@ static NTSTATUS send_unlink_command(send_context* context, send_dir* parent, UIN
     return STATUS_SUCCESS;
 }
 
-static void send_rmdir_command(send_context* context, UINT16 pathlen, char* path) {
+static void send_rmdir_command(send_context* context, uint16_t pathlen, char* path) {
     ULONG pos = context->datalen;
 
     send_command(context, BTRFS_SEND_CMD_RMDIR);
@@ -1057,7 +1057,7 @@ static void send_rmdir_command(send_context* context, UINT16 pathlen, char* path
     send_command_finish(context, pos);
 }
 
-static NTSTATUS get_dir_last_child(send_context* context, UINT64* last_inode) {
+static NTSTATUS get_dir_last_child(send_context* context, uint64_t* last_inode) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
@@ -1068,7 +1068,7 @@ static NTSTATUS get_dir_last_child(send_context* context, UINT64* last_inode) {
     searchkey.obj_type = TYPE_DIR_INDEX;
     searchkey.offset = 2;
 
-    Status = find_item(context->Vcb, context->parent, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(context->Vcb, context->parent, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
@@ -1081,7 +1081,7 @@ static NTSTATUS get_dir_last_child(send_context* context, UINT64* last_inode) {
             DIR_ITEM* di = (DIR_ITEM*)tp.item->data;
 
             if (tp.item->size < sizeof(DIR_ITEM) || tp.item->size < offsetof(DIR_ITEM, name[0]) + di->m + di->n) {
-                ERR("(%llx,%x,%llx) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                ERR("(%I64x,%x,%I64x) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
                 return STATUS_INTERNAL_ERROR;
             }
 
@@ -1090,16 +1090,16 @@ static NTSTATUS get_dir_last_child(send_context* context, UINT64* last_inode) {
         } else
             break;
 
-        if (find_next_item(context->Vcb, &tp, &next_tp, FALSE, NULL))
+        if (find_next_item(context->Vcb, &tp, &next_tp, false, NULL))
             tp = next_tp;
         else
             break;
-    } while (TRUE);
+    } while (true);
 
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS add_pending_rmdir(send_context* context, UINT64 last_inode) {
+static NTSTATUS add_pending_rmdir(send_context* context, uint64_t last_inode) {
     pending_rmdir* pr;
     LIST_ENTRY* le;
 
@@ -1129,18 +1129,18 @@ static NTSTATUS add_pending_rmdir(send_context* context, UINT64 last_inode) {
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS look_for_collision(send_context* context, send_dir* sd, char* name, ULONG namelen, UINT64* inode, BOOL* dir) {
+static NTSTATUS look_for_collision(send_context* context, send_dir* sd, char* name, ULONG namelen, uint64_t* inode, bool* dir) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
     DIR_ITEM* di;
-    UINT16 len;
+    uint16_t len;
 
     searchkey.obj_id = sd->inode;
     searchkey.obj_type = TYPE_DIR_ITEM;
-    searchkey.offset = calc_crc32c(0xfffffffe, (UINT8*)name, namelen);
+    searchkey.offset = calc_crc32c(0xfffffffe, (uint8_t*)name, namelen);
 
-    Status = find_item(context->Vcb, context->parent, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(context->Vcb, context->parent, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         return Status;
@@ -1154,24 +1154,24 @@ static NTSTATUS look_for_collision(send_context* context, send_dir* sd, char* na
 
     do {
         if (len < sizeof(DIR_ITEM) || len < offsetof(DIR_ITEM, name[0]) + di->m + di->n) {
-            ERR("(%llx,%x,%llx) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+            ERR("(%I64x,%x,%I64x) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
             return STATUS_INTERNAL_ERROR;
         }
 
         if (di->n == namelen && RtlCompareMemory(di->name, name, namelen) == namelen) {
             *inode = di->key.obj_type == TYPE_INODE_ITEM ? di->key.obj_id : 0;
-            *dir = di->type == BTRFS_TYPE_DIRECTORY ? TRUE: FALSE;
+            *dir = di->type == BTRFS_TYPE_DIRECTORY ? true: false;
             return STATUS_OBJECT_NAME_COLLISION;
         }
 
         di = (DIR_ITEM*)&di->name[di->m + di->n];
-        len -= (UINT16)offsetof(DIR_ITEM, name[0]) + di->m + di->n;
+        len -= (uint16_t)offsetof(DIR_ITEM, name[0]) + di->m + di->n;
     } while (len > 0);
 
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS make_file_orphan(send_context* context, UINT64 inode, BOOL dir, UINT64 generation, ref* r) {
+static NTSTATUS make_file_orphan(send_context* context, uint64_t inode, bool dir, uint64_t generation, ref* r) {
     NTSTATUS Status;
     ULONG pos = context->datalen;
     send_dir* sd = NULL;
@@ -1224,19 +1224,19 @@ static NTSTATUS make_file_orphan(send_context* context, UINT64 inode, BOOL dir,
             return Status;
         }
 
-        sd->dummy = TRUE;
+        sd->dummy = true;
 
         send_command(context, BTRFS_SEND_CMD_RENAME);
 
         send_add_tlv_path(context, BTRFS_SEND_TLV_PATH, r->sd, r->name, r->namelen);
-        send_add_tlv_path(context, BTRFS_SEND_TLV_PATH_TO, context->root_dir, name, (UINT16)strlen(name));
+        send_add_tlv_path(context, BTRFS_SEND_TLV_PATH_TO, context->root_dir, name, (uint16_t)strlen(name));
 
         send_command_finish(context, pos);
 
         if (sd->name)
             ExFreePool(sd->name);
 
-        sd->namelen = (UINT16)strlen(name);
+        sd->namelen = (uint16_t)strlen(name);
         sd->name = ExAllocatePoolWithTag(PagedPool, sd->namelen, ALLOC_TAG);
         if (!sd->name) {
             ERR("out of memory\n");
@@ -1250,7 +1250,7 @@ static NTSTATUS make_file_orphan(send_context* context, UINT64 inode, BOOL dir,
 
         send_add_tlv_path(context, BTRFS_SEND_TLV_PATH, r->sd, r->name, r->namelen);
 
-        send_add_tlv_path(context, BTRFS_SEND_TLV_PATH_TO, context->root_dir, name, (UINT16)strlen(name));
+        send_add_tlv_path(context, BTRFS_SEND_TLV_PATH_TO, context->root_dir, name, (uint16_t)strlen(name));
 
         send_command_finish(context, pos);
     }
@@ -1262,7 +1262,7 @@ static NTSTATUS make_file_orphan(send_context* context, UINT64 inode, BOOL dir,
     }
 
     o->inode = inode;
-    o->dir = TRUE;
+    o->dir = true;
     strcpy(o->tmpname, name);
     o->sd = sd;
     add_orphan(context, o);
@@ -1292,7 +1292,7 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
             context->lastinode.path[len] = 0;
 
             if (!context->lastinode.sd) {
-                Status = find_send_dir(context, context->lastinode.inode, context->lastinode.gen, &context->lastinode.sd, FALSE);
+                Status = find_send_dir(context, context->lastinode.inode, context->lastinode.gen, &context->lastinode.sd, false);
                 if (!NT_SUCCESS(Status)) {
                     ERR("find_send_dir returned %08x\n", Status);
                     return Status;
@@ -1301,8 +1301,8 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
         }
 
         if (r && or) {
-            UINT64 inode;
-            BOOL dir;
+            uint64_t inode;
+            bool dir;
 
             Status = look_for_collision(context, r->sd, r->name, r->namelen, &inode, &dir);
             if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_COLLISION) {
@@ -1332,7 +1332,7 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
 
                 send_command(context, BTRFS_SEND_CMD_RENAME);
 
-                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, (UINT16)strlen(context->lastinode.path));
+                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, (uint16_t)strlen(context->lastinode.path));
 
                 send_add_tlv_path(context, BTRFS_SEND_TLV_PATH_TO, r->sd, r->name, r->namelen);
 
@@ -1376,7 +1376,7 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
             if (!r->sd->dummy)
                 send_utimes_command_dir(context, r->sd, &r->sd->atime, &r->sd->mtime, &r->sd->ctime);
         } else { // deleted
-            UINT64 last_inode;
+            uint64_t last_inode;
 
             Status = get_dir_last_child(context, &last_inode);
             if (!NT_SUCCESS(Status)) {
@@ -1385,7 +1385,7 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
             }
 
             if (last_inode <= context->lastinode.inode) {
-                send_rmdir_command(context, (UINT16)strlen(context->lastinode.path), context->lastinode.path);
+                send_rmdir_command(context, (uint16_t)strlen(context->lastinode.path), context->lastinode.path);
 
                 if (!or->sd->dummy)
                     send_utimes_command_dir(context, or->sd, &or->sd->atime, &or->sd->mtime, &or->sd->ctime);
@@ -1400,8 +1400,8 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
                 }
 
                 send_command(context, BTRFS_SEND_CMD_RENAME);
-                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, (UINT16)strlen(context->lastinode.path));
-                send_add_tlv(context, BTRFS_SEND_TLV_PATH_TO, name, (UINT16)strlen(name));
+                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, (uint16_t)strlen(context->lastinode.path));
+                send_add_tlv(context, BTRFS_SEND_TLV_PATH_TO, name, (uint16_t)strlen(name));
                 send_command_finish(context, pos);
 
                 if (context->lastinode.sd->name)
@@ -1414,8 +1414,8 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
                 }
 
                 RtlCopyMemory(context->lastinode.sd->name, name, strlen(name));
-                context->lastinode.sd->namelen = (UINT16)strlen(name);
-                context->lastinode.sd->dummy = TRUE;
+                context->lastinode.sd->namelen = (uint16_t)strlen(name);
+                context->lastinode.sd->dummy = true;
                 context->lastinode.sd->parent = NULL;
 
                 send_utimes_command(context, NULL, &context->root_dir->atime, &context->root_dir->mtime, &context->root_dir->ctime);
@@ -1460,7 +1460,7 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
         while (le != &context->lastinode.oldrefs) {
             ref* or = CONTAINING_RECORD(le, ref, list_entry);
             LIST_ENTRY* le2;
-            BOOL matched = FALSE;
+            bool matched = false;
 
             le2 = context->lastinode.refs.Flink;
             while (le2 != &context->lastinode.refs) {
@@ -1469,7 +1469,7 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
                 if (r->sd == or->sd && r->namelen == or->namelen && RtlCompareMemory(r->name, or->name, r->namelen) == r->namelen) {
                     RemoveEntryList(&r->list_entry);
                     ExFreePool(r);
-                    matched = TRUE;
+                    matched = true;
                     break;
                 }
 
@@ -1488,8 +1488,8 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
 
         while (!IsListEmpty(&context->lastinode.refs)) {
             ref* r = CONTAINING_RECORD(RemoveHeadList(&context->lastinode.refs), ref, list_entry);
-            UINT64 inode;
-            BOOL dir;
+            uint64_t inode;
+            bool dir;
 
             if (context->parent) {
                 Status = look_for_collision(context, r->sd, r->name, r->namelen, &inode, &dir);
@@ -1535,7 +1535,7 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
 
         while (!IsListEmpty(&context->lastinode.oldrefs)) {
             ref* or = CONTAINING_RECORD(RemoveHeadList(&context->lastinode.oldrefs), ref, list_entry);
-            BOOL deleted = FALSE;
+            bool deleted = false;
 
             le = or->sd->deleted_children.Flink;
             while (le != &or->sd->deleted_children) {
@@ -1544,7 +1544,7 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
                 if (dc->namelen == or->namelen && RtlCompareMemory(dc->name, or->name, or->namelen) == or->namelen) {
                     RemoveEntryList(&dc->list_entry);
                     ExFreePool(dc);
-                    deleted = TRUE;
+                    deleted = true;
                     break;
                 }
 
@@ -1574,7 +1574,7 @@ static NTSTATUS flush_refs(send_context* context, traverse_ptr* tp1, traverse_pt
             }
 
             if (or == nameref && nameref2) {
-                UINT16 len = find_path_len(nameref2->sd, nameref2->namelen);
+                uint16_t len = find_path_len(nameref2->sd, nameref2->namelen);
 
                 if (context->lastinode.path)
                     ExFreePool(context->lastinode.path);
@@ -1611,16 +1611,16 @@ static NTSTATUS wait_for_flush(send_context* context, traverse_ptr* tp1, travers
     ExReleaseResourceLite(&context->Vcb->tree_lock);
 
     KeClearEvent(&context->send->cleared_event);
-    KeSetEvent(&context->buffer_event, 0, TRUE);
-    KeWaitForSingleObject(&context->send->cleared_event, Executive, KernelMode, FALSE, NULL);
+    KeSetEvent(&context->buffer_event, 0, true);
+    KeWaitForSingleObject(&context->send->cleared_event, Executive, KernelMode, false, NULL);
 
-    ExAcquireResourceSharedLite(&context->Vcb->tree_lock, TRUE);
+    ExAcquireResourceSharedLite(&context->Vcb->tree_lock, true);
 
     if (context->send->cancelling)
         return STATUS_SUCCESS;
 
     if (tp1) {
-        Status = find_item(context->Vcb, context->root, tp1, &key1, FALSE, NULL);
+        Status = find_item(context->Vcb, context->root, tp1, &key1, false, NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
             return Status;
@@ -1633,7 +1633,7 @@ static NTSTATUS wait_for_flush(send_context* context, traverse_ptr* tp1, travers
     }
 
     if (tp2) {
-        Status = find_item(context->Vcb, context->parent, tp2, &key2, FALSE, NULL);
+        Status = find_item(context->Vcb, context->parent, tp2, &key2, false, NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
             return Status;
@@ -1648,8 +1648,8 @@ static NTSTATUS wait_for_flush(send_context* context, traverse_ptr* tp1, travers
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS add_ext_holes(device_extension* Vcb, LIST_ENTRY* exts, UINT64 size) {
-    UINT64 lastoff = 0;
+static NTSTATUS add_ext_holes(device_extension* Vcb, LIST_ENTRY* exts, uint64_t size) {
+    uint64_t lastoff = 0;
     LIST_ENTRY* le;
 
     le = exts->Flink;
@@ -1709,7 +1709,7 @@ static NTSTATUS add_ext_holes(device_extension* Vcb, LIST_ENTRY* exts, UINT64 si
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS divide_ext(send_ext* ext, UINT64 len, BOOL trunc) {
+static NTSTATUS divide_ext(send_ext* ext, uint64_t len, bool trunc) {
     send_ext* ext2;
     EXTENT_DATA2 *ed2a, *ed2b;
 
@@ -1789,7 +1789,7 @@ static NTSTATUS sync_ext_cutoff_points(send_context* context) {
     ext2 = CONTAINING_RECORD(context->lastinode.oldexts.Flink, send_ext, list_entry);
 
     do {
-        UINT64 len1, len2;
+        uint64_t len1, len2;
         EXTENT_DATA2 *ed2a, *ed2b;
 
         ed2a = ext1->data.type == EXTENT_TYPE_INLINE ? NULL : (EXTENT_DATA2*)ext1->data.data;
@@ -1799,13 +1799,13 @@ static NTSTATUS sync_ext_cutoff_points(send_context* context) {
         len2 = ed2b ? ed2b->num_bytes : ext2->data.decoded_size;
 
         if (len1 < len2) {
-            Status = divide_ext(ext2, len1, FALSE);
+            Status = divide_ext(ext2, len1, false);
             if (!NT_SUCCESS(Status)) {
                 ERR("divide_ext returned %08x\n", Status);
                 return Status;
             }
         } else if (len2 < len1) {
-            Status = divide_ext(ext1, len2, FALSE);
+            Status = divide_ext(ext1, len2, false);
             if (!NT_SUCCESS(Status)) {
                 ERR("divide_ext returned %08x\n", Status);
                 return Status;
@@ -1817,18 +1817,18 @@ static NTSTATUS sync_ext_cutoff_points(send_context* context) {
 
         ext1 = CONTAINING_RECORD(ext1->list_entry.Flink, send_ext, list_entry);
         ext2 = CONTAINING_RECORD(ext2->list_entry.Flink, send_ext, list_entry);
-    } while (TRUE);
+    } while (true);
 
     ext1 = CONTAINING_RECORD(context->lastinode.exts.Blink, send_ext, list_entry);
     ext2 = CONTAINING_RECORD(context->lastinode.oldexts.Blink, send_ext, list_entry);
 
-    Status = divide_ext(ext1, context->lastinode.size - ext1->offset, TRUE);
+    Status = divide_ext(ext1, context->lastinode.size - ext1->offset, true);
     if (!NT_SUCCESS(Status)) {
         ERR("divide_ext returned %08x\n", Status);
         return Status;
     }
 
-    Status = divide_ext(ext2, context->lastinode.size - ext2->offset, TRUE);
+    Status = divide_ext(ext2, context->lastinode.size - ext2->offset, true);
     if (!NT_SUCCESS(Status)) {
         ERR("divide_ext returned %08x\n", Status);
         return Status;
@@ -1837,13 +1837,13 @@ static NTSTATUS sync_ext_cutoff_points(send_context* context) {
     return STATUS_SUCCESS;
 }
 
-static BOOL send_add_tlv_clone_path(send_context* context, root* r, UINT64 inode) {
+static bool send_add_tlv_clone_path(send_context* context, root* r, uint64_t inode) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
-    UINT16 len = 0;
-    UINT64 num;
-    UINT8* ptr;
+    uint16_t len = 0;
+    uint64_t num;
+    uint8_t* ptr;
 
     num = inode;
 
@@ -1852,15 +1852,15 @@ static BOOL send_add_tlv_clone_path(send_context* context, root* r, UINT64 inode
         searchkey.obj_type = TYPE_INODE_EXTREF;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(context->Vcb, r, &tp, &searchkey, FALSE, NULL);
+        Status = find_item(context->Vcb, r, &tp, &searchkey, false, NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
-            return FALSE;
+            return false;
         }
 
         if (tp.item->key.obj_id != searchkey.obj_id || (tp.item->key.obj_type != TYPE_INODE_REF && tp.item->key.obj_type != TYPE_INODE_EXTREF)) {
-            ERR("could not find INODE_REF for inode %llx\n", searchkey.obj_id);
-            return FALSE;
+            ERR("could not find INODE_REF for inode %I64x\n", searchkey.obj_id);
+            return false;
         }
 
         if (len > 0)
@@ -1870,8 +1870,8 @@ static BOOL send_add_tlv_clone_path(send_context* context, root* r, UINT64 inode
             INODE_REF* ir = (INODE_REF*)tp.item->data;
 
             if (tp.item->size < sizeof(INODE_REF) || tp.item->size < offsetof(INODE_REF, name[0]) + ir->n) {
-                ERR("(%llx,%x,%llx) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
-                return FALSE;
+                ERR("(%I64x,%x,%I64x) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                return false;
             }
 
             len += ir->n;
@@ -1880,8 +1880,8 @@ static BOOL send_add_tlv_clone_path(send_context* context, root* r, UINT64 inode
             INODE_EXTREF* ier = (INODE_EXTREF*)tp.item->data;
 
             if (tp.item->size < sizeof(INODE_EXTREF) || tp.item->size < offsetof(INODE_EXTREF, name[0]) + ier->n) {
-                ERR("(%llx,%x,%llx) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
-                return FALSE;
+                ERR("(%I64x,%x,%I64x) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                return false;
             }
 
             len += ier->n;
@@ -1899,15 +1899,15 @@ static BOOL send_add_tlv_clone_path(send_context* context, root* r, UINT64 inode
         searchkey.obj_type = TYPE_INODE_EXTREF;
         searchkey.offset = 0xffffffffffffffff;
 
-        Status = find_item(context->Vcb, r, &tp, &searchkey, FALSE, NULL);
+        Status = find_item(context->Vcb, r, &tp, &searchkey, false, NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
-            return FALSE;
+            return false;
         }
 
         if (tp.item->key.obj_id != searchkey.obj_id || (tp.item->key.obj_type != TYPE_INODE_REF && tp.item->key.obj_type != TYPE_INODE_EXTREF)) {
-            ERR("could not find INODE_REF for inode %llx\n", searchkey.obj_id);
-            return FALSE;
+            ERR("could not find INODE_REF for inode %I64x\n", searchkey.obj_id);
+            return false;
         }
 
         if (num != inode) {
@@ -1930,10 +1930,10 @@ static BOOL send_add_tlv_clone_path(send_context* context, root* r, UINT64 inode
         }
     }
 
-    return TRUE;
+    return true;
 }
 
-static BOOL try_clone_edr(send_context* context, send_ext* se, EXTENT_DATA_REF* edr) {
+static bool try_clone_edr(send_context* context, send_ext* se, EXTENT_DATA_REF* edr) {
     NTSTATUS Status;
     root* r = NULL;
     KEY searchkey;
@@ -1955,57 +1955,57 @@ static BOOL try_clone_edr(send_context* context, send_ext* se, EXTENT_DATA_REF*
     }
 
     if (!r)
-        return FALSE;
+        return false;
 
     searchkey.obj_id = edr->objid;
     searchkey.obj_type = TYPE_EXTENT_DATA;
     searchkey.offset = 0;
 
-    Status = find_item(context->Vcb, r, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(context->Vcb, r, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
-    while (TRUE) {
+    while (true) {
         traverse_ptr next_tp;
 
         if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type) {
             if (tp.item->size < sizeof(EXTENT_DATA))
-                ERR("(%llx,%x,%llx) has size %u, not at least %u as expected\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_DATA));
+                ERR("(%I64x,%x,%I64x) has size %u, not at least %u as expected\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_DATA));
             else {
                 EXTENT_DATA* ed = (EXTENT_DATA*)tp.item->data;
 
                 if (ed->type == EXTENT_TYPE_REGULAR) {
                     if (tp.item->size < offsetof(EXTENT_DATA, data[0]) + sizeof(EXTENT_DATA2))
-                        ERR("(%llx,%x,%llx) has size %u, not %u as expected\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
+                        ERR("(%I64x,%x,%I64x) has size %u, not %u as expected\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                             tp.item->size, offsetof(EXTENT_DATA, data[0]) + sizeof(EXTENT_DATA2));
                     else {
                         EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ed->data;
 
                         if (ed2->address == seed2->address && ed2->size == seed2->size && seed2->offset <= ed2->offset && seed2->offset + seed2->num_bytes >= ed2->offset + ed2->num_bytes) {
-                            UINT64 clone_offset = tp.item->key.offset + ed2->offset - seed2->offset;
-                            UINT64 clone_len = min(context->lastinode.size - se->offset, ed2->num_bytes);
+                            uint64_t clone_offset = tp.item->key.offset + ed2->offset - seed2->offset;
+                            uint64_t clone_len = min(context->lastinode.size - se->offset, ed2->num_bytes);
 
                             if (clone_offset % context->Vcb->superblock.sector_size == 0 && clone_len % context->Vcb->superblock.sector_size == 0) {
                                 ULONG pos = context->datalen;
 
                                 send_command(context, BTRFS_SEND_CMD_CLONE);
 
-                                send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &se->offset, sizeof(UINT64));
-                                send_add_tlv(context, BTRFS_SEND_TLV_CLONE_LENGTH, &clone_len, sizeof(UINT64));
-                                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (UINT16)strlen(context->lastinode.path) : 0);
+                                send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &se->offset, sizeof(uint64_t));
+                                send_add_tlv(context, BTRFS_SEND_TLV_CLONE_LENGTH, &clone_len, sizeof(uint64_t));
+                                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (uint16_t)strlen(context->lastinode.path) : 0);
                                 send_add_tlv(context, BTRFS_SEND_TLV_CLONE_UUID, r->root_item.rtransid == 0 ? &r->root_item.uuid : &r->root_item.received_uuid, sizeof(BTRFS_UUID));
-                                send_add_tlv(context, BTRFS_SEND_TLV_CLONE_CTRANSID, &r->root_item.ctransid, sizeof(UINT64));
+                                send_add_tlv(context, BTRFS_SEND_TLV_CLONE_CTRANSID, &r->root_item.ctransid, sizeof(uint64_t));
 
                                 if (!send_add_tlv_clone_path(context, r, tp.item->key.obj_id))
                                     context->datalen = pos;
                                 else {
-                                    send_add_tlv(context, BTRFS_SEND_TLV_CLONE_OFFSET, &clone_offset, sizeof(UINT64));
+                                    send_add_tlv(context, BTRFS_SEND_TLV_CLONE_OFFSET, &clone_offset, sizeof(uint64_t));
 
                                     send_command_finish(context, pos);
 
-                                    return TRUE;
+                                    return true;
                                 }
                             }
                         }
@@ -2015,112 +2015,112 @@ static BOOL try_clone_edr(send_context* context, send_ext* se, EXTENT_DATA_REF*
         } else if (tp.item->key.obj_id > searchkey.obj_id || (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type > searchkey.obj_type))
             break;
 
-        if (find_next_item(context->Vcb, &tp, &next_tp, FALSE, NULL))
+        if (find_next_item(context->Vcb, &tp, &next_tp, false, NULL))
             tp = next_tp;
         else
             break;
     }
 
-    return FALSE;
+    return false;
 }
 
-static BOOL try_clone(send_context* context, send_ext* se) {
+static bool try_clone(send_context* context, send_ext* se) {
     NTSTATUS Status;
     KEY searchkey;
     traverse_ptr tp;
     EXTENT_DATA2* ed2 = (EXTENT_DATA2*)se->data.data;
     EXTENT_ITEM* ei;
-    UINT64 rc = 0;
+    uint64_t rc = 0;
 
     searchkey.obj_id = ed2->address;
     searchkey.obj_type = TYPE_EXTENT_ITEM;
     searchkey.offset = ed2->size;
 
-    Status = find_item(context->Vcb, context->Vcb->extent_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(context->Vcb, context->Vcb->extent_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
     if (keycmp(tp.item->key, searchkey)) {
-        ERR("(%llx,%x,%llx) not found\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
-        return FALSE;
+        ERR("(%I64x,%x,%I64x) not found\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
+        return false;
     }
 
     if (tp.item->size < sizeof(EXTENT_ITEM)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
-        return FALSE;
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_ITEM));
+        return false;
     }
 
     ei = (EXTENT_ITEM*)tp.item->data;
 
     if (tp.item->size > sizeof(EXTENT_ITEM)) {
-        UINT32 len = tp.item->size - sizeof(EXTENT_ITEM);
-        UINT8* ptr = (UINT8*)&ei[1];
+        uint32_t len = tp.item->size - sizeof(EXTENT_ITEM);
+        uint8_t* ptr = (uint8_t*)&ei[1];
 
         while (len > 0) {
-            UINT8 secttype = *ptr;
+            uint8_t secttype = *ptr;
             ULONG sectlen = get_extent_data_len(secttype);
-            UINT64 sectcount = get_extent_data_refcount(secttype, ptr + sizeof(UINT8));
+            uint64_t sectcount = get_extent_data_refcount(secttype, ptr + sizeof(uint8_t));
 
             len--;
 
             if (sectlen > len) {
-                ERR("(%llx,%x,%llx): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
-                return FALSE;
+                ERR("(%I64x,%x,%I64x): %x bytes left, expecting at least %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, len, sectlen);
+                return false;
             }
 
             if (sectlen == 0) {
-                ERR("(%llx,%x,%llx): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
-                return FALSE;
+                ERR("(%I64x,%x,%I64x): unrecognized extent type %x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, secttype);
+                return false;
             }
 
             rc += sectcount;
 
             if (secttype == TYPE_EXTENT_DATA_REF) {
-                EXTENT_DATA_REF* sectedr = (EXTENT_DATA_REF*)(ptr + sizeof(UINT8));
+                EXTENT_DATA_REF* sectedr = (EXTENT_DATA_REF*)(ptr + sizeof(uint8_t));
 
                 if (try_clone_edr(context, se, sectedr))
-                    return TRUE;
+                    return true;
             }
 
             len -= sectlen;
-            ptr += sizeof(UINT8) + sectlen;
+            ptr += sizeof(uint8_t) + sectlen;
         }
     }
 
     if (rc >= ei->refcount)
-        return FALSE;
+        return false;
 
     searchkey.obj_type = TYPE_EXTENT_DATA_REF;
     searchkey.offset = 0;
 
-    Status = find_item(context->Vcb, context->Vcb->extent_root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(context->Vcb, context->Vcb->extent_root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
-        return FALSE;
+        return false;
     }
 
-    while (TRUE) {
+    while (true) {
         traverse_ptr next_tp;
 
         if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type) {
             if (tp.item->size < sizeof(EXTENT_DATA_REF))
-                ERR("(%llx,%x,%llx) has size %u, not %u as expected\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_DATA_REF));
+                ERR("(%I64x,%x,%I64x) has size %u, not %u as expected\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(EXTENT_DATA_REF));
             else {
                 if (try_clone_edr(context, se, (EXTENT_DATA_REF*)tp.item->data))
-                    return TRUE;
+                    return true;
             }
         } else if (tp.item->key.obj_id > searchkey.obj_id || (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type > searchkey.obj_type))
             break;
 
-        if (find_next_item(context->Vcb, &tp, &next_tp, FALSE, NULL))
+        if (find_next_item(context->Vcb, &tp, &next_tp, false, NULL))
             tp = next_tp;
         else
             break;
     }
 
-    return FALSE;
+    return false;
 }
 
 static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse_ptr* tp2) {
@@ -2182,19 +2182,19 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
 
             send_command(context, BTRFS_SEND_CMD_WRITE);
 
-            send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (UINT16)strlen(context->lastinode.path) : 0);
-            send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &se->offset, sizeof(UINT64));
+            send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (uint16_t)strlen(context->lastinode.path) : 0);
+            send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &se->offset, sizeof(uint64_t));
 
             if (se->data.compression == BTRFS_COMPRESSION_NONE)
-                send_add_tlv(context, BTRFS_SEND_TLV_DATA, se->data.data, (UINT16)se->data.decoded_size);
+                send_add_tlv(context, BTRFS_SEND_TLV_DATA, se->data.data, (uint16_t)se->data.decoded_size);
             else if (se->data.compression == BTRFS_COMPRESSION_ZLIB || se->data.compression == BTRFS_COMPRESSION_LZO || se->data.compression == BTRFS_COMPRESSION_ZSTD) {
                 ULONG inlen = se->datalen - (ULONG)offsetof(EXTENT_DATA, data[0]);
 
-                send_add_tlv(context, BTRFS_SEND_TLV_DATA, NULL, (UINT16)se->data.decoded_size);
+                send_add_tlv(context, BTRFS_SEND_TLV_DATA, NULL, (uint16_t)se->data.decoded_size);
                 RtlZeroMemory(&context->data[context->datalen - se->data.decoded_size], (ULONG)se->data.decoded_size);
 
                 if (se->data.compression == BTRFS_COMPRESSION_ZLIB) {
-                    Status = zlib_decompress(se->data.data, inlen, &context->data[context->datalen - se->data.decoded_size], (UINT32)se->data.decoded_size);
+                    Status = zlib_decompress(se->data.data, inlen, &context->data[context->datalen - se->data.decoded_size], (uint32_t)se->data.decoded_size);
                     if (!NT_SUCCESS(Status)) {
                         ERR("zlib_decompress returned %08x\n", Status);
                         ExFreePool(se);
@@ -2202,15 +2202,15 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
                         return Status;
                     }
                 } else if (se->data.compression == BTRFS_COMPRESSION_LZO) {
-                    if (inlen < sizeof(UINT32)) {
+                    if (inlen < sizeof(uint32_t)) {
                         ERR("extent data was truncated\n");
                         ExFreePool(se);
                         if (se2) ExFreePool(se2);
                         return STATUS_INTERNAL_ERROR;
                     } else
-                        inlen -= sizeof(UINT32);
+                        inlen -= sizeof(uint32_t);
 
-                    Status = lzo_decompress(se->data.data + sizeof(UINT32), inlen, &context->data[context->datalen - se->data.decoded_size], (UINT32)se->data.decoded_size, sizeof(UINT32));
+                    Status = lzo_decompress(se->data.data + sizeof(uint32_t), inlen, &context->data[context->datalen - se->data.decoded_size], (uint32_t)se->data.decoded_size, sizeof(uint32_t));
                     if (!NT_SUCCESS(Status)) {
                         ERR("lzo_decompress returned %08x\n", Status);
                         ExFreePool(se);
@@ -2218,7 +2218,7 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
                         return Status;
                     }
                 } else if (se->data.compression == BTRFS_COMPRESSION_ZSTD) {
-                    Status = zstd_decompress(se->data.data, inlen, &context->data[context->datalen - se->data.decoded_size], (UINT32)se->data.decoded_size);
+                    Status = zstd_decompress(se->data.data, inlen, &context->data[context->datalen - se->data.decoded_size], (uint32_t)se->data.decoded_size);
                     if (!NT_SUCCESS(Status)) {
                         ERR("zlib_decompress returned %08x\n", Status);
                         ExFreePool(se);
@@ -2251,10 +2251,10 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
         }
 
         if (ed2->size == 0) { // write sparse
-            UINT64 off, offset;
+            uint64_t off, offset;
 
             for (off = ed2->offset; off < ed2->offset + ed2->num_bytes; off += MAX_SEND_WRITE) {
-                UINT16 length = (UINT16)min(min(ed2->offset + ed2->num_bytes - off, MAX_SEND_WRITE), context->lastinode.size - se->offset - off);
+                uint16_t length = (uint16_t)min(min(ed2->offset + ed2->num_bytes - off, MAX_SEND_WRITE), context->lastinode.size - se->offset - off);
 
                 if (context->datalen > SEND_BUFFER_LENGTH) {
                     Status = wait_for_flush(context, tp1, tp2);
@@ -2276,10 +2276,10 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
 
                 send_command(context, BTRFS_SEND_CMD_WRITE);
 
-                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (UINT16)strlen(context->lastinode.path) : 0);
+                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (uint16_t)strlen(context->lastinode.path) : 0);
 
                 offset = se->offset + off;
-                send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &offset, sizeof(UINT64));
+                send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &offset, sizeof(uint64_t));
 
                 send_add_tlv(context, BTRFS_SEND_TLV_DATA, NULL, length);
                 RtlZeroMemory(&context->data[context->datalen - length], length);
@@ -2287,8 +2287,8 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
                 send_command_finish(context, pos);
             }
         } else if (se->data.compression == BTRFS_COMPRESSION_NONE) {
-            UINT64 off, offset;
-            UINT8* buf;
+            uint64_t off, offset;
+            uint8_t* buf;
 
             buf = ExAllocatePoolWithTag(NonPagedPool, MAX_SEND_WRITE + (2 * context->Vcb->superblock.sector_size), ALLOC_TAG);
             if (!buf) {
@@ -2299,10 +2299,10 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
             }
 
             for (off = ed2->offset; off < ed2->offset + ed2->num_bytes; off += MAX_SEND_WRITE) {
-                UINT16 length = (UINT16)min(ed2->offset + ed2->num_bytes - off, MAX_SEND_WRITE);
+                uint16_t length = (uint16_t)min(ed2->offset + ed2->num_bytes - off, MAX_SEND_WRITE);
                 ULONG skip_start;
-                UINT64 addr = ed2->address + off;
-                UINT32* csum;
+                uint64_t addr = ed2->address + off;
+                uint32_t* csum;
 
                 if (context->datalen > SEND_BUFFER_LENGTH) {
                     Status = wait_for_flush(context, tp1, tp2);
@@ -2328,11 +2328,11 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
                 if (context->lastinode.flags & BTRFS_INODE_NODATASUM)
                     csum = NULL;
                 else {
-                    UINT32 len;
+                    uint32_t len;
 
-                    len = (UINT32)sector_align(length + skip_start, context->Vcb->superblock.sector_size) / context->Vcb->superblock.sector_size;
+                    len = (uint32_t)sector_align(length + skip_start, context->Vcb->superblock.sector_size) / context->Vcb->superblock.sector_size;
 
-                    csum = ExAllocatePoolWithTag(PagedPool, len * sizeof(UINT32), ALLOC_TAG);
+                    csum = ExAllocatePoolWithTag(PagedPool, len * sizeof(uint32_t), ALLOC_TAG);
                     if (!csum) {
                         ERR("out of memory\n");
                         ExFreePool(buf);
@@ -2352,8 +2352,8 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
                     }
                 }
 
-                Status = read_data(context->Vcb, addr, (UINT32)sector_align(length + skip_start, context->Vcb->superblock.sector_size),
-                                   csum, FALSE, buf, NULL, NULL, NULL, 0, FALSE, NormalPagePriority);
+                Status = read_data(context->Vcb, addr, (uint32_t)sector_align(length + skip_start, context->Vcb->superblock.sector_size),
+                                   csum, false, buf, NULL, NULL, NULL, 0, false, NormalPagePriority);
                 if (!NT_SUCCESS(Status)) {
                     ERR("read_data returned %08x\n", Status);
                     ExFreePool(buf);
@@ -2370,12 +2370,12 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
 
                 send_command(context, BTRFS_SEND_CMD_WRITE);
 
-                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (UINT16)strlen(context->lastinode.path) : 0);
+                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (uint16_t)strlen(context->lastinode.path) : 0);
 
                 offset = se->offset + off;
-                send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &offset, sizeof(UINT64));
+                send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &offset, sizeof(uint64_t));
 
-                length = (UINT16)min(context->lastinode.size - se->offset - off, length);
+                length = (uint16_t)min(context->lastinode.size - se->offset - off, length);
                 send_add_tlv(context, BTRFS_SEND_TLV_DATA, buf + skip_start, length);
 
                 send_command_finish(context, pos);
@@ -2383,9 +2383,9 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
 
             ExFreePool(buf);
         } else {
-            UINT8 *buf, *compbuf;
-            UINT64 off;
-            UINT32* csum;
+            uint8_t *buf, *compbuf;
+            uint64_t off;
+            uint32_t* csum;
 
             buf = ExAllocatePoolWithTag(PagedPool, (ULONG)se->data.decoded_size, ALLOC_TAG);
             if (!buf) {
@@ -2407,11 +2407,11 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
             if (context->lastinode.flags & BTRFS_INODE_NODATASUM)
                 csum = NULL;
             else {
-                UINT32 len;
+                uint32_t len;
 
-                len = (UINT32)(ed2->size / context->Vcb->superblock.sector_size);
+                len = (uint32_t)(ed2->size / context->Vcb->superblock.sector_size);
 
-                csum = ExAllocatePoolWithTag(PagedPool, len * sizeof(UINT32), ALLOC_TAG);
+                csum = ExAllocatePoolWithTag(PagedPool, len * sizeof(uint32_t), ALLOC_TAG);
                 if (!csum) {
                     ERR("out of memory\n");
                     ExFreePool(compbuf);
@@ -2433,7 +2433,7 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
                 }
             }
 
-            Status = read_data(context->Vcb, ed2->address, (UINT32)ed2->size, csum, FALSE, compbuf, NULL, NULL, NULL, 0, FALSE, NormalPagePriority);
+            Status = read_data(context->Vcb, ed2->address, (uint32_t)ed2->size, csum, false, compbuf, NULL, NULL, NULL, 0, false, NormalPagePriority);
             if (!NT_SUCCESS(Status)) {
                 ERR("read_data returned %08x\n", Status);
                 ExFreePool(compbuf);
@@ -2448,7 +2448,7 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
                 ExFreePool(csum);
 
             if (se->data.compression == BTRFS_COMPRESSION_ZLIB) {
-                Status = zlib_decompress(compbuf, (UINT32)ed2->size, buf, (UINT32)se->data.decoded_size);
+                Status = zlib_decompress(compbuf, (uint32_t)ed2->size, buf, (uint32_t)se->data.decoded_size);
                 if (!NT_SUCCESS(Status)) {
                     ERR("zlib_decompress returned %08x\n", Status);
                     ExFreePool(compbuf);
@@ -2458,7 +2458,7 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
                     return Status;
                 }
             } else if (se->data.compression == BTRFS_COMPRESSION_LZO) {
-                Status = lzo_decompress(&compbuf[sizeof(UINT32)], (UINT32)ed2->size, buf, (UINT32)se->data.decoded_size, sizeof(UINT32));
+                Status = lzo_decompress(&compbuf[sizeof(uint32_t)], (uint32_t)ed2->size, buf, (uint32_t)se->data.decoded_size, sizeof(uint32_t));
                 if (!NT_SUCCESS(Status)) {
                     ERR("lzo_decompress returned %08x\n", Status);
                     ExFreePool(compbuf);
@@ -2468,7 +2468,7 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
                     return Status;
                 }
             } else if (se->data.compression == BTRFS_COMPRESSION_ZSTD) {
-                Status = zstd_decompress(compbuf, (UINT32)ed2->size, buf, (UINT32)se->data.decoded_size);
+                Status = zstd_decompress(compbuf, (uint32_t)ed2->size, buf, (uint32_t)se->data.decoded_size);
                 if (!NT_SUCCESS(Status)) {
                     ERR("zstd_decompress returned %08x\n", Status);
                     ExFreePool(compbuf);
@@ -2482,8 +2482,8 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
             ExFreePool(compbuf);
 
             for (off = ed2->offset; off < ed2->offset + ed2->num_bytes; off += MAX_SEND_WRITE) {
-                UINT16 length = (UINT16)min(ed2->offset + ed2->num_bytes - off, MAX_SEND_WRITE);
-                UINT64 offset;
+                uint16_t length = (uint16_t)min(ed2->offset + ed2->num_bytes - off, MAX_SEND_WRITE);
+                uint64_t offset;
 
                 if (context->datalen > SEND_BUFFER_LENGTH) {
                     Status = wait_for_flush(context, tp1, tp2);
@@ -2507,12 +2507,12 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
 
                 send_command(context, BTRFS_SEND_CMD_WRITE);
 
-                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (UINT16)strlen(context->lastinode.path) : 0);
+                send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (uint16_t)strlen(context->lastinode.path) : 0);
 
                 offset = se->offset + off;
-                send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &offset, sizeof(UINT64));
+                send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &offset, sizeof(uint64_t));
 
-                length = (UINT16)min(context->lastinode.size - se->offset - off, length);
+                length = (uint16_t)min(context->lastinode.size - se->offset - off, length);
                 send_add_tlv(context, BTRFS_SEND_TLV_DATA, &buf[off], length);
 
                 send_command_finish(context, pos);
@@ -2640,7 +2640,7 @@ static NTSTATUS send_extent_data(send_context* context, traverse_ptr* tp, traver
         EXTENT_DATA2* ed2 = NULL;
 
         if (tp->item->size < sizeof(EXTENT_DATA)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
                 tp->item->size, sizeof(EXTENT_DATA));
             return STATUS_INTERNAL_ERROR;
         }
@@ -2665,7 +2665,7 @@ static NTSTATUS send_extent_data(send_context* context, traverse_ptr* tp, traver
 
         if (ed->type == EXTENT_TYPE_REGULAR) {
             if (tp->item->size < offsetof(EXTENT_DATA, data[0]) + sizeof(EXTENT_DATA2)) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
                     tp->item->size, offsetof(EXTENT_DATA, data[0]) + sizeof(EXTENT_DATA2));
                 return STATUS_INTERNAL_ERROR;
             }
@@ -2673,7 +2673,7 @@ static NTSTATUS send_extent_data(send_context* context, traverse_ptr* tp, traver
             ed2 = (EXTENT_DATA2*)ed->data;
         } else if (ed->type == EXTENT_TYPE_INLINE) {
             if (tp->item->size < offsetof(EXTENT_DATA, data[0]) + ed->decoded_size && ed->compression == BTRFS_COMPRESSION_NONE) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
                     tp->item->size, offsetof(EXTENT_DATA, data[0]) + ed->decoded_size);
                 return STATUS_INTERNAL_ERROR;
             }
@@ -2699,7 +2699,7 @@ static NTSTATUS send_extent_data(send_context* context, traverse_ptr* tp, traver
         EXTENT_DATA2* ed2 = NULL;
 
         if (tp2->item->size < sizeof(EXTENT_DATA)) {
-            ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
+            ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
                 tp2->item->size, sizeof(EXTENT_DATA));
             return STATUS_INTERNAL_ERROR;
         }
@@ -2724,7 +2724,7 @@ static NTSTATUS send_extent_data(send_context* context, traverse_ptr* tp, traver
 
         if (ed->type == EXTENT_TYPE_REGULAR) {
             if (tp2->item->size < offsetof(EXTENT_DATA, data[0]) + sizeof(EXTENT_DATA2)) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
                     tp2->item->size, offsetof(EXTENT_DATA, data[0]) + sizeof(EXTENT_DATA2));
                 return STATUS_INTERNAL_ERROR;
             }
@@ -2732,7 +2732,7 @@ static NTSTATUS send_extent_data(send_context* context, traverse_ptr* tp, traver
             ed2 = (EXTENT_DATA2*)ed->data;
         } else if (ed->type == EXTENT_TYPE_INLINE) {
             if (tp2->item->size < offsetof(EXTENT_DATA, data[0]) + ed->decoded_size) {
-                ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
+                ERR("(%I64x,%x,%I64x) was %u bytes, expected %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
                     tp2->item->size, offsetof(EXTENT_DATA, data[0]) + ed->decoded_size);
                 return STATUS_INTERNAL_ERROR;
             }
@@ -2757,11 +2757,11 @@ static NTSTATUS send_extent_data(send_context* context, traverse_ptr* tp, traver
 }
 
 typedef struct {
-    UINT16 namelen;
+    uint16_t namelen;
     char* name;
-    UINT16 value1len;
+    uint16_t value1len;
     char* value1;
-    UINT16 value2len;
+    uint16_t value2len;
     char* value2;
     LIST_ENTRY list_entry;
 } xattr_cmp;
@@ -2782,13 +2782,13 @@ static NTSTATUS send_xattr(send_context* context, traverse_ptr* tp, traverse_ptr
     }
 
     if (tp && tp->item->size < sizeof(DIR_ITEM)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset,
             tp->item->size, sizeof(DIR_ITEM));
         return STATUS_INTERNAL_ERROR;
     }
 
     if (tp2 && tp2->item->size < sizeof(DIR_ITEM)) {
-        ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
+        ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset,
             tp2->item->size, sizeof(DIR_ITEM));
         return STATUS_INTERNAL_ERROR;
     }
@@ -2804,13 +2804,13 @@ static NTSTATUS send_xattr(send_context* context, traverse_ptr* tp, traverse_ptr
             ULONG pos;
 
             if (len < sizeof(DIR_ITEM) || len < offsetof(DIR_ITEM, name[0]) + di->m + di->n) {
-                ERR("(%llx,%x,%llx) was truncated\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset);
+                ERR("(%I64x,%x,%I64x) was truncated\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset);
                 return STATUS_INTERNAL_ERROR;
             }
 
             pos = context->datalen;
             send_command(context, BTRFS_SEND_CMD_SET_XATTR);
-            send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (UINT16)strlen(context->lastinode.path) : 0);
+            send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (uint16_t)strlen(context->lastinode.path) : 0);
             send_add_tlv(context, BTRFS_SEND_TLV_XATTR_NAME, di->name, di->n);
             send_add_tlv(context, BTRFS_SEND_TLV_XATTR_DATA, &di->name[di->n], di->m);
             send_command_finish(context, pos);
@@ -2829,13 +2829,13 @@ static NTSTATUS send_xattr(send_context* context, traverse_ptr* tp, traverse_ptr
             ULONG pos;
 
             if (len < sizeof(DIR_ITEM) || len < offsetof(DIR_ITEM, name[0]) + di->m + di->n) {
-                ERR("(%llx,%x,%llx) was truncated\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset);
+                ERR("(%I64x,%x,%I64x) was truncated\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset);
                 return STATUS_INTERNAL_ERROR;
             }
 
             pos = context->datalen;
             send_command(context, BTRFS_SEND_CMD_REMOVE_XATTR);
-            send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (UINT16)strlen(context->lastinode.path) : 0);
+            send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (uint16_t)strlen(context->lastinode.path) : 0);
             send_add_tlv(context, BTRFS_SEND_TLV_XATTR_NAME, di->name, di->n);
             send_command_finish(context, pos);
 
@@ -2856,7 +2856,7 @@ static NTSTATUS send_xattr(send_context* context, traverse_ptr* tp, traverse_ptr
             xattr_cmp* xa;
 
             if (len < sizeof(DIR_ITEM) || len < offsetof(DIR_ITEM, name[0]) + di->m + di->n) {
-                ERR("(%llx,%x,%llx) was truncated\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset);
+                ERR("(%I64x,%x,%I64x) was truncated\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset);
                 return STATUS_INTERNAL_ERROR;
             }
 
@@ -2890,10 +2890,10 @@ static NTSTATUS send_xattr(send_context* context, traverse_ptr* tp, traverse_ptr
         do {
             xattr_cmp* xa;
             LIST_ENTRY* le;
-            BOOL found = FALSE;
+            bool found = false;
 
             if (len < sizeof(DIR_ITEM) || len < offsetof(DIR_ITEM, name[0]) + di->m + di->n) {
-                ERR("(%llx,%x,%llx) was truncated\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset);
+                ERR("(%I64x,%x,%I64x) was truncated\n", tp2->item->key.obj_id, tp2->item->key.obj_type, tp2->item->key.offset);
                 return STATUS_INTERNAL_ERROR;
             }
 
@@ -2904,7 +2904,7 @@ static NTSTATUS send_xattr(send_context* context, traverse_ptr* tp, traverse_ptr
                 if (xa->namelen == di->n && RtlCompareMemory(xa->name, di->name, di->n) == di->n) {
                     xa->value2len = di->m;
                     xa->value2 = di->name + di->n;
-                    found = TRUE;
+                    found = true;
                     break;
                 }
 
@@ -2946,13 +2946,13 @@ static NTSTATUS send_xattr(send_context* context, traverse_ptr* tp, traverse_ptr
                 if (!xa->value1) {
                     pos = context->datalen;
                     send_command(context, BTRFS_SEND_CMD_REMOVE_XATTR);
-                    send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (UINT16)strlen(context->lastinode.path) : 0);
+                    send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (uint16_t)strlen(context->lastinode.path) : 0);
                     send_add_tlv(context, BTRFS_SEND_TLV_XATTR_NAME, xa->name, xa->namelen);
                     send_command_finish(context, pos);
                 } else {
                     pos = context->datalen;
                     send_command(context, BTRFS_SEND_CMD_SET_XATTR);
-                    send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (UINT16)strlen(context->lastinode.path) : 0);
+                    send_add_tlv(context, BTRFS_SEND_TLV_PATH, context->lastinode.path, context->lastinode.path ? (uint16_t)strlen(context->lastinode.path) : 0);
                     send_add_tlv(context, BTRFS_SEND_TLV_XATTR_NAME, xa->name, xa->namelen);
                     send_add_tlv(context, BTRFS_SEND_TLV_XATTR_DATA, xa->value1, xa->value1len);
                     send_command_finish(context, pos);
@@ -2967,11 +2967,7 @@ static NTSTATUS send_xattr(send_context* context, traverse_ptr* tp, traverse_ptr
 }
 
 _Function_class_(KSTART_ROUTINE)
-#ifdef __REACTOS__
-static void NTAPI send_thread(void* ctx) {
-#else
-static void send_thread(void* ctx) {
-#endif
+static void __stdcall send_thread(void* ctx) {
     send_context* context = (send_context*)ctx;
     NTSTATUS Status;
     KEY searchkey;
@@ -2990,7 +2986,7 @@ static void send_thread(void* ctx) {
         }
     }
 
-    ExAcquireResourceExclusiveLite(&context->Vcb->tree_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&context->Vcb->tree_lock, true);
 
     flush_subvol_fcbs(context->root);
 
@@ -3015,7 +3011,7 @@ static void send_thread(void* ctx) {
     searchkey.obj_id = searchkey.offset = 0;
     searchkey.obj_type = 0;
 
-    Status = find_item(context->Vcb, context->root, &tp, &searchkey, FALSE, NULL);
+    Status = find_item(context->Vcb, context->root, &tp, &searchkey, false, NULL);
     if (!NT_SUCCESS(Status)) {
         ERR("find_item returned %08x\n", Status);
         ExReleaseResourceLite(&context->Vcb->tree_lock);
@@ -3023,8 +3019,8 @@ static void send_thread(void* ctx) {
     }
 
     if (context->parent) {
-        BOOL ended1 = FALSE, ended2 = FALSE;
-        Status = find_item(context->Vcb, context->parent, &tp2, &searchkey, FALSE, NULL);
+        bool ended1 = false, ended2 = false;
+        Status = find_item(context->Vcb, context->parent, &tp2, &searchkey, false, NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("find_item returned %08x\n", Status);
             ExReleaseResourceLite(&context->Vcb->tree_lock);
@@ -3040,16 +3036,16 @@ static void send_thread(void* ctx) {
                 ExReleaseResourceLite(&context->Vcb->tree_lock);
 
                 KeClearEvent(&context->send->cleared_event);
-                KeSetEvent(&context->buffer_event, 0, TRUE);
-                KeWaitForSingleObject(&context->send->cleared_event, Executive, KernelMode, FALSE, NULL);
+                KeSetEvent(&context->buffer_event, 0, true);
+                KeWaitForSingleObject(&context->send->cleared_event, Executive, KernelMode, false, NULL);
 
                 if (context->send->cancelling)
                     goto end;
 
-                ExAcquireResourceSharedLite(&context->Vcb->tree_lock, TRUE);
+                ExAcquireResourceSharedLite(&context->Vcb->tree_lock, true);
 
                 if (!ended1) {
-                    Status = find_item(context->Vcb, context->root, &tp, &key1, FALSE, NULL);
+                    Status = find_item(context->Vcb, context->root, &tp, &key1, false, NULL);
                     if (!NT_SUCCESS(Status)) {
                         ERR("find_item returned %08x\n", Status);
                         ExReleaseResourceLite(&context->Vcb->tree_lock);
@@ -3065,7 +3061,7 @@ static void send_thread(void* ctx) {
                 }
 
                 if (!ended2) {
-                    Status = find_item(context->Vcb, context->parent, &tp2, &key2, FALSE, NULL);
+                    Status = find_item(context->Vcb, context->parent, &tp2, &key2, false, NULL);
                     if (!NT_SUCCESS(Status)) {
                         ERR("find_item returned %08x\n", Status);
                         ExReleaseResourceLite(&context->Vcb->tree_lock);
@@ -3091,9 +3087,9 @@ static void send_thread(void* ctx) {
             }
 
             if (!ended1 && !ended2 && !keycmp(tp.item->key, tp2.item->key)) {
-                BOOL no_next = FALSE, no_next2 = FALSE;
+                bool no_next = false, no_next2 = false;
 
-                TRACE("~ %llx,%x,%llx\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                TRACE("~ %I64x,%x,%I64x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
 
                 if (context->lastinode.inode != 0 && tp.item->key.obj_id > context->lastinode.inode) {
                     Status = finish_inode(context, ended1 ? NULL : &tp, ended2 ? NULL : &tp2);
@@ -3111,11 +3107,11 @@ static void send_thread(void* ctx) {
 
                 if (tp.item->key.obj_type == TYPE_INODE_ITEM) {
                     if (tp.item->size == tp2.item->size && tp.item->size > 0 && RtlCompareMemory(tp.item->data, tp2.item->data, tp.item->size) == tp.item->size) {
-                        UINT64 inode = tp.item->key.obj_id;
+                        uint64_t inode = tp.item->key.obj_id;
 
-                        while (TRUE) {
-                            if (!find_next_item(context->Vcb, &tp, &next_tp, FALSE, NULL)) {
-                                ended1 = TRUE;
+                        while (true) {
+                            if (!find_next_item(context->Vcb, &tp, &next_tp, false, NULL)) {
+                                ended1 = true;
                                 break;
                             }
 
@@ -3125,9 +3121,9 @@ static void send_thread(void* ctx) {
                                 break;
                         }
 
-                        while (TRUE) {
-                            if (!find_next_item(context->Vcb, &tp2, &next_tp, FALSE, NULL)) {
-                                ended2 = TRUE;
+                        while (true) {
+                            if (!find_next_item(context->Vcb, &tp2, &next_tp, false, NULL)) {
+                                ended2 = true;
                                 break;
                             }
 
@@ -3137,9 +3133,9 @@ static void send_thread(void* ctx) {
                                 break;
                         }
 
-                        no_next = TRUE;
-                    } else if (tp.item->size > sizeof(UINT64) && tp2.item->size > sizeof(UINT64) && *(UINT64*)tp.item->data != *(UINT64*)tp2.item->data) {
-                        UINT64 inode = tp.item->key.obj_id;
+                        no_next = true;
+                    } else if (tp.item->size > sizeof(uint64_t) && tp2.item->size > sizeof(uint64_t) && *(uint64_t*)tp.item->data != *(uint64_t*)tp2.item->data) {
+                        uint64_t inode = tp.item->key.obj_id;
 
                         Status = send_inode(context, NULL, &tp2);
                         if (!NT_SUCCESS(Status)) {
@@ -3148,9 +3144,9 @@ static void send_thread(void* ctx) {
                             goto end;
                         }
 
-                        while (TRUE) {
-                            if (!find_next_item(context->Vcb, &tp2, &next_tp, FALSE, NULL)) {
-                                ended2 = TRUE;
+                        while (true) {
+                            if (!find_next_item(context->Vcb, &tp2, &next_tp, false, NULL)) {
+                                ended2 = true;
                                 break;
                             }
 
@@ -3160,14 +3156,14 @@ static void send_thread(void* ctx) {
                                 break;
 
                             if (tp2.item->key.obj_type == TYPE_INODE_REF) {
-                                Status = send_inode_ref(context, &tp2, TRUE);
+                                Status = send_inode_ref(context, &tp2, true);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("send_inode_ref returned %08x\n", Status);
                                     ExReleaseResourceLite(&context->Vcb->tree_lock);
                                     goto end;
                                 }
                             } else if (tp2.item->key.obj_type == TYPE_INODE_EXTREF) {
-                                Status = send_inode_extref(context, &tp2, TRUE);
+                                Status = send_inode_extref(context, &tp2, true);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("send_inode_extref returned %08x\n", Status);
                                     ExReleaseResourceLite(&context->Vcb->tree_lock);
@@ -3188,7 +3184,7 @@ static void send_thread(void* ctx) {
                             goto end;
                         }
 
-                        no_next2 = TRUE;
+                        no_next2 = true;
 
                         Status = send_inode(context, &tp, NULL);
                         if (!NT_SUCCESS(Status)) {
@@ -3205,28 +3201,28 @@ static void send_thread(void* ctx) {
                         }
                     }
                 } else if (tp.item->key.obj_type == TYPE_INODE_REF) {
-                    Status = send_inode_ref(context, &tp, FALSE);
+                    Status = send_inode_ref(context, &tp, false);
                     if (!NT_SUCCESS(Status)) {
                         ERR("send_inode_ref returned %08x\n", Status);
                         ExReleaseResourceLite(&context->Vcb->tree_lock);
                         goto end;
                     }
 
-                    Status = send_inode_ref(context, &tp2, TRUE);
+                    Status = send_inode_ref(context, &tp2, true);
                     if (!NT_SUCCESS(Status)) {
                         ERR("send_inode_ref returned %08x\n", Status);
                         ExReleaseResourceLite(&context->Vcb->tree_lock);
                         goto end;
                     }
                 } else if (tp.item->key.obj_type == TYPE_INODE_EXTREF) {
-                    Status = send_inode_extref(context, &tp, FALSE);
+                    Status = send_inode_extref(context, &tp, false);
                     if (!NT_SUCCESS(Status)) {
                         ERR("send_inode_extref returned %08x\n", Status);
                         ExReleaseResourceLite(&context->Vcb->tree_lock);
                         goto end;
                     }
 
-                    Status = send_inode_extref(context, &tp2, TRUE);
+                    Status = send_inode_extref(context, &tp2, true);
                     if (!NT_SUCCESS(Status)) {
                         ERR("send_inode_extref returned %08x\n", Status);
                         ExReleaseResourceLite(&context->Vcb->tree_lock);
@@ -3259,20 +3255,20 @@ static void send_thread(void* ctx) {
                 }
 
                 if (!no_next) {
-                    if (find_next_item(context->Vcb, &tp, &next_tp, FALSE, NULL))
+                    if (find_next_item(context->Vcb, &tp, &next_tp, false, NULL))
                         tp = next_tp;
                     else
-                        ended1 = TRUE;
+                        ended1 = true;
 
                     if (!no_next2) {
-                        if (find_next_item(context->Vcb, &tp2, &next_tp, FALSE, NULL))
+                        if (find_next_item(context->Vcb, &tp2, &next_tp, false, NULL))
                             tp2 = next_tp;
                         else
-                            ended2 = TRUE;
+                            ended2 = true;
                     }
                 }
             } else if (ended2 || (!ended1 && !ended2 && keycmp(tp.item->key, tp2.item->key) == -1)) {
-                TRACE("A %llx,%x,%llx\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
+                TRACE("A %I64x,%x,%I64x\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
 
                 if (context->lastinode.inode != 0 && tp.item->key.obj_id > context->lastinode.inode) {
                     Status = finish_inode(context, ended1 ? NULL : &tp, ended2 ? NULL : &tp2);
@@ -3296,14 +3292,14 @@ static void send_thread(void* ctx) {
                         goto end;
                     }
                 } else if (tp.item->key.obj_type == TYPE_INODE_REF) {
-                    Status = send_inode_ref(context, &tp, FALSE);
+                    Status = send_inode_ref(context, &tp, false);
                     if (!NT_SUCCESS(Status)) {
                         ERR("send_inode_ref returned %08x\n", Status);
                         ExReleaseResourceLite(&context->Vcb->tree_lock);
                         goto end;
                     }
                 } else if (tp.item->key.obj_type == TYPE_INODE_EXTREF) {
-                    Status = send_inode_extref(context, &tp, FALSE);
+                    Status = send_inode_extref(context, &tp, false);
                     if (!NT_SUCCESS(Status)) {
                         ERR("send_inode_extref returned %08x\n", Status);
                         ExReleaseResourceLite(&context->Vcb->tree_lock);
@@ -3335,12 +3331,12 @@ static void send_thread(void* ctx) {
                     }
                 }
 
-                if (find_next_item(context->Vcb, &tp, &next_tp, FALSE, NULL))
+                if (find_next_item(context->Vcb, &tp, &next_tp, false, NULL))
                     tp = next_tp;
                 else
-                    ended1 = TRUE;
+                    ended1 = true;
             } else if (ended1 || (!ended1 && !ended2 && keycmp(tp.item->key, tp2.item->key) == 1)) {
-                TRACE("B %llx,%x,%llx\n", tp2.item->key.obj_id, tp2.item->key.obj_type, tp2.item->key.offset);
+                TRACE("B %I64x,%x,%I64x\n", tp2.item->key.obj_id, tp2.item->key.obj_type, tp2.item->key.offset);
 
                 if (context->lastinode.inode != 0 && tp2.item->key.obj_id > context->lastinode.inode) {
                     Status = finish_inode(context, ended1 ? NULL : &tp, ended2 ? NULL : &tp2);
@@ -3364,14 +3360,14 @@ static void send_thread(void* ctx) {
                         goto end;
                     }
                 } else if (tp2.item->key.obj_type == TYPE_INODE_REF) {
-                    Status = send_inode_ref(context, &tp2, TRUE);
+                    Status = send_inode_ref(context, &tp2, true);
                     if (!NT_SUCCESS(Status)) {
                         ERR("send_inode_ref returned %08x\n", Status);
                         ExReleaseResourceLite(&context->Vcb->tree_lock);
                         goto end;
                     }
                 } else if (tp2.item->key.obj_type == TYPE_INODE_EXTREF) {
-                    Status = send_inode_extref(context, &tp2, TRUE);
+                    Status = send_inode_extref(context, &tp2, true);
                     if (!NT_SUCCESS(Status)) {
                         ERR("send_inode_extref returned %08x\n", Status);
                         ExReleaseResourceLite(&context->Vcb->tree_lock);
@@ -3403,10 +3399,10 @@ static void send_thread(void* ctx) {
                     }
                 }
 
-                if (find_next_item(context->Vcb, &tp2, &next_tp, FALSE, NULL))
+                if (find_next_item(context->Vcb, &tp2, &next_tp, false, NULL))
                     tp2 = next_tp;
                 else
-                    ended2 = TRUE;
+                    ended2 = true;
             }
         } while (!ended1 || !ended2);
     } else {
@@ -3419,15 +3415,15 @@ static void send_thread(void* ctx) {
                 ExReleaseResourceLite(&context->Vcb->tree_lock);
 
                 KeClearEvent(&context->send->cleared_event);
-                KeSetEvent(&context->buffer_event, 0, TRUE);
-                KeWaitForSingleObject(&context->send->cleared_event, Executive, KernelMode, FALSE, NULL);
+                KeSetEvent(&context->buffer_event, 0, true);
+                KeWaitForSingleObject(&context->send->cleared_event, Executive, KernelMode, false, NULL);
 
                 if (context->send->cancelling)
                     goto end;
 
-                ExAcquireResourceSharedLite(&context->Vcb->tree_lock, TRUE);
+                ExAcquireResourceSharedLite(&context->Vcb->tree_lock, true);
 
-                Status = find_item(context->Vcb, context->root, &tp, &key, FALSE, NULL);
+                Status = find_item(context->Vcb, context->root, &tp, &key, false, NULL);
                 if (!NT_SUCCESS(Status)) {
                     ERR("find_item returned %08x\n", Status);
                     ExReleaseResourceLite(&context->Vcb->tree_lock);
@@ -3464,14 +3460,14 @@ static void send_thread(void* ctx) {
                     goto end;
                 }
             } else if (tp.item->key.obj_type == TYPE_INODE_REF) {
-                Status = send_inode_ref(context, &tp, FALSE);
+                Status = send_inode_ref(context, &tp, false);
                 if (!NT_SUCCESS(Status)) {
                     ERR("send_inode_ref returned %08x\n", Status);
                     ExReleaseResourceLite(&context->Vcb->tree_lock);
                     goto end;
                 }
             } else if (tp.item->key.obj_type == TYPE_INODE_EXTREF) {
-                Status = send_inode_extref(context, &tp, FALSE);
+                Status = send_inode_extref(context, &tp, false);
                 if (!NT_SUCCESS(Status)) {
                     ERR("send_inode_extref returned %08x\n", Status);
                     ExReleaseResourceLite(&context->Vcb->tree_lock);
@@ -3503,11 +3499,11 @@ static void send_thread(void* ctx) {
                 }
             }
 
-            if (find_next_item(context->Vcb, &tp, &next_tp, FALSE, NULL))
+            if (find_next_item(context->Vcb, &tp, &next_tp, false, NULL))
                 tp = next_tp;
             else
                 break;
-        } while (TRUE);
+        } while (true);
     }
 
     if (context->lastinode.inode != 0) {
@@ -3526,20 +3522,20 @@ static void send_thread(void* ctx) {
         ExReleaseResourceLite(&context->Vcb->tree_lock);
 
     KeClearEvent(&context->send->cleared_event);
-    KeSetEvent(&context->buffer_event, 0, TRUE);
-    KeWaitForSingleObject(&context->send->cleared_event, Executive, KernelMode, FALSE, NULL);
+    KeSetEvent(&context->buffer_event, 0, true);
+    KeWaitForSingleObject(&context->send->cleared_event, Executive, KernelMode, false, NULL);
 
     Status = STATUS_SUCCESS;
 
 end:
     if (!NT_SUCCESS(Status)) {
-        KeSetEvent(&context->buffer_event, 0, FALSE);
+        KeSetEvent(&context->buffer_event, 0, false);
 
         if (context->send->ccb)
             context->send->ccb->send_status = Status;
     }
 
-    ExAcquireResourceExclusiveLite(&context->Vcb->send_load_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&context->Vcb->send_load_lock, true);
 
     while (!IsListEmpty(&context->orphans)) {
         orphan* o = CONTAINING_RECORD(RemoveHeadList(&context->orphans), orphan, list_entry);
@@ -3634,7 +3630,7 @@ NTSTATUS send_subvol(device_extension* Vcb, void* data, ULONG datalen, PFILE_OBJ
             if (datalen >= offsetof(btrfs_send_subvol32, clones[0]))
                 num_clones = bss32->num_clones;
 
-            if (datalen < offsetof(btrfs_send_subvol32, clones[0]) + (num_clones * sizeof(UINT32)))
+            if (datalen < offsetof(btrfs_send_subvol32, clones[0]) + (num_clones * sizeof(uint32_t)))
                 return STATUS_INVALID_PARAMETER;
         } else {
 #endif
@@ -3739,7 +3735,7 @@ NTSTATUS send_subvol(device_extension* Vcb, void* data, ULONG datalen, PFILE_OBJ
         }
     }
 
-    ExAcquireResourceExclusiveLite(&Vcb->send_load_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->send_load_lock, true);
 
     if (ccb->send) {
         WARN("send operation already running\n");
@@ -3786,7 +3782,7 @@ NTSTATUS send_subvol(device_extension* Vcb, void* data, ULONG datalen, PFILE_OBJ
 
     send_subvol_header(context, fcb->subvol, ccb->fileref); // FIXME - fileref needs some sort of lock here
 
-    KeInitializeEvent(&context->buffer_event, NotificationEvent, FALSE);
+    KeInitializeEvent(&context->buffer_event, NotificationEvent, false);
 
     send = ExAllocatePoolWithTag(NonPagedPool, sizeof(send_info), ALLOC_TAG);
     if (!send) {
@@ -3801,7 +3797,7 @@ NTSTATUS send_subvol(device_extension* Vcb, void* data, ULONG datalen, PFILE_OBJ
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    KeInitializeEvent(&send->cleared_event, NotificationEvent, FALSE);
+    KeInitializeEvent(&send->cleared_event, NotificationEvent, false);
 
     send->context = context;
     context->send = send;
@@ -3810,7 +3806,7 @@ NTSTATUS send_subvol(device_extension* Vcb, void* data, ULONG datalen, PFILE_OBJ
     send->ccb = ccb;
     ccb->send_status = STATUS_SUCCESS;
 
-    send->cancelling = FALSE;
+    send->cancelling = false;
 
     InterlockedIncrement(&Vcb->running_sends);
 
@@ -3847,7 +3843,7 @@ NTSTATUS read_send_buffer(device_extension* Vcb, PFILE_OBJECT FileObject, void*
     if (!SeSinglePrivilegeCheck(RtlConvertLongToLuid(SE_MANAGE_VOLUME_PRIVILEGE), processor_mode))
         return STATUS_PRIVILEGE_NOT_HELD;
 
-    ExAcquireResourceExclusiveLite(&Vcb->send_load_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&Vcb->send_load_lock, true);
 
     if (!ccb->send) {
         ExReleaseResourceLite(&Vcb->send_load_lock);
@@ -3856,7 +3852,7 @@ NTSTATUS read_send_buffer(device_extension* Vcb, PFILE_OBJECT FileObject, void*
 
     context = (send_context*)ccb->send->context;
 
-    KeWaitForSingleObject(&context->buffer_event, Executive, KernelMode, FALSE, NULL);
+    KeWaitForSingleObject(&context->buffer_event, Executive, KernelMode, false, NULL);
 
     if (datalen == 0) {
         ExReleaseResourceLite(&Vcb->send_load_lock);
@@ -3876,7 +3872,7 @@ NTSTATUS read_send_buffer(device_extension* Vcb, PFILE_OBJECT FileObject, void*
         ExReleaseResourceLite(&Vcb->send_load_lock);
 
         KeClearEvent(&context->buffer_event);
-        KeSetEvent(&ccb->send->cleared_event, 0, FALSE);
+        KeSetEvent(&ccb->send->cleared_event, 0, false);
     }
 
     return STATUS_SUCCESS;
diff --git a/drivers/filesystems/btrfs/treefuncs.c b/drivers/filesystems/btrfs/treefuncs.c
index 0283386bd38..100553b942b 100644
--- a/drivers/filesystems/btrfs/treefuncs.c
+++ b/drivers/filesystems/btrfs/treefuncs.c
@@ -17,12 +17,12 @@
 
 #include "btrfs_drv.h"
 
-NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, UINT8* buf, root* r, tree** pt) {
+NTSTATUS load_tree(device_extension* Vcb, uint64_t addr, uint8_t* buf, root* r, tree** pt) {
     tree_header* th;
     tree* t;
     tree_data* td;
-    UINT8 h;
-    BOOL inserted;
+    uint8_t h;
+    bool inserted;
     LIST_ENTRY* le;
 
     th = (tree_header*)buf;
@@ -46,18 +46,18 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, UINT8* buf, root* r, tree
         t->nonpaged = NULL;
 
     RtlCopyMemory(&t->header, th, sizeof(tree_header));
-    t->hash = calc_crc32c(0xffffffff, (UINT8*)&addr, sizeof(UINT64));
-    t->has_address = TRUE;
+    t->hash = calc_crc32c(0xffffffff, (uint8_t*)&addr, sizeof(uint64_t));
+    t->has_address = true;
     t->Vcb = Vcb;
     t->parent = NULL;
     t->root = r;
     t->paritem = NULL;
     t->size = 0;
     t->new_address = 0;
-    t->has_new_address = FALSE;
-    t->updated_extents = FALSE;
-    t->write = FALSE;
-    t->uniqueness_determined = FALSE;
+    t->has_new_address = false;
+    t->updated_extents = false;
+    t->write = false;
+    t->uniqueness_determined = false;
 
     InitializeListHead(&t->itemlist);
 
@@ -66,7 +66,7 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, UINT8* buf, root* r, tree
         unsigned int i;
 
         if ((t->header.num_items * sizeof(leaf_node)) + sizeof(tree_header) > Vcb->superblock.node_size) {
-            ERR("tree at %llx has more items than expected (%x)\n", t->header.num_items);
+            ERR("tree at %I64x has more items than expected (%x)\n", t->header.num_items);
             ExFreePool(t);
             return STATUS_INSUFFICIENT_RESOURCES;
         }
@@ -87,15 +87,15 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, UINT8* buf, root* r, tree
                 td->data = NULL;
 
             if (ln[i].size + sizeof(tree_header) + sizeof(leaf_node) > Vcb->superblock.node_size) {
-                ERR("overlarge item in tree %llx: %u > %u\n", addr, ln[i].size, Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node));
+                ERR("overlarge item in tree %I64x: %u > %u\n", addr, ln[i].size, Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node));
                 ExFreeToPagedLookasideList(&t->Vcb->tree_data_lookaside, td);
                 ExFreePool(t);
                 return STATUS_INTERNAL_ERROR;
             }
 
-            td->size = (UINT16)ln[i].size;
-            td->ignore = FALSE;
-            td->inserted = FALSE;
+            td->size = (uint16_t)ln[i].size;
+            td->ignore = false;
+            td->inserted = false;
 
             InsertTailList(&t->itemlist, &td->list_entry);
 
@@ -109,7 +109,7 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, UINT8* buf, root* r, tree
         unsigned int i;
 
         if ((t->header.num_items * sizeof(internal_node)) + sizeof(tree_header) > Vcb->superblock.node_size) {
-            ERR("tree at %llx has more items than expected (%x)\n", t->header.num_items);
+            ERR("tree at %I64x has more items than expected (%x)\n", t->header.num_items);
             ExFreePool(t);
             return STATUS_INSUFFICIENT_RESOURCES;
         }
@@ -127,8 +127,8 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, UINT8* buf, root* r, tree
             td->treeholder.address = in[i].address;
             td->treeholder.generation = in[i].generation;
             td->treeholder.tree = NULL;
-            td->ignore = FALSE;
-            td->inserted = FALSE;
+            td->ignore = false;
+            td->inserted = false;
 
             InsertTailList(&t->itemlist, &td->list_entry);
         }
@@ -144,7 +144,7 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, UINT8* buf, root* r, tree
     h = t->hash >> 24;
 
     if (!Vcb->trees_ptrs[h]) {
-        UINT8 h2 = h;
+        uint8_t h2 = h;
 
         le = Vcb->trees_hash.Flink;
 
@@ -162,13 +162,13 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, UINT8* buf, root* r, tree
     } else
         le = Vcb->trees_ptrs[h];
 
-    inserted = FALSE;
+    inserted = false;
     while (le != &Vcb->trees_hash) {
         tree* t2 = CONTAINING_RECORD(le, tree, list_entry_hash);
 
         if (t2->hash >= t->hash) {
             InsertHeadList(le->Blink, &t->list_entry_hash);
-            inserted = TRUE;
+            inserted = true;
             break;
         }
 
@@ -190,7 +190,7 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, UINT8* buf, root* r, tree
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS do_load_tree2(device_extension* Vcb, tree_holder* th, UINT8* buf, root* r, tree* t, tree_data* td) {
+static NTSTATUS do_load_tree2(device_extension* Vcb, tree_holder* th, uint8_t* buf, root* r, tree* t, tree_data* td) {
     if (!th->tree) {
         NTSTATUS Status;
         tree* nt;
@@ -217,7 +217,7 @@ static NTSTATUS do_load_tree2(device_extension* Vcb, tree_holder* th, UINT8* buf
 
 NTSTATUS do_load_tree(device_extension* Vcb, tree_holder* th, root* r, tree* t, tree_data* td, PIRP Irp) {
     NTSTATUS Status;
-    UINT8* buf;
+    uint8_t* buf;
     chunk* c;
 
     buf = ExAllocatePoolWithTag(PagedPool, Vcb->superblock.node_size, ALLOC_TAG);
@@ -226,8 +226,8 @@ NTSTATUS do_load_tree(device_extension* Vcb, tree_holder* th, root* r, tree* t,
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    Status = read_data(Vcb, th->address, Vcb->superblock.node_size, NULL, TRUE, buf, NULL,
-                       &c, Irp, th->generation, FALSE, NormalPagePriority);
+    Status = read_data(Vcb, th->address, Vcb->superblock.node_size, NULL, true, buf, NULL,
+                       &c, Irp, th->generation, false, NormalPagePriority);
     if (!NT_SUCCESS(Status)) {
         ERR("read_data returned 0x%08x\n", Status);
         ExFreePool(buf);
@@ -237,7 +237,7 @@ NTSTATUS do_load_tree(device_extension* Vcb, tree_holder* th, root* r, tree* t,
     if (t)
         ExAcquireFastMutex(&t->nonpaged->mutex);
     else
-        ExAcquireResourceExclusiveLite(&r->nonpaged->load_tree_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&r->nonpaged->load_tree_lock, true);
 
     Status = do_load_tree2(Vcb, th, buf, r, t, td);
 
@@ -288,7 +288,7 @@ void free_tree(tree* t) {
         r->treeholder.tree = NULL;
 
     if (t->list_entry_hash.Flink) {
-        UINT8 h = t->hash >> 24;
+        uint8_t h = t->hash >> 24;
         if (t->Vcb->trees_ptrs[h] == &t->list_entry_hash) {
             if (t->list_entry_hash.Flink != &t->Vcb->trees_hash) {
                 tree* t2 = CONTAINING_RECORD(t->list_entry_hash.Flink, tree, list_entry_hash);
@@ -362,10 +362,10 @@ static NTSTATUS next_item2(device_extension* Vcb, tree* t, tree_data* td, traver
 
     td2 = next_item(t2, td2);
 
-    return find_item_to_level(Vcb, t2->root, tp, &td2->key, FALSE, t->header.level, NULL);
+    return find_item_to_level(Vcb, t2->root, tp, &td2->key, false, t->header.level, NULL);
 }
 
-NTSTATUS skip_to_difference(device_extension* Vcb, traverse_ptr* tp, traverse_ptr* tp2, BOOL* ended1, BOOL* ended2) {
+NTSTATUS skip_to_difference(device_extension* Vcb, traverse_ptr* tp, traverse_ptr* tp2, bool* ended1, bool* ended2) {
     NTSTATUS Status;
     tree *t1, *t2;
     tree_data *td1, *td2;
@@ -380,12 +380,12 @@ NTSTATUS skip_to_difference(device_extension* Vcb, traverse_ptr* tp, traverse_pt
         t2 = t2->parent;
     } while (t1 && t2 && t1->header.address == t2->header.address);
 
-    while (TRUE) {
+    while (true) {
         traverse_ptr tp3, tp4;
 
         Status = next_item2(Vcb, t1, td1, &tp3);
         if (Status == STATUS_NOT_FOUND)
-            *ended1 = TRUE;
+            *ended1 = true;
         else if (!NT_SUCCESS(Status)) {
             ERR("next_item2 returned %08x\n", Status);
             return Status;
@@ -393,7 +393,7 @@ NTSTATUS skip_to_difference(device_extension* Vcb, traverse_ptr* tp, traverse_pt
 
         Status = next_item2(Vcb, t2, td2, &tp4);
         if (Status == STATUS_NOT_FOUND)
-            *ended2 = TRUE;
+            *ended2 = true;
         else if (!NT_SUCCESS(Status)) {
             ERR("next_item2 returned %08x\n", Status);
             return Status;
@@ -401,13 +401,13 @@ NTSTATUS skip_to_difference(device_extension* Vcb, traverse_ptr* tp, traverse_pt
 
         if (*ended1 || *ended2) {
             if (!*ended1) {
-                Status = find_item(Vcb, t1->root, tp, &tp3.item->key, FALSE, NULL);
+                Status = find_item(Vcb, t1->root, tp, &tp3.item->key, false, NULL);
                 if (!NT_SUCCESS(Status)) {
                     ERR("find_item returned %08x\n", Status);
                     return Status;
                 }
             } else if (!*ended2) {
-                Status = find_item(Vcb, t2->root, tp2, &tp4.item->key, FALSE, NULL);
+                Status = find_item(Vcb, t2->root, tp2, &tp4.item->key, false, NULL);
                 if (!NT_SUCCESS(Status)) {
                     ERR("find_item returned %08x\n", Status);
                     return Status;
@@ -418,13 +418,13 @@ NTSTATUS skip_to_difference(device_extension* Vcb, traverse_ptr* tp, traverse_pt
         }
 
         if (tp3.tree->header.address != tp4.tree->header.address) {
-            Status = find_item(Vcb, t1->root, tp, &tp3.item->key, FALSE, NULL);
+            Status = find_item(Vcb, t1->root, tp, &tp3.item->key, false, NULL);
             if (!NT_SUCCESS(Status)) {
                 ERR("find_item returned %08x\n", Status);
                 return Status;
             }
 
-            Status = find_item(Vcb, t2->root, tp2, &tp4.item->key, FALSE, NULL);
+            Status = find_item(Vcb, t2->root, tp2, &tp4.item->key, false, NULL);
             if (!NT_SUCCESS(Status)) {
                 ERR("find_item returned %08x\n", Status);
                 return Status;
@@ -440,7 +440,7 @@ NTSTATUS skip_to_difference(device_extension* Vcb, traverse_ptr* tp, traverse_pt
     }
 }
 
-static NTSTATUS find_item_in_tree(device_extension* Vcb, tree* t, traverse_ptr* tp, const KEY* searchkey, BOOL ignore, UINT8 level, PIRP Irp) {
+static NTSTATUS find_item_in_tree(device_extension* Vcb, tree* t, traverse_ptr* tp, const KEY* searchkey, bool ignore, uint8_t level, PIRP Irp) {
     int cmp;
     tree_data *td, *lasttd;
     KEY key2;
@@ -501,7 +501,7 @@ static NTSTATUS find_item_in_tree(device_extension* Vcb, tree* t, traverse_ptr*
             oldtp.tree = t;
             oldtp.item = td;
 
-            while (find_next_item(Vcb, &oldtp, tp, TRUE, Irp)) {
+            while (find_next_item(Vcb, &oldtp, tp, true, Irp)) {
                 if (!tp->item->ignore)
                     return STATUS_SUCCESS;
 
@@ -546,7 +546,7 @@ static NTSTATUS find_item_in_tree(device_extension* Vcb, tree* t, traverse_ptr*
 }
 
 NTSTATUS find_item(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _Out_ traverse_ptr* tp,
-                   _In_ const KEY* searchkey, _In_ BOOL ignore, _In_opt_ PIRP Irp) {
+                   _In_ const KEY* searchkey, _In_ bool ignore, _In_opt_ PIRP Irp) {
     NTSTATUS Status;
 
     if (!r->treeholder.tree) {
@@ -565,7 +565,7 @@ NTSTATUS find_item(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension
     return Status;
 }
 
-NTSTATUS find_item_to_level(device_extension* Vcb, root* r, traverse_ptr* tp, const KEY* searchkey, BOOL ignore, UINT8 level, PIRP Irp) {
+NTSTATUS find_item_to_level(device_extension* Vcb, root* r, traverse_ptr* tp, const KEY* searchkey, bool ignore, uint8_t level, PIRP Irp) {
     NTSTATUS Status;
 
     if (!r->treeholder.tree) {
@@ -589,7 +589,7 @@ NTSTATUS find_item_to_level(device_extension* Vcb, root* r, traverse_ptr* tp, co
     return Status;
 }
 
-BOOL find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, const traverse_ptr* tp, traverse_ptr* next_tp, BOOL ignore, PIRP Irp) {
+bool find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, const traverse_ptr* tp, traverse_ptr* next_tp, bool ignore, PIRP Irp) {
     tree* t;
     tree_data *td = NULL, *next;
     NTSTATUS Status;
@@ -612,11 +612,11 @@ BOOL find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
         }
 #endif
 
-        return TRUE;
+        return true;
     }
 
     if (!tp->tree->parent)
-        return FALSE;
+        return false;
 
     t = tp->tree;
     do {
@@ -630,13 +630,13 @@ BOOL find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
     } while (t);
 
     if (!t)
-        return FALSE;
+        return false;
 
     if (!td->treeholder.tree) {
         Status = do_load_tree(Vcb, &td->treeholder, t->parent->root, t->parent, td, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("do_load_tree returned %08x\n", Status);
-            return FALSE;
+            return false;
         }
     }
 
@@ -651,7 +651,7 @@ BOOL find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
             Status = do_load_tree(Vcb, &fi->treeholder, t->parent->root, t, fi, Irp);
             if (!NT_SUCCESS(Status)) {
                 ERR("do_load_tree returned %08x\n", Status);
-                return FALSE;
+                return false;
             }
         }
 
@@ -663,9 +663,9 @@ BOOL find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
 
     if (!ignore && next_tp->item->ignore) {
         traverse_ptr ntp2;
-        BOOL b;
+        bool b;
 
-        while ((b = find_next_item(Vcb, next_tp, &ntp2, TRUE, Irp))) {
+        while ((b = find_next_item(Vcb, next_tp, &ntp2, true, Irp))) {
             *next_tp = ntp2;
 
             if (!next_tp->item->ignore)
@@ -673,7 +673,7 @@ BOOL find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
         }
 
         if (!b)
-            return FALSE;
+            return false;
     }
 
 #ifdef DEBUG_PARANOID
@@ -683,7 +683,7 @@ BOOL find_next_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
     }
 #endif
 
-    return TRUE;
+    return true;
 }
 
 static __inline tree_data* last_item(tree* t) {
@@ -695,7 +695,7 @@ static __inline tree_data* last_item(tree* t) {
     return CONTAINING_RECORD(le, tree_data, list_entry);
 }
 
-BOOL find_prev_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, const traverse_ptr* tp, traverse_ptr* prev_tp, PIRP Irp) {
+bool find_prev_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, const traverse_ptr* tp, traverse_ptr* prev_tp, PIRP Irp) {
     tree* t;
     tree_data* td;
     NTSTATUS Status;
@@ -705,11 +705,11 @@ BOOL find_prev_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
         prev_tp->tree = tp->tree;
         prev_tp->item = prev_item(tp->tree, tp->item);
 
-        return TRUE;
+        return true;
     }
 
     if (!tp->tree->parent)
-        return FALSE;
+        return false;
 
     t = tp->tree;
     while (t && (!t->parent || !prev_item(t->parent, t->paritem))) {
@@ -717,7 +717,7 @@ BOOL find_prev_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
     }
 
     if (!t)
-        return FALSE;
+        return false;
 
     td = prev_item(t->parent, t->paritem);
 
@@ -725,7 +725,7 @@ BOOL find_prev_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
         Status = do_load_tree(Vcb, &td->treeholder, t->parent->root, t->parent, td, Irp);
         if (!NT_SUCCESS(Status)) {
             ERR("do_load_tree returned %08x\n", Status);
-            return FALSE;
+            return false;
         }
     }
 
@@ -740,7 +740,7 @@ BOOL find_prev_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
             Status = do_load_tree(Vcb, &li->treeholder, t->parent->root, t, li, Irp);
             if (!NT_SUCCESS(Status)) {
                 ERR("do_load_tree returned %08x\n", Status);
-                return FALSE;
+                return false;
             }
         }
 
@@ -750,7 +750,7 @@ BOOL find_prev_item(_Requires_lock_held_(_Curr_->tree_lock) device_extension* Vc
     prev_tp->tree = t;
     prev_tp->item = last_item(t);
 
-    return TRUE;
+    return true;
 }
 
 void free_trees_root(device_extension* Vcb, root* r) {
@@ -758,7 +758,7 @@ void free_trees_root(device_extension* Vcb, root* r) {
     ULONG level;
 
     for (level = 0; level <= 255; level++) {
-        BOOL empty = TRUE;
+        bool empty = true;
 
         le = Vcb->trees.Flink;
 
@@ -768,9 +768,9 @@ void free_trees_root(device_extension* Vcb, root* r) {
 
             if (t->root == r) {
                 if (t->header.level == level) {
-                    BOOL top = !t->paritem;
+                    bool top = !t->paritem;
 
-                    empty = FALSE;
+                    empty = false;
 
                     free_tree(t);
                     if (top && r->treeholder.tree == t)
@@ -779,7 +779,7 @@ void free_trees_root(device_extension* Vcb, root* r) {
                     if (IsListEmpty(&Vcb->trees))
                         return;
                 } else if (t->header.level > level)
-                    empty = FALSE;
+                    empty = false;
             }
 
             le = nextle;
@@ -795,7 +795,7 @@ void free_trees(device_extension* Vcb) {
     ULONG level;
 
     for (level = 0; level <= 255; level++) {
-        BOOL empty = TRUE;
+        bool empty = true;
 
         le = Vcb->trees.Flink;
 
@@ -805,9 +805,9 @@ void free_trees(device_extension* Vcb) {
             root* r = t->root;
 
             if (t->header.level == level) {
-                BOOL top = !t->paritem;
+                bool top = !t->paritem;
 
-                empty = FALSE;
+                empty = false;
 
                 free_tree(t);
                 if (top && r->treeholder.tree == t)
@@ -816,7 +816,7 @@ void free_trees(device_extension* Vcb) {
                 if (IsListEmpty(&Vcb->trees))
                     return;
             } else if (t->header.level > level)
-                empty = FALSE;
+                empty = false;
 
             le = nextle;
         }
@@ -854,9 +854,9 @@ void add_rollback(_In_ LIST_ENTRY* rollback, _In_ enum rollback_type type, _In_
 #pragma warning(push)
 #pragma warning(suppress: 28194)
 #endif
-NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _In_ UINT64 obj_id,
-                          _In_ UINT8 obj_type, _In_ UINT64 offset, _In_reads_bytes_opt_(size) _When_(return >= 0, __drv_aliasesMem) void* data,
-                          _In_ UINT16 size, _Out_opt_ traverse_ptr* ptp, _In_opt_ PIRP Irp) {
+NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _In_ uint64_t obj_id,
+                          _In_ uint8_t obj_type, _In_ uint64_t offset, _In_reads_bytes_opt_(size) _When_(return >= 0, __drv_aliasesMem) void* data,
+                          _In_ uint16_t size, _Out_opt_ traverse_ptr* ptp, _In_opt_ PIRP Irp) {
     traverse_ptr tp;
     KEY searchkey;
     int cmp;
@@ -868,13 +868,13 @@ NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock)
 #endif
     NTSTATUS Status;
 
-    TRACE("(%p, %p, %llx, %x, %llx, %p, %x, %p)\n", Vcb, r, obj_id, obj_type, offset, data, size, ptp);
+    TRACE("(%p, %p, %I64x, %x, %I64x, %p, %x, %p)\n", Vcb, r, obj_id, obj_type, offset, data, size, ptp);
 
     searchkey.obj_id = obj_id;
     searchkey.obj_type = obj_type;
     searchkey.offset = offset;
 
-    Status = find_item(Vcb, r, &tp, &searchkey, TRUE, Irp);
+    Status = find_item(Vcb, r, &tp, &searchkey, true, Irp);
     if (Status == STATUS_NOT_FOUND) {
         if (r) {
             if (!r->treeholder.tree) {
@@ -889,7 +889,7 @@ NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock)
                 tp.tree = r->treeholder.tree;
                 tp.item = NULL;
             } else {
-                ERR("error: unable to load tree for root %llx\n", r->id);
+                ERR("error: unable to load tree for root %I64x\n", r->id);
                 return STATUS_INTERNAL_ERROR;
             }
         } else {
@@ -908,7 +908,7 @@ NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock)
         cmp = keycmp(searchkey, tp.item->key);
 
         if (cmp == 0 && !tp.item->ignore) {
-            ERR("error: key (%llx,%x,%llx) already present\n", obj_id, obj_type, offset);
+            ERR("error: key (%I64x,%x,%I64x) already present\n", obj_id, obj_type, offset);
 #ifdef DEBUG_PARANOID
             int3;
 #endif
@@ -926,8 +926,8 @@ NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock)
     td->key = searchkey;
     td->size = size;
     td->data = data;
-    td->ignore = FALSE;
-    td->inserted = TRUE;
+    td->ignore = false;
+    td->inserted = true;
 
 #ifdef _DEBUG
     le = tp.tree->itemlist.Flink;
@@ -937,7 +937,7 @@ NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock)
         break;
     }
 
-    TRACE("inserting %llx,%x,%llx into tree beginning %llx,%x,%llx (num_items %x)\n", obj_id, obj_type, offset, firstitem.obj_id, firstitem.obj_type, firstitem.offset, tp.tree->header.num_items);
+    TRACE("inserting %I64x,%x,%I64x into tree beginning %I64x,%x,%I64x (num_items %x)\n", obj_id, obj_type, offset, firstitem.obj_id, firstitem.obj_type, firstitem.offset, tp.tree->header.num_items);
 #endif
 
     if (cmp == -1) { // very first key in root
@@ -961,8 +961,8 @@ NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock)
     tp.tree->size += size + sizeof(leaf_node);
 
     if (!tp.tree->write) {
-        tp.tree->write = TRUE;
-        Vcb->need_write = TRUE;
+        tp.tree->write = true;
+        Vcb->need_write = true;
     }
 
     if (ptp)
@@ -971,7 +971,7 @@ NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock)
     t = tp.tree;
     while (t) {
         if (t->paritem && t->paritem->ignore) {
-            t->paritem->ignore = FALSE;
+            t->paritem->ignore = false;
             t->parent->header.num_items++;
             t->parent->size += sizeof(internal_node);
         }
@@ -988,23 +988,23 @@ NTSTATUS insert_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock)
 
 NTSTATUS delete_tree_item(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _Inout_ traverse_ptr* tp) {
     tree* t;
-    UINT64 gen;
+    uint64_t gen;
 
-    TRACE("deleting item %llx,%x,%llx (ignore = %s)\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset, tp->item->ignore ? "TRUE" : "FALSE");
+    TRACE("deleting item %I64x,%x,%I64x (ignore = %s)\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset, tp->item->ignore ? "true" : "false");
 
 #ifdef DEBUG_PARANOID
     if (tp->item->ignore) {
-        ERR("trying to delete already-deleted item %llx,%x,%llx\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset);
+        ERR("trying to delete already-deleted item %I64x,%x,%I64x\n", tp->item->key.obj_id, tp->item->key.obj_type, tp->item->key.offset);
         int3;
         return STATUS_INTERNAL_ERROR;
     }
 #endif
 
-    tp->item->ignore = TRUE;
+    tp->item->ignore = true;
 
     if (!tp->tree->write) {
-        tp->tree->write = TRUE;
-        Vcb->need_write = TRUE;
+        tp->tree->write = true;
+        Vcb->need_write = true;
     }
 
     tp->tree->header.num_items--;
@@ -1059,7 +1059,7 @@ void do_rollback(device_extension* Vcb, LIST_ENTRY* rollback) {
             {
                 rollback_extent* re = ri->ptr;
 
-                re->ext->ignore = TRUE;
+                re->ext->ignore = true;
 
                 if (re->ext->extent_data.type == EXTENT_TYPE_REGULAR || re->ext->extent_data.type == EXTENT_TYPE_PREALLOC) {
                     EXTENT_DATA2* ed2 = (EXTENT_DATA2*)re->ext->extent_data.data;
@@ -1070,7 +1070,7 @@ void do_rollback(device_extension* Vcb, LIST_ENTRY* rollback) {
                         if (c) {
                             Status = update_changed_extent_ref(Vcb, c, ed2->address, ed2->size, re->fcb->subvol->id,
                                                                re->fcb->inode, re->ext->offset - ed2->offset, -1,
-                                                               re->fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, NULL);
+                                                               re->fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, NULL);
 
                             if (!NT_SUCCESS(Status))
                                 ERR("update_changed_extent_ref returned %08x\n", Status);
@@ -1088,7 +1088,7 @@ void do_rollback(device_extension* Vcb, LIST_ENTRY* rollback) {
             {
                 rollback_extent* re = ri->ptr;
 
-                re->ext->ignore = FALSE;
+                re->ext->ignore = false;
 
                 if (re->ext->extent_data.type == EXTENT_TYPE_REGULAR || re->ext->extent_data.type == EXTENT_TYPE_PREALLOC) {
                     EXTENT_DATA2* ed2 = (EXTENT_DATA2*)re->ext->extent_data.data;
@@ -1099,7 +1099,7 @@ void do_rollback(device_extension* Vcb, LIST_ENTRY* rollback) {
                         if (c) {
                             Status = update_changed_extent_ref(Vcb, c, ed2->address, ed2->size, re->fcb->subvol->id,
                                                                re->fcb->inode, re->ext->offset - ed2->offset, 1,
-                                                               re->fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, NULL);
+                                                               re->fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, NULL);
 
                             if (!NT_SUCCESS(Status))
                                 ERR("update_changed_extent_ref returned %08x\n", Status);
@@ -1174,7 +1174,7 @@ void do_rollback(device_extension* Vcb, LIST_ENTRY* rollback) {
     }
 }
 
-static void find_tree_end(tree* t, KEY* tree_end, BOOL* no_end) {
+static void find_tree_end(tree* t, KEY* tree_end, bool* no_end) {
     tree* p;
 
     p = t;
@@ -1182,7 +1182,7 @@ static void find_tree_end(tree* t, KEY* tree_end, BOOL* no_end) {
         tree_data* pi;
 
         if (!p->parent) {
-            *no_end = TRUE;
+            *no_end = true;
             return;
         }
 
@@ -1192,7 +1192,7 @@ static void find_tree_end(tree* t, KEY* tree_end, BOOL* no_end) {
             tree_data* td = CONTAINING_RECORD(pi->list_entry.Flink, tree_data, list_entry);
 
             *tree_end = td->key;
-            *no_end = FALSE;
+            *no_end = false;
             return;
         }
 
@@ -1244,7 +1244,7 @@ static void add_delete_inode_extref(device_extension* Vcb, batch_item* bi, LIST_
 
     bi2->key.obj_id = bi->key.obj_id;
     bi2->key.obj_type = TYPE_INODE_EXTREF;
-    bi2->key.offset = calc_crc32c((UINT32)bi->key.offset, (UINT8*)ier->name, ier->n);
+    bi2->key.offset = calc_crc32c((uint32_t)bi->key.offset, (uint8_t*)ier->name, ier->n);
     bi2->data = ier;
     bi2->datalen = sizeof(INODE_EXTREF) - 1 + ier->n;
     bi2->operation = Batch_DeleteInodeExtRef;
@@ -1264,34 +1264,34 @@ static void add_delete_inode_extref(device_extension* Vcb, batch_item* bi, LIST_
     InsertTailList(listhead, &bi2->list_entry);
 }
 
-static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tree* t, tree_data* td, tree_data* newtd, LIST_ENTRY* listhead, BOOL* ignore) {
+static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tree* t, tree_data* td, tree_data* newtd, LIST_ENTRY* listhead, bool* ignore) {
     if (bi->operation == Batch_Delete || bi->operation == Batch_SetXattr || bi->operation == Batch_DirItem || bi->operation == Batch_InodeRef ||
         bi->operation == Batch_InodeExtRef || bi->operation == Batch_DeleteDirItem || bi->operation == Batch_DeleteInodeRef ||
         bi->operation == Batch_DeleteInodeExtRef || bi->operation == Batch_DeleteXattr) {
-        UINT16 maxlen = (UINT16)(Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node));
+        uint16_t maxlen = (uint16_t)(Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node));
 
         switch (bi->operation) {
             case Batch_SetXattr: {
                 if (td->size < sizeof(DIR_ITEM)) {
-                    ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", bi->key.obj_id, bi->key.obj_type, bi->key.offset, td->size, sizeof(DIR_ITEM));
+                    ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %u\n", bi->key.obj_id, bi->key.obj_type, bi->key.offset, td->size, sizeof(DIR_ITEM));
                 } else {
-                    UINT8* newdata;
+                    uint8_t* newdata;
                     ULONG size = td->size;
                     DIR_ITEM* newxa = (DIR_ITEM*)bi->data;
                     DIR_ITEM* xa = (DIR_ITEM*)td->data;
 
-                    while (TRUE) {
+                    while (true) {
                         ULONG oldxasize;
 
                         if (size < sizeof(DIR_ITEM) || size < sizeof(DIR_ITEM) - 1 + xa->m + xa->n) {
-                            ERR("(%llx,%x,%llx) was truncated\n", bi->key.obj_id, bi->key.obj_type, bi->key.offset);
+                            ERR("(%I64x,%x,%I64x) was truncated\n", bi->key.obj_id, bi->key.obj_type, bi->key.offset);
                             break;
                         }
 
                         oldxasize = sizeof(DIR_ITEM) - 1 + xa->m + xa->n;
 
                         if (xa->n == newxa->n && RtlCompareMemory(newxa->name, xa->name, xa->n) == xa->n) {
-                            UINT64 pos;
+                            uint64_t pos;
 
                             // replace
 
@@ -1304,7 +1304,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
                                 return STATUS_INSUFFICIENT_RESOURCES;
                             }
 
-                            pos = (UINT8*)xa - td->data;
+                            pos = (uint8_t*)xa - td->data;
                             if (pos + oldxasize < td->size) // copy after changed xattr
                                 RtlCopyMemory(newdata + pos + bi->datalen, td->data + pos + oldxasize, (ULONG)(td->size - pos - oldxasize));
 
@@ -1316,7 +1316,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                             RtlCopyMemory(xa, bi->data, bi->datalen);
 
-                            bi->datalen = (UINT16)min(td->size + bi->datalen - oldxasize, maxlen);
+                            bi->datalen = (uint16_t)min(td->size + bi->datalen - oldxasize, maxlen);
 
                             ExFreePool(bi->data);
                             bi->data = newdata;
@@ -1324,7 +1324,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
                             break;
                         }
 
-                        if ((UINT8*)xa - (UINT8*)td->data + oldxasize >= size) {
+                        if ((uint8_t*)xa - (uint8_t*)td->data + oldxasize >= size) {
                             // not found, add to end of data
 
                             if (td->size + bi->datalen > maxlen)
@@ -1338,7 +1338,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                             RtlCopyMemory(newdata, td->data, td->size);
 
-                            xa = (DIR_ITEM*)((UINT8*)newdata + td->size);
+                            xa = (DIR_ITEM*)((uint8_t*)newdata + td->size);
                             RtlCopyMemory(xa, bi->data, bi->datalen);
 
                             bi->datalen = min(bi->datalen + td->size, maxlen);
@@ -1357,7 +1357,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
             }
 
             case Batch_DirItem: {
-                UINT8* newdata;
+                uint8_t* newdata;
 
                 if (td->size + bi->datalen > maxlen) {
                     ERR("DIR_ITEM would be over maximum size (%u + %u > %u)\n", td->size, bi->datalen, maxlen);
@@ -1383,20 +1383,20 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
             }
 
             case Batch_InodeRef: {
-                UINT8* newdata;
+                uint8_t* newdata;
 
                 if (td->size + bi->datalen > maxlen) {
                     if (Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF) {
                         INODE_REF* ir = (INODE_REF*)bi->data;
                         INODE_EXTREF* ier;
-                        UINT16 ierlen;
+                        uint16_t ierlen;
                         batch_item* bi2;
                         LIST_ENTRY* le;
-                        BOOL inserted = FALSE;
+                        bool inserted = false;
 
                         TRACE("INODE_REF would be too long, adding INODE_EXTREF instead\n");
 
-                        ierlen = (UINT16)(offsetof(INODE_EXTREF, name[0]) + ir->n);
+                        ierlen = (uint16_t)(offsetof(INODE_EXTREF, name[0]) + ir->n);
 
                         ier = ExAllocatePoolWithTag(PagedPool, ierlen, ALLOC_TAG);
                         if (!ier) {
@@ -1418,7 +1418,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                         bi2->key.obj_id = bi->key.obj_id;
                         bi2->key.obj_type = TYPE_INODE_EXTREF;
-                        bi2->key.offset = calc_crc32c((UINT32)ier->dir, (UINT8*)ier->name, ier->n);
+                        bi2->key.offset = calc_crc32c((uint32_t)ier->dir, (uint8_t*)ier->name, ier->n);
                         bi2->data = ier;
                         bi2->datalen = ierlen;
                         bi2->operation = Batch_InodeExtRef;
@@ -1429,7 +1429,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                             if (keycmp(bi3->key, bi2->key) != -1) {
                                 InsertHeadList(le->Blink, &bi2->list_entry);
-                                inserted = TRUE;
+                                inserted = true;
                             }
 
                             le = le->Flink;
@@ -1438,7 +1438,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
                         if (!inserted)
                             InsertTailList(listhead, &bi2->list_entry);
 
-                        *ignore = TRUE;
+                        *ignore = true;
                         return STATUS_SUCCESS;
                     } else {
                         ERR("INODE_REF would be over maximum size (%u + %u > %u)\n", td->size, bi->datalen, maxlen);
@@ -1465,7 +1465,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
             }
 
             case Batch_InodeExtRef: {
-                UINT8* newdata;
+                uint8_t* newdata;
 
                 if (td->size + bi->datalen > maxlen) {
                     ERR("INODE_EXTREF would be over maximum size (%u + %u > %u)\n", td->size, bi->datalen, maxlen);
@@ -1504,12 +1504,12 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                     do {
                         if (di->m == deldi->m && di->n == deldi->n && RtlCompareMemory(di->name, deldi->name, di->n + di->m) == di->n + di->m) {
-                            UINT16 newlen = td->size - (sizeof(DIR_ITEM) - sizeof(char) + di->n + di->m);
+                            uint16_t newlen = td->size - (sizeof(DIR_ITEM) - sizeof(char) + di->n + di->m);
 
                             if (newlen == 0) {
                                 TRACE("deleting DIR_ITEM\n");
                             } else {
-                                UINT8 *newdi = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *dioff;
+                                uint8_t *newdi = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *dioff;
                                 tree_data* td2;
 
                                 if (!newdi) {
@@ -1519,15 +1519,15 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                                 TRACE("modifying DIR_ITEM\n");
 
-                                if ((UINT8*)di > td->data) {
-                                    RtlCopyMemory(newdi, td->data, (UINT8*)di - td->data);
-                                    dioff = newdi + ((UINT8*)di - td->data);
+                                if ((uint8_t*)di > td->data) {
+                                    RtlCopyMemory(newdi, td->data, (uint8_t*)di - td->data);
+                                    dioff = newdi + ((uint8_t*)di - td->data);
                                 } else {
                                     dioff = newdi;
                                 }
 
-                                if ((UINT8*)&di->name[di->n + di->m] < td->data + td->size)
-                                    RtlCopyMemory(dioff, &di->name[di->n + di->m], td->size - ((UINT8*)&di->name[di->n + di->m] - td->data));
+                                if ((uint8_t*)&di->name[di->n + di->m] < td->data + td->size)
+                                    RtlCopyMemory(dioff, &di->name[di->n + di->m], td->size - ((uint8_t*)&di->name[di->n + di->m] - td->data));
 
                                 td2 = ExAllocateFromPagedLookasideList(&Vcb->tree_data_lookaside);
                                 if (!td2) {
@@ -1539,14 +1539,14 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
                                 td2->key = bi->key;
                                 td2->size = newlen;
                                 td2->data = newdi;
-                                td2->ignore = FALSE;
-                                td2->inserted = TRUE;
+                                td2->ignore = false;
+                                td2->inserted = true;
 
                                 InsertHeadList(td->list_entry.Blink, &td2->list_entry);
 
                                 t->header.num_items++;
                                 t->size += newlen + sizeof(leaf_node);
-                                t->write = TRUE;
+                                t->write = true;
                             }
 
                             break;
@@ -1557,7 +1557,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                         if (len == 0) {
                             TRACE("could not find DIR_ITEM to delete\n");
-                            *ignore = TRUE;
+                            *ignore = true;
                             return STATUS_SUCCESS;
                         }
                     } while (len > 0);
@@ -1572,31 +1572,31 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
                 } else {
                     INODE_REF *ir, *delir;
                     ULONG len;
-                    BOOL changed = FALSE;
+                    bool changed = false;
 
                     delir = (INODE_REF*)bi->data;
                     ir = (INODE_REF*)td->data;
                     len = td->size;
 
                     do {
-                        UINT16 itemlen;
+                        uint16_t itemlen;
 
                         if (len < sizeof(INODE_REF) || len < offsetof(INODE_REF, name[0]) + ir->n) {
                             ERR("INODE_REF was truncated\n");
                             break;
                         }
 
-                        itemlen = (UINT16)offsetof(INODE_REF, name[0]) + ir->n;
+                        itemlen = (uint16_t)offsetof(INODE_REF, name[0]) + ir->n;
 
                         if (ir->n == delir->n && RtlCompareMemory(ir->name, delir->name, ir->n) == ir->n) {
-                            UINT16 newlen = td->size - itemlen;
+                            uint16_t newlen = td->size - itemlen;
 
-                            changed = TRUE;
+                            changed = true;
 
                             if (newlen == 0)
                                 TRACE("deleting INODE_REF\n");
                             else {
-                                UINT8 *newir = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *iroff;
+                                uint8_t *newir = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *iroff;
                                 tree_data* td2;
 
                                 if (!newir) {
@@ -1606,15 +1606,15 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                                 TRACE("modifying INODE_REF\n");
 
-                                if ((UINT8*)ir > td->data) {
-                                    RtlCopyMemory(newir, td->data, (UINT8*)ir - td->data);
-                                    iroff = newir + ((UINT8*)ir - td->data);
+                                if ((uint8_t*)ir > td->data) {
+                                    RtlCopyMemory(newir, td->data, (uint8_t*)ir - td->data);
+                                    iroff = newir + ((uint8_t*)ir - td->data);
                                 } else {
                                     iroff = newir;
                                 }
 
-                                if ((UINT8*)&ir->name[ir->n] < td->data + td->size)
-                                    RtlCopyMemory(iroff, &ir->name[ir->n], td->size - ((UINT8*)&ir->name[ir->n] - td->data));
+                                if ((uint8_t*)&ir->name[ir->n] < td->data + td->size)
+                                    RtlCopyMemory(iroff, &ir->name[ir->n], td->size - ((uint8_t*)&ir->name[ir->n] - td->data));
 
                                 td2 = ExAllocateFromPagedLookasideList(&Vcb->tree_data_lookaside);
                                 if (!td2) {
@@ -1626,14 +1626,14 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
                                 td2->key = bi->key;
                                 td2->size = newlen;
                                 td2->data = newir;
-                                td2->ignore = FALSE;
-                                td2->inserted = TRUE;
+                                td2->ignore = false;
+                                td2->inserted = true;
 
                                 InsertHeadList(td->list_entry.Blink, &td2->list_entry);
 
                                 t->header.num_items++;
                                 t->size += newlen + sizeof(leaf_node);
-                                t->write = TRUE;
+                                t->write = true;
                             }
 
                             break;
@@ -1652,7 +1652,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                             add_delete_inode_extref(Vcb, bi, listhead);
 
-                            *ignore = TRUE;
+                            *ignore = true;
                             return STATUS_SUCCESS;
                         } else
                             WARN("entry not found in INODE_REF\n");
@@ -1675,22 +1675,22 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
                     len = td->size;
 
                     do {
-                        UINT16 itemlen;
+                        uint16_t itemlen;
 
                         if (len < sizeof(INODE_EXTREF) || len < offsetof(INODE_EXTREF, name[0]) + ier->n) {
                             ERR("INODE_REF was truncated\n");
                             break;
                         }
 
-                        itemlen = (UINT16)offsetof(INODE_EXTREF, name[0]) + ier->n;
+                        itemlen = (uint16_t)offsetof(INODE_EXTREF, name[0]) + ier->n;
 
                         if (ier->dir == delier->dir && ier->n == delier->n && RtlCompareMemory(ier->name, delier->name, ier->n) == ier->n) {
-                            UINT16 newlen = td->size - itemlen;
+                            uint16_t newlen = td->size - itemlen;
 
                             if (newlen == 0)
                                 TRACE("deleting INODE_EXTREF\n");
                             else {
-                                UINT8 *newier = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *ieroff;
+                                uint8_t *newier = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *ieroff;
                                 tree_data* td2;
 
                                 if (!newier) {
@@ -1700,15 +1700,15 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                                 TRACE("modifying INODE_EXTREF\n");
 
-                                if ((UINT8*)ier > td->data) {
-                                    RtlCopyMemory(newier, td->data, (UINT8*)ier - td->data);
-                                    ieroff = newier + ((UINT8*)ier - td->data);
+                                if ((uint8_t*)ier > td->data) {
+                                    RtlCopyMemory(newier, td->data, (uint8_t*)ier - td->data);
+                                    ieroff = newier + ((uint8_t*)ier - td->data);
                                 } else {
                                     ieroff = newier;
                                 }
 
-                                if ((UINT8*)&ier->name[ier->n] < td->data + td->size)
-                                    RtlCopyMemory(ieroff, &ier->name[ier->n], td->size - ((UINT8*)&ier->name[ier->n] - td->data));
+                                if ((uint8_t*)&ier->name[ier->n] < td->data + td->size)
+                                    RtlCopyMemory(ieroff, &ier->name[ier->n], td->size - ((uint8_t*)&ier->name[ier->n] - td->data));
 
                                 td2 = ExAllocateFromPagedLookasideList(&Vcb->tree_data_lookaside);
                                 if (!td2) {
@@ -1720,14 +1720,14 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
                                 td2->key = bi->key;
                                 td2->size = newlen;
                                 td2->data = newier;
-                                td2->ignore = FALSE;
-                                td2->inserted = TRUE;
+                                td2->ignore = false;
+                                td2->inserted = true;
 
                                 InsertHeadList(td->list_entry.Blink, &td2->list_entry);
 
                                 t->header.num_items++;
                                 t->size += newlen + sizeof(leaf_node);
-                                t->write = TRUE;
+                                t->write = true;
                             }
 
                             break;
@@ -1757,12 +1757,12 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                     do {
                         if (di->n == deldi->n && RtlCompareMemory(di->name, deldi->name, di->n) == di->n) {
-                            UINT16 newlen = td->size - ((UINT16)offsetof(DIR_ITEM, name[0]) + di->n + di->m);
+                            uint16_t newlen = td->size - ((uint16_t)offsetof(DIR_ITEM, name[0]) + di->n + di->m);
 
                             if (newlen == 0)
                                 TRACE("deleting XATTR_ITEM\n");
                             else {
-                                UINT8 *newdi = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *dioff;
+                                uint8_t *newdi = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *dioff;
                                 tree_data* td2;
 
                                 if (!newdi) {
@@ -1772,14 +1772,14 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                                 TRACE("modifying XATTR_ITEM\n");
 
-                                if ((UINT8*)di > td->data) {
-                                    RtlCopyMemory(newdi, td->data, (UINT8*)di - td->data);
-                                    dioff = newdi + ((UINT8*)di - td->data);
+                                if ((uint8_t*)di > td->data) {
+                                    RtlCopyMemory(newdi, td->data, (uint8_t*)di - td->data);
+                                    dioff = newdi + ((uint8_t*)di - td->data);
                                 } else
                                     dioff = newdi;
 
-                                if ((UINT8*)&di->name[di->n + di->m] < td->data + td->size)
-                                    RtlCopyMemory(dioff, &di->name[di->n + di->m], td->size - ((UINT8*)&di->name[di->n + di->m] - td->data));
+                                if ((uint8_t*)&di->name[di->n + di->m] < td->data + td->size)
+                                    RtlCopyMemory(dioff, &di->name[di->n + di->m], td->size - ((uint8_t*)&di->name[di->n + di->m] - td->data));
 
                                 td2 = ExAllocateFromPagedLookasideList(&Vcb->tree_data_lookaside);
                                 if (!td2) {
@@ -1791,14 +1791,14 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
                                 td2->key = bi->key;
                                 td2->size = newlen;
                                 td2->data = newdi;
-                                td2->ignore = FALSE;
-                                td2->inserted = TRUE;
+                                td2->ignore = false;
+                                td2->inserted = true;
 
                                 InsertHeadList(td->list_entry.Blink, &td2->list_entry);
 
                                 t->header.num_items++;
                                 t->size += newlen + sizeof(leaf_node);
-                                t->write = TRUE;
+                                t->write = true;
                             }
 
                             break;
@@ -1809,7 +1809,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
                         if (len == 0) {
                             TRACE("could not find DIR_ITEM to delete\n");
-                            *ignore = TRUE;
+                            *ignore = true;
                             return STATUS_SUCCESS;
                         }
                     } while (len > 0);
@@ -1827,11 +1827,11 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
 
         // delete old item
         if (!td->ignore) {
-            td->ignore = TRUE;
+            td->ignore = true;
 
             t->header.num_items--;
             t->size -= sizeof(leaf_node) + td->size;
-            t->write = TRUE;
+            t->write = true;
         }
 
         if (newtd) {
@@ -1840,11 +1840,11 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr
             InsertHeadList(td->list_entry.Blink, &newtd->list_entry);
         }
     } else {
-        ERR("(%llx,%x,%llx) already exists\n", bi->key.obj_id, bi->key.obj_type, bi->key.offset);
+        ERR("(%I64x,%x,%I64x) already exists\n", bi->key.obj_id, bi->key.obj_type, bi->key.offset);
         return STATUS_INTERNAL_ERROR;
     }
 
-    *ignore = FALSE;
+    *ignore = false;
     return STATUS_SUCCESS;
 }
 
@@ -1852,7 +1852,7 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
     LIST_ENTRY* le;
     NTSTATUS Status;
 
-    TRACE("root: %llx\n", br->r->id);
+    TRACE("root: %I64x\n", br->r->id);
 
     le = br->items.Flink;
     while (le != &br->items) {
@@ -1860,15 +1860,15 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
         LIST_ENTRY *le2;
         traverse_ptr tp;
         KEY tree_end;
-        BOOL no_end;
+        bool no_end;
         tree_data *td, *listhead;
         int cmp;
         tree* t;
-        BOOL ignore = FALSE;
+        bool ignore = false;
 
-        TRACE("(%llx,%x,%llx)\n", bi->key.obj_id, bi->key.obj_type, bi->key.offset);
+        TRACE("(%I64x,%x,%I64x)\n", bi->key.obj_id, bi->key.obj_type, bi->key.offset);
 
-        Status = find_item(Vcb, br->r, &tp, &bi->key, TRUE, Irp);
+        Status = find_item(Vcb, br->r, &tp, &bi->key, true, Irp);
         if (!NT_SUCCESS(Status)) { // FIXME - handle STATUS_NOT_FOUND
             ERR("find_item returned %08x\n", Status);
             return Status;
@@ -1878,15 +1878,15 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
         if (bi->operation == Batch_DeleteInode) {
             if (tp.item->key.obj_id == bi->key.obj_id) {
-                BOOL ended = FALSE;
+                bool ended = false;
 
                 td = tp.item;
 
                 if (!tp.item->ignore) {
-                    tp.item->ignore = TRUE;
+                    tp.item->ignore = true;
                     tp.tree->header.num_items--;
                     tp.tree->size -= tp.item->size + sizeof(leaf_node);
-                    tp.tree->write = TRUE;
+                    tp.tree->write = true;
                 }
 
                 le2 = tp.item->list_entry.Flink;
@@ -1895,13 +1895,13 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
                     if (td->key.obj_id == bi->key.obj_id) {
                         if (!td->ignore) {
-                            td->ignore = TRUE;
+                            td->ignore = true;
                             tp.tree->header.num_items--;
                             tp.tree->size -= td->size + sizeof(leaf_node);
-                            tp.tree->write = TRUE;
+                            tp.tree->write = true;
                         }
                     } else {
-                        ended = TRUE;
+                        ended = true;
                         break;
                     }
 
@@ -1913,7 +1913,7 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
                     tp.item = td;
 
-                    if (!find_next_item(Vcb, &tp, &next_tp, FALSE, Irp))
+                    if (!find_next_item(Vcb, &tp, &next_tp, false, Irp))
                         break;
 
                     tp = next_tp;
@@ -1924,13 +1924,13 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
                         if (td->key.obj_id == bi->key.obj_id) {
                             if (!td->ignore) {
-                                td->ignore = TRUE;
+                                td->ignore = true;
                                 tp.tree->header.num_items--;
                                 tp.tree->size -= td->size + sizeof(leaf_node);
-                                tp.tree->write = TRUE;
+                                tp.tree->write = true;
                             }
                         } else {
-                            ended = TRUE;
+                            ended = true;
                             break;
                         }
 
@@ -1942,7 +1942,7 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
             if (tp.item->key.obj_id < bi->key.obj_id || (tp.item->key.obj_id == bi->key.obj_id && tp.item->key.obj_type < bi->key.obj_type)) {
                 traverse_ptr tp2;
 
-                if (find_next_item(Vcb, &tp, &tp2, FALSE, Irp)) {
+                if (find_next_item(Vcb, &tp, &tp2, false, Irp)) {
                     if (tp2.item->key.obj_id == bi->key.obj_id && tp2.item->key.obj_type == bi->key.obj_type) {
                         tp = tp2;
                         find_tree_end(tp.tree, &tree_end, &no_end);
@@ -1951,15 +1951,15 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
             }
 
             if (tp.item->key.obj_id == bi->key.obj_id && tp.item->key.obj_type == bi->key.obj_type) {
-                BOOL ended = FALSE;
+                bool ended = false;
 
                 td = tp.item;
 
                 if (!tp.item->ignore) {
-                    tp.item->ignore = TRUE;
+                    tp.item->ignore = true;
                     tp.tree->header.num_items--;
                     tp.tree->size -= tp.item->size + sizeof(leaf_node);
-                    tp.tree->write = TRUE;
+                    tp.tree->write = true;
                 }
 
                 le2 = tp.item->list_entry.Flink;
@@ -1968,13 +1968,13 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
                     if (td->key.obj_id == bi->key.obj_id && td->key.obj_type == bi->key.obj_type) {
                         if (!td->ignore) {
-                            td->ignore = TRUE;
+                            td->ignore = true;
                             tp.tree->header.num_items--;
                             tp.tree->size -= td->size + sizeof(leaf_node);
-                            tp.tree->write = TRUE;
+                            tp.tree->write = true;
                         }
                     } else {
-                        ended = TRUE;
+                        ended = true;
                         break;
                     }
 
@@ -1986,7 +1986,7 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
                     tp.item = td;
 
-                    if (!find_next_item(Vcb, &tp, &next_tp, FALSE, Irp))
+                    if (!find_next_item(Vcb, &tp, &next_tp, false, Irp))
                         break;
 
                     tp = next_tp;
@@ -1997,13 +1997,13 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
                         if (td->key.obj_id == bi->key.obj_id && td->key.obj_type == bi->key.obj_type) {
                             if (!td->ignore) {
-                                td->ignore = TRUE;
+                                td->ignore = true;
                                 tp.tree->header.num_items--;
                                 tp.tree->size -= td->size + sizeof(leaf_node);
-                                tp.tree->write = TRUE;
+                                tp.tree->write = true;
                             }
                         } else {
-                            ended = TRUE;
+                            ended = true;
                             break;
                         }
 
@@ -2013,15 +2013,15 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
             }
         } else if (bi->operation == Batch_DeleteFreeSpace) {
             if (tp.item->key.obj_id >= bi->key.obj_id && tp.item->key.obj_id < bi->key.obj_id + bi->key.offset) {
-                BOOL ended = FALSE;
+                bool ended = false;
 
                 td = tp.item;
 
                 if (!tp.item->ignore) {
-                    tp.item->ignore = TRUE;
+                    tp.item->ignore = true;
                     tp.tree->header.num_items--;
                     tp.tree->size -= tp.item->size + sizeof(leaf_node);
-                    tp.tree->write = TRUE;
+                    tp.tree->write = true;
                 }
 
                 le2 = tp.item->list_entry.Flink;
@@ -2030,13 +2030,13 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
                     if (td->key.obj_id >= bi->key.obj_id && td->key.obj_id < bi->key.obj_id + bi->key.offset) {
                         if (!td->ignore) {
-                            td->ignore = TRUE;
+                            td->ignore = true;
                             tp.tree->header.num_items--;
                             tp.tree->size -= td->size + sizeof(leaf_node);
-                            tp.tree->write = TRUE;
+                            tp.tree->write = true;
                         }
                     } else {
-                        ended = TRUE;
+                        ended = true;
                         break;
                     }
 
@@ -2048,7 +2048,7 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
                     tp.item = td;
 
-                    if (!find_next_item(Vcb, &tp, &next_tp, FALSE, Irp))
+                    if (!find_next_item(Vcb, &tp, &next_tp, false, Irp))
                         break;
 
                     tp = next_tp;
@@ -2059,13 +2059,13 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
                         if (td->key.obj_id >= bi->key.obj_id && td->key.obj_id < bi->key.obj_id + bi->key.offset) {
                             if (!td->ignore) {
-                                td->ignore = TRUE;
+                                td->ignore = true;
                                 tp.tree->header.num_items--;
                                 tp.tree->size -= td->size + sizeof(leaf_node);
-                                tp.tree->write = TRUE;
+                                tp.tree->write = true;
                             }
                         } else {
-                            ended = TRUE;
+                            ended = true;
                             break;
                         }
 
@@ -2087,8 +2087,8 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
                 td->key = bi->key;
                 td->size = bi->datalen;
                 td->data = bi->data;
-                td->ignore = FALSE;
-                td->inserted = TRUE;
+                td->ignore = false;
+                td->inserted = true;
             }
 
             cmp = keycmp(bi->key, tp.item->key);
@@ -2135,7 +2135,7 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
             if (!ignore && td) {
                 tp.tree->header.num_items++;
                 tp.tree->size += bi->datalen + sizeof(leaf_node);
-                tp.tree->write = TRUE;
+                tp.tree->write = true;
 
                 listhead = td;
             } else
@@ -2159,9 +2159,9 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
 
                 if (no_end || keycmp(bi2->key, tree_end) == -1) {
                     LIST_ENTRY* le3;
-                    BOOL inserted = FALSE;
+                    bool inserted = false;
 
-                    ignore = FALSE;
+                    ignore = false;
 
                     if (bi2->operation == Batch_Delete || bi2->operation == Batch_DeleteDirItem || bi2->operation == Batch_DeleteInodeRef ||
                         bi2->operation == Batch_DeleteInodeExtRef || bi2->operation == Batch_DeleteXattr)
@@ -2176,8 +2176,8 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
                         td->key = bi2->key;
                         td->size = bi2->datalen;
                         td->data = bi2->data;
-                        td->ignore = FALSE;
-                        td->inserted = TRUE;
+                        td->ignore = false;
+                        td->inserted = true;
                     }
 
                     le3 = &listhead->list_entry;
@@ -2190,7 +2190,7 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
                             if (td2->ignore) {
                                 if (td) {
                                     InsertHeadList(le3->Blink, &td->list_entry);
-                                    inserted = TRUE;
+                                    inserted = true;
                                 } else if (bi2->operation == Batch_DeleteInodeRef && Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF) {
                                     add_delete_inode_extref(Vcb, bi2, &br->items);
                                 }
@@ -2202,12 +2202,12 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
                                 }
                             }
 
-                            inserted = TRUE;
+                            inserted = true;
                             break;
                         } else if (cmp == -1) {
                             if (td) {
                                 InsertHeadList(le3->Blink, &td->list_entry);
-                                inserted = TRUE;
+                                inserted = true;
                             } else if (bi2->operation == Batch_DeleteInodeRef && Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF) {
                                 add_delete_inode_extref(Vcb, bi2, &br->items);
                             }
@@ -2250,7 +2250,7 @@ static NTSTATUS commit_batch_list_root(_Requires_exclusive_lock_held_(_Curr_->tr
             t = tp.tree;
             while (t) {
                 if (t->paritem && t->paritem->ignore) {
-                    t->paritem->ignore = FALSE;
+                    t->paritem->ignore = false;
                     t->parent->header.num_items++;
                     t->parent->size += sizeof(internal_node);
                 }
diff --git a/drivers/filesystems/btrfs/volume.c b/drivers/filesystems/btrfs/volume.c
index 4f7dc635d57..d50852b5952 100644
--- a/drivers/filesystems/btrfs/volume.c
+++ b/drivers/filesystems/btrfs/volume.c
@@ -27,6 +27,7 @@
 
 extern PDRIVER_OBJECT drvobj;
 extern PDEVICE_OBJECT master_devobj;
+extern PDEVICE_OBJECT busobj;
 extern ERESOURCE pdo_list_lock;
 extern LIST_ENTRY pdo_list;
 extern UNICODE_STRING registry_path;
@@ -53,9 +54,9 @@ NTSTATUS vol_close(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
 
     Irp->IoStatus.Information = 0;
 
-    ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&pdo_list_lock, true);
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     if (InterlockedDecrement(&vde->open_count) == 0 && vde->removing) {
         NTSTATUS Status;
@@ -108,17 +109,13 @@ typedef struct {
 } vol_read_context;
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI vol_read_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#else
-static NTSTATUS vol_read_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#endif
+static NTSTATUS __stdcall vol_read_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
     vol_read_context* context = conptr;
 
     UNUSED(DeviceObject);
 
     context->iosb = Irp->IoStatus;
-    KeSetEvent(&context->Event, 0, FALSE);
+    KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
@@ -134,7 +131,7 @@ NTSTATUS vol_read(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
 
     TRACE("(%p, %p)\n", DeviceObject, Irp);
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     if (IsListEmpty(&pdode->children)) {
         ExReleaseResourceLite(&pdode->child_lock);
@@ -146,7 +143,7 @@ NTSTATUS vol_read(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
 
     // We can't use IoSkipCurrentIrpStackLocation as the device isn't in our stack
 
-    Irp2 = IoAllocateIrp(vc->devobj->StackSize, FALSE);
+    Irp2 = IoAllocateIrp(vc->devobj->StackSize, false);
 
     if (!Irp2) {
         ERR("IoAllocateIrp failed\n");
@@ -159,6 +156,7 @@ NTSTATUS vol_read(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     IrpSp2 = IoGetNextIrpStackLocation(Irp2);
 
     IrpSp2->MajorFunction = IRP_MJ_READ;
+    IrpSp2->FileObject = vc->fileobj;
 
     if (vc->devobj->Flags & DO_BUFFERED_IO) {
         Irp2->AssociatedIrp.SystemBuffer = ExAllocatePoolWithTag(NonPagedPool, IrpSp->Parameters.Read.Length, ALLOC_TAG);
@@ -180,15 +178,15 @@ NTSTATUS vol_read(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     IrpSp2->Parameters.Read.Length = IrpSp->Parameters.Read.Length;
     IrpSp2->Parameters.Read.ByteOffset.QuadPart = IrpSp->Parameters.Read.ByteOffset.QuadPart;
 
-    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&context.Event, NotificationEvent, false);
     Irp2->UserIosb = &context.iosb;
 
-    IoSetCompletionRoutine(Irp2, vol_read_completion, &context, TRUE, TRUE, TRUE);
+    IoSetCompletionRoutine(Irp2, vol_read_completion, &context, true, true, true);
 
     Status = IoCallDriver(vc->devobj, Irp2);
 
     if (Status == STATUS_PENDING) {
-        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+        KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
         Status = context.iosb.Status;
     }
 
@@ -214,7 +212,7 @@ NTSTATUS vol_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
 
     TRACE("(%p, %p)\n", DeviceObject, Irp);
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     if (IsListEmpty(&pdode->children)) {
         ExReleaseResourceLite(&pdode->child_lock);
@@ -232,7 +230,7 @@ NTSTATUS vol_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
 
     // We can't use IoSkipCurrentIrpStackLocation as the device isn't in our stack
 
-    Irp2 = IoAllocateIrp(vc->devobj->StackSize, FALSE);
+    Irp2 = IoAllocateIrp(vc->devobj->StackSize, false);
 
     if (!Irp2) {
         ERR("IoAllocateIrp failed\n");
@@ -245,6 +243,7 @@ NTSTATUS vol_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     IrpSp2 = IoGetNextIrpStackLocation(Irp2);
 
     IrpSp2->MajorFunction = IRP_MJ_WRITE;
+    IrpSp2->FileObject = vc->fileobj;
 
     if (vc->devobj->Flags & DO_BUFFERED_IO) {
         Irp2->AssociatedIrp.SystemBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
@@ -260,15 +259,15 @@ NTSTATUS vol_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     IrpSp2->Parameters.Write.Length = IrpSp->Parameters.Write.Length;
     IrpSp2->Parameters.Write.ByteOffset.QuadPart = IrpSp->Parameters.Write.ByteOffset.QuadPart;
 
-    KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&context.Event, NotificationEvent, false);
     Irp2->UserIosb = &context.iosb;
 
-    IoSetCompletionRoutine(Irp2, vol_read_completion, &context, TRUE, TRUE, TRUE);
+    IoSetCompletionRoutine(Irp2, vol_read_completion, &context, true, true, true);
 
     Status = IoCallDriver(vc->devobj, Irp2);
 
     if (Status == STATUS_PENDING) {
-        KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
+        KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
         Status = context.iosb.Status;
     }
 
@@ -310,7 +309,7 @@ NTSTATUS vol_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
 NTSTATUS vol_flush_buffers(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     TRACE("(%p, %p)\n", DeviceObject, Irp);
 
-    return STATUS_INVALID_DEVICE_REQUEST;
+    return STATUS_SUCCESS;
 }
 
 NTSTATUS vol_query_volume_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
@@ -407,12 +406,12 @@ static NTSTATUS vol_query_unique_id(volume_device_extension* vde, PIRP Irp) {
 
 static NTSTATUS vol_is_dynamic(PIRP Irp) {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
-    UINT8* buf;
+    uint8_t* buf;
 
     if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength == 0 || !Irp->AssociatedIrp.SystemBuffer)
         return STATUS_INVALID_PARAMETER;
 
-    buf = (UINT8*)Irp->AssociatedIrp.SystemBuffer;
+    buf = (uint8_t*)Irp->AssociatedIrp.SystemBuffer;
 
     *buf = 1;
 
@@ -426,13 +425,13 @@ static NTSTATUS vol_check_verify(volume_device_extension* vde) {
     NTSTATUS Status;
     LIST_ENTRY* le;
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     le = pdode->children.Flink;
     while (le != &pdode->children) {
         volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
 
-        Status = dev_ioctl(vc->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, NULL, 0, FALSE, NULL);
+        Status = dev_ioctl(vc->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, NULL, 0, false, NULL);
         if (!NT_SUCCESS(Status))
             goto end;
 
@@ -458,14 +457,14 @@ static NTSTATUS vol_get_disk_extents(volume_device_extension* vde, PIRP Irp) {
     if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(VOLUME_DISK_EXTENTS))
         return STATUS_BUFFER_TOO_SMALL;
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     le = pdode->children.Flink;
     while (le != &pdode->children) {
         volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
         VOLUME_DISK_EXTENTS ext2;
 
-        Status = dev_ioctl(vc->devobj, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, &ext2, sizeof(VOLUME_DISK_EXTENTS), FALSE, NULL);
+        Status = dev_ioctl(vc->devobj, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, &ext2, sizeof(VOLUME_DISK_EXTENTS), false, NULL);
         if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
             ERR("IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS returned %08x\n", Status);
             goto end;
@@ -503,7 +502,7 @@ static NTSTATUS vol_get_disk_extents(volume_device_extension* vde, PIRP Irp) {
         volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
 
         Status = dev_ioctl(vc->devobj, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, ext3,
-                           (ULONG)offsetof(VOLUME_DISK_EXTENTS, Extents[0]) + (max_extents * sizeof(DISK_EXTENT)), FALSE, NULL);
+                           (ULONG)offsetof(VOLUME_DISK_EXTENTS, Extents[0]) + (max_extents * sizeof(DISK_EXTENT)), false, NULL);
         if (!NT_SUCCESS(Status)) {
             ERR("IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS returned %08x\n", Status);
             ExFreePool(ext3);
@@ -541,18 +540,18 @@ static NTSTATUS vol_is_writable(volume_device_extension* vde) {
     pdo_device_extension* pdode = vde->pdode;
     NTSTATUS Status;
     LIST_ENTRY* le;
-    BOOL writable = FALSE;
+    bool writable = false;
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     le = pdode->children.Flink;
     while (le != &pdode->children) {
         volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
 
-        Status = dev_ioctl(vc->devobj, IOCTL_DISK_IS_WRITABLE, NULL, 0, NULL, 0, TRUE, NULL);
+        Status = dev_ioctl(vc->devobj, IOCTL_DISK_IS_WRITABLE, NULL, 0, NULL, 0, true, NULL);
 
         if (NT_SUCCESS(Status)) {
-            writable = TRUE;
+            writable = true;
             break;
         } else if (Status != STATUS_MEDIA_WRITE_PROTECTED)
             goto end;
@@ -581,7 +580,7 @@ static NTSTATUS vol_get_length(volume_device_extension* vde, PIRP Irp) {
 
     gli->Length.QuadPart = 0;
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     le = pdode->children.Flink;
     while (le != &pdode->children) {
@@ -604,7 +603,7 @@ static NTSTATUS vol_get_drive_geometry(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
     pdo_device_extension* pdode = vde->pdode;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     DISK_GEOMETRY* geom;
-    UINT64 length;
+    uint64_t length;
     LIST_ENTRY* le;
 
     if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DISK_GEOMETRY))
@@ -612,7 +611,7 @@ static NTSTATUS vol_get_drive_geometry(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
 
     length = 0;
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     le = pdode->children.Flink;
     while (le != &pdode->children) {
@@ -664,7 +663,7 @@ static NTSTATUS vol_get_device_number(volume_device_extension* vde, PIRP Irp) {
     if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_DEVICE_NUMBER))
         return STATUS_BUFFER_TOO_SMALL;
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     if (IsListEmpty(&pdode->children) || pdode->num_children > 1) {
         ExReleaseResourceLite(&pdode->child_lock);
@@ -692,17 +691,13 @@ static NTSTATUS vol_get_device_number(volume_device_extension* vde, PIRP Irp) {
 }
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI vol_ioctl_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#else
-static NTSTATUS vol_ioctl_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#endif
+static NTSTATUS __stdcall vol_ioctl_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
     KEVENT* event = conptr;
 
     UNUSED(DeviceObject);
     UNUSED(Irp);
 
-    KeSetEvent(event, 0, FALSE);
+    KeSetEvent(event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
@@ -717,7 +712,7 @@ static NTSTATUS vol_ioctl_passthrough(volume_device_extension* vde, PIRP Irp) {
 
     TRACE("(%p, %p)\n", vde, Irp);
 
-    ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
+    ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
     if (IsListEmpty(&pdode->children)) {
         ExReleaseResourceLite(&pdode->child_lock);
@@ -731,7 +726,7 @@ static NTSTATUS vol_ioctl_passthrough(volume_device_extension* vde, PIRP Irp) {
         return STATUS_INVALID_DEVICE_REQUEST;
     }
 
-    Irp2 = IoAllocateIrp(vc->devobj->StackSize, FALSE);
+    Irp2 = IoAllocateIrp(vc->devobj->StackSize, false);
 
     if (!Irp2) {
         ERR("IoAllocateIrp failed\n");
@@ -744,6 +739,7 @@ static NTSTATUS vol_ioctl_passthrough(volume_device_extension* vde, PIRP Irp) {
 
     IrpSp2->MajorFunction = IrpSp->MajorFunction;
     IrpSp2->MinorFunction = IrpSp->MinorFunction;
+    IrpSp2->FileObject = vc->fileobj;
 
     IrpSp2->Parameters.DeviceIoControl.OutputBufferLength = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
     IrpSp2->Parameters.DeviceIoControl.InputBufferLength = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
@@ -755,14 +751,14 @@ static NTSTATUS vol_ioctl_passthrough(volume_device_extension* vde, PIRP Irp) {
     Irp2->UserBuffer = Irp->UserBuffer;
     Irp2->Flags = Irp->Flags;
 
-    KeInitializeEvent(&Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&Event, NotificationEvent, false);
 
-    IoSetCompletionRoutine(Irp2, vol_ioctl_completion, &Event, TRUE, TRUE, TRUE);
+    IoSetCompletionRoutine(Irp2, vol_ioctl_completion, &Event, true, true, true);
 
     Status = IoCallDriver(vc->devobj, Irp2);
 
     if (Status == STATUS_PENDING) {
-        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+        KeWaitForSingleObject(&Event, Executive, KernelMode, false, NULL);
         Status = Irp2->IoStatus.Status;
     }
 
@@ -882,21 +878,6 @@ NTSTATUS vol_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     return STATUS_INVALID_DEVICE_REQUEST;
 }
 
-NTSTATUS vol_power(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
-    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
-    NTSTATUS Status;
-
-    TRACE("(%p, %p)\n", DeviceObject, Irp);
-
-    if (IrpSp->MinorFunction == IRP_MN_SET_POWER || IrpSp->MinorFunction == IRP_MN_QUERY_POWER)
-        Irp->IoStatus.Status = STATUS_SUCCESS;
-
-    Status = Irp->IoStatus.Status;
-    PoStartNextPowerIrp(Irp);
-
-    return Status;
-}
-
 NTSTATUS mountmgr_add_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath) {
     NTSTATUS Status;
     ULONG mmdltsize;
@@ -915,7 +896,7 @@ NTSTATUS mountmgr_add_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devp
     RtlCopyMemory(&mmdlt->DeviceName, devpath->Buffer, devpath->Length);
     TRACE("mmdlt = %.*S\n", mmdlt->DeviceNameLength / sizeof(WCHAR), mmdlt->DeviceName);
 
-    Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER, mmdlt, mmdltsize, &mmdli, sizeof(MOUNTMGR_DRIVE_LETTER_INFORMATION), FALSE, NULL);
+    Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER, mmdlt, mmdltsize, &mmdli, sizeof(MOUNTMGR_DRIVE_LETTER_INFORMATION), false, NULL);
 
     if (!NT_SUCCESS(Status))
         ERR("IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER returned %08x\n", Status);
@@ -928,11 +909,7 @@ NTSTATUS mountmgr_add_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devp
 }
 
 _Function_class_(DRIVER_NOTIFICATION_CALLBACK_ROUTINE)
-#ifdef __REACTOS__
-NTSTATUS NTAPI pnp_removal(PVOID NotificationStructure, PVOID Context) {
-#else
-NTSTATUS pnp_removal(PVOID NotificationStructure, PVOID Context) {
-#endif
+NTSTATUS __stdcall pnp_removal(PVOID NotificationStructure, PVOID Context) {
     TARGET_DEVICE_REMOVAL_NOTIFICATION* tdrn = (TARGET_DEVICE_REMOVAL_NOTIFICATION*)NotificationStructure;
     pdo_device_extension* pdode = (pdo_device_extension*)Context;
 
@@ -946,12 +923,12 @@ NTSTATUS pnp_removal(PVOID NotificationStructure, PVOID Context) {
     return STATUS_SUCCESS;
 }
 
-static BOOL allow_degraded_mount(BTRFS_UUID* uuid) {
+static bool allow_degraded_mount(BTRFS_UUID* uuid) {
     HANDLE h;
     NTSTATUS Status;
     OBJECT_ATTRIBUTES oa;
     UNICODE_STRING path, adus;
-    UINT32 degraded = mount_allow_degraded;
+    uint32_t degraded = mount_allow_degraded;
     ULONG i, j, kvfilen, retlen;
     KEY_VALUE_FULL_INFORMATION* kvfi;
 
@@ -960,7 +937,7 @@ static BOOL allow_degraded_mount(BTRFS_UUID* uuid) {
 
     if (!path.Buffer) {
         ERR("out of memory\n");
-        return FALSE;
+        return false;
     }
 
     RtlCopyMemory(path.Buffer, registry_path.Buffer, registry_path.Length);
@@ -988,7 +965,7 @@ static BOOL allow_degraded_mount(BTRFS_UUID* uuid) {
     if (!kvfi) {
         ERR("out of memory\n");
         ExFreePool(path.Buffer);
-        return FALSE;
+        return false;
     }
 
     Status = ZwOpenKey(&h, KEY_QUERY_VALUE, &oa);
@@ -1003,8 +980,8 @@ static BOOL allow_degraded_mount(BTRFS_UUID* uuid) {
     adus.Length = adus.MaximumLength = sizeof(adus.Buffer) - sizeof(WCHAR);
 
     if (NT_SUCCESS(ZwQueryValueKey(h, &adus, KeyValueFullInformation, kvfi, kvfilen, &retlen))) {
-        if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(UINT32)) {
-            UINT32* val = (UINT32*)((UINT8*)kvfi + kvfi->DataOffset);
+        if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(uint32_t)) {
+            uint32_t* val = (uint32_t*)((uint8_t*)kvfi + kvfi->DataOffset);
 
             degraded = *val;
         }
@@ -1020,21 +997,126 @@ end:
     return degraded;
 }
 
-void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath, UINT64 length, ULONG disk_num, ULONG part_num) {
+typedef struct {
+    PIO_WORKITEM work_item;
+    pdo_device_extension* pdode;
+} drive_letter_callback_context;
+
+_Function_class_(IO_WORKITEM_ROUTINE)
+static void __stdcall drive_letter_callback(PDEVICE_OBJECT DeviceObject, PVOID con) {
+    drive_letter_callback_context* context = con;
+    NTSTATUS Status;
+    UNICODE_STRING mmdevpath;
+    PDEVICE_OBJECT mountmgr;
+    PFILE_OBJECT mountmgrfo;
+    LIST_ENTRY* le;
+
+    UNUSED(DeviceObject);
+
+    RtlInitUnicodeString(&mmdevpath, MOUNTMGR_DEVICE_NAME);
+    Status = IoGetDeviceObjectPointer(&mmdevpath, FILE_READ_ATTRIBUTES, &mountmgrfo, &mountmgr);
+    if (!NT_SUCCESS(Status)) {
+        ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
+        return;
+    }
+
+    ExAcquireResourceSharedLite(&pdo_list_lock, true);
+
+    le = pdo_list.Flink;
+    while (le != &pdo_list) {
+        pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
+
+        if (pdode == context->pdode) {
+            LIST_ENTRY* le2;
+
+            ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
+
+            le2 = pdode->children.Flink;
+
+            while (le2 != &pdode->children) {
+                UNICODE_STRING name;
+
+                volume_child* vc = CONTAINING_RECORD(le2, volume_child, list_entry);
+
+                name.Length = name.MaximumLength = vc->pnp_name.Length + (3 * sizeof(WCHAR));
+                name.Buffer = ExAllocatePoolWithTag(PagedPool, name.Length, ALLOC_TAG);
+
+                if (!name.Buffer) {
+                    ERR("out of memory\n");
+
+                    ExReleaseResourceLite(&pdode->child_lock);
+                    ExReleaseResourceLite(&pdo_list_lock);
+                    ObDereferenceObject(mountmgrfo);
+                    IoFreeWorkItem(context->work_item);
+                    return;
+                }
+
+                RtlCopyMemory(name.Buffer, L"\\??", 3 * sizeof(WCHAR));
+                RtlCopyMemory(&name.Buffer[3], vc->pnp_name.Buffer, vc->pnp_name.Length);
+
+                Status = remove_drive_letter(mountmgr, &name);
+
+                if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND)
+                    WARN("remove_drive_letter returned %08x\n", Status);
+
+                ExFreePool(name.Buffer);
+
+                vc->had_drive_letter = NT_SUCCESS(Status);
+
+                le2 = le2->Flink;
+            }
+
+            ExReleaseResourceLite(&pdode->child_lock);
+            ExReleaseResourceLite(&pdo_list_lock);
+            ObDereferenceObject(mountmgrfo);
+            IoFreeWorkItem(context->work_item);
+            return;
+        }
+
+        le = le->Flink;
+    }
+
+    ExReleaseResourceLite(&pdo_list_lock);
+
+    ObDereferenceObject(mountmgrfo);
+    IoFreeWorkItem(context->work_item);
+}
+
+static void add_drive_letter_work_item(pdo_device_extension* pdode) {
+    PIO_WORKITEM work_item;
+    drive_letter_callback_context* context;
+
+    work_item = IoAllocateWorkItem(master_devobj);
+
+    context = ExAllocatePoolWithTag(PagedPool, sizeof(drive_letter_callback_context), ALLOC_TAG);
+
+    if (!context) {
+        ERR("out of memory\n");
+        IoFreeWorkItem(work_item);
+        return;
+    }
+
+    context->work_item = work_item;
+    context->pdode = pdode;
+
+    IoQueueWorkItem(work_item, drive_letter_callback, DelayedWorkQueue, context);
+}
+
+void add_volume_device(superblock* sb, PUNICODE_STRING devpath, uint64_t length, ULONG disk_num, ULONG part_num) {
     NTSTATUS Status;
     LIST_ENTRY* le;
     PDEVICE_OBJECT DeviceObject;
     volume_child* vc;
     PFILE_OBJECT FileObject;
     UNICODE_STRING devpath2;
-    BOOL inserted = FALSE, new_pdo = FALSE;
+    bool inserted = false, new_pdo = false;
     pdo_device_extension* pdode = NULL;
     PDEVICE_OBJECT pdo = NULL;
 
     if (devpath->Length == 0)
         return;
 
-    ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&pdo_list_lock, true);
 
     le = pdo_list.Flink;
     while (le != &pdo_list) {
@@ -1074,7 +1156,7 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
             }
         } else {
             Status = IoCreateDevice(drvobj, sizeof(pdo_device_extension), NULL, FILE_DEVICE_DISK,
-                                    FILE_AUTOGENERATED_DEVICE_NAME | FILE_DEVICE_SECURE_OPEN, FALSE, &pdo);
+                                    FILE_AUTOGENERATED_DEVICE_NAME | FILE_DEVICE_SECURE_OPEN, false, &pdo);
             if (!NT_SUCCESS(Status)) {
                 ERR("IoCreateDevice returned %08x\n", Status);
                 ExReleaseResourceLite(&pdo_list_lock);
@@ -1100,11 +1182,11 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
         pdo->Flags &= ~DO_DEVICE_INITIALIZING;
         pdo->SectorSize = (USHORT)sb->sector_size;
 
-        ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
 
-        new_pdo = TRUE;
+        new_pdo = true;
     } else {
-        ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
         ExConvertExclusiveToSharedLite(&pdo_list_lock);
 
         le = pdode->children.Flink;
@@ -1167,10 +1249,10 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
     }
 
     vc->size = length;
-    vc->seeding = sb->flags & BTRFS_SUPERBLOCK_FLAGS_SEEDING ? TRUE : FALSE;
+    vc->seeding = sb->flags & BTRFS_SUPERBLOCK_FLAGS_SEEDING ? true : false;
     vc->disk_num = disk_num;
     vc->part_num = part_num;
-    vc->had_drive_letter = FALSE;
+    vc->had_drive_letter = false;
 
     le = pdode->children.Flink;
     while (le != &pdode->children) {
@@ -1181,7 +1263,7 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
                 pdode->num_children = sb->num_devices;
 
             InsertHeadList(vc2->list_entry.Blink, &vc->list_entry);
-            inserted = TRUE;
+            inserted = true;
             break;
         }
 
@@ -1196,7 +1278,7 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
     if (pdode->vde && pdode->vde->mounted_device) {
         device_extension* Vcb = pdode->vde->mounted_device->DeviceExtension;
 
-        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
         le = Vcb->devices.Flink;
         while (le != &Vcb->devices) {
@@ -1206,7 +1288,7 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
                 dev->devobj = DeviceObject;
                 dev->disk_num = disk_num;
                 dev->part_num = part_num;
-                init_device(Vcb, dev, FALSE);
+                init_device(Vcb, dev, false);
                 break;
             }
 
@@ -1217,77 +1299,37 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
     }
 
     if (DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) {
-        pdode->removable = TRUE;
+        pdode->removable = true;
 
         if (pdode->vde && pdode->vde->device)
             pdode->vde->device->Characteristics |= FILE_REMOVABLE_MEDIA;
     }
 
     if (pdode->num_children == pdode->children_loaded || (pdode->children_loaded == 1 && allow_degraded_mount(&sb->uuid))) {
-        if (pdode->num_children == 1) {
-            Status = remove_drive_letter(mountmgr, devpath);
-            if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND)
-                WARN("remove_drive_letter returned %08x\n", Status);
-
-            vc->had_drive_letter = NT_SUCCESS(Status);
-        } else {
-            le = pdode->children.Flink;
-
-            while (le != &pdode->children) {
-                UNICODE_STRING name;
-
-                vc = CONTAINING_RECORD(le, volume_child, list_entry);
-
-                name.Length = name.MaximumLength = vc->pnp_name.Length + (3 * sizeof(WCHAR));
-                name.Buffer = ExAllocatePoolWithTag(PagedPool, name.Length, ALLOC_TAG);
-
-                if (!name.Buffer) {
-                    ERR("out of memory\n");
-
-                    ExReleaseResourceLite(&pdode->child_lock);
-                    ExReleaseResourceLite(&pdo_list_lock);
-
-                    goto fail;
-                }
-
-                RtlCopyMemory(name.Buffer, L"\\??", 3 * sizeof(WCHAR));
-                RtlCopyMemory(&name.Buffer[3], vc->pnp_name.Buffer, vc->pnp_name.Length);
-
-                Status = remove_drive_letter(mountmgr, &name);
-
-                if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND)
-                    WARN("remove_drive_letter returned %08x\n", Status);
-
-                ExFreePool(name.Buffer);
-
-                vc->had_drive_letter = NT_SUCCESS(Status);
-
-                le = le->Flink;
-            }
-        }
-
         if ((!new_pdo || !no_pnp) && pdode->vde) {
-            Status = IoSetDeviceInterfaceState(&pdode->vde->bus_name, TRUE);
+            Status = IoSetDeviceInterfaceState(&pdode->vde->bus_name, true);
             if (!NT_SUCCESS(Status))
                 WARN("IoSetDeviceInterfaceState returned %08x\n", Status);
         }
+
+        add_drive_letter_work_item(pdode);
     }
 
     ExReleaseResourceLite(&pdode->child_lock);
 
-    if (new_pdo) {
-        control_device_extension* cde = master_devobj->DeviceExtension;
-
+    if (new_pdo)
         InsertTailList(&pdo_list, &pdode->list_entry);
 
-        if (!no_pnp)
-            IoInvalidateDeviceRelations(cde->buspdo, BusRelations);
-    }
-
     ExReleaseResourceLite(&pdo_list_lock);
 
-    if (new_pdo && no_pnp)
-        AddDevice(drvobj, pdo);
+    if (new_pdo) {
+        if (no_pnp)
+            AddDevice(drvobj, pdo);
+        else {
+            bus_device_extension* bde = busobj->DeviceExtension;
+            IoInvalidateDeviceRelations(bde->buspdo, BusRelations);
+        }
+    }
 
     return;
 
diff --git a/drivers/filesystems/btrfs/worker-thread.c b/drivers/filesystems/btrfs/worker-thread.c
index 4344c6cf410..0fcf5868953 100644
--- a/drivers/filesystems/btrfs/worker-thread.c
+++ b/drivers/filesystems/btrfs/worker-thread.c
@@ -23,29 +23,29 @@ typedef struct {
     WORK_QUEUE_ITEM item;
 } job_info;
 
-void do_read_job(PIRP Irp) {
+NTSTATUS do_read_job(PIRP Irp) {
     NTSTATUS Status;
     ULONG bytes_read;
-    BOOL top_level = is_top_level(Irp);
+    bool top_level = is_top_level(Irp);
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     fcb* fcb = FileObject->FsContext;
-    BOOL fcb_lock = FALSE;
+    bool acquired_fcb_lock = false;
 
     Irp->IoStatus.Information = 0;
 
     if (!ExIsResourceAcquiredSharedLite(fcb->Header.Resource)) {
-        ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
-        fcb_lock = TRUE;
+        ExAcquireResourceSharedLite(fcb->Header.Resource, true);
+        acquired_fcb_lock = true;
     }
 
     _SEH2_TRY {
-        Status = do_read(Irp, TRUE, &bytes_read);
+        Status = do_read(Irp, true, &bytes_read);
     } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
         Status = _SEH2_GetExceptionCode();
     } _SEH2_END;
 
-    if (fcb_lock)
+    if (acquired_fcb_lock)
         ExReleaseResourceLite(fcb->Header.Resource);
 
     if (!NT_SUCCESS(Status))
@@ -61,14 +61,16 @@ void do_read_job(PIRP Irp) {
         IoSetTopLevelIrp(NULL);
 
     TRACE("returning %08x\n", Status);
+
+    return Status;
 }
 
-void do_write_job(device_extension* Vcb, PIRP Irp) {
-    BOOL top_level = is_top_level(Irp);
+NTSTATUS do_write_job(device_extension* Vcb, PIRP Irp) {
+    bool top_level = is_top_level(Irp);
     NTSTATUS Status;
 
     _SEH2_TRY {
-        Status = write_file(Vcb, Irp, TRUE, TRUE);
+        Status = write_file(Vcb, Irp, true, true);
     } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
         Status = _SEH2_GetExceptionCode();
     } _SEH2_END;
@@ -86,14 +88,12 @@ void do_write_job(device_extension* Vcb, PIRP Irp) {
         IoSetTopLevelIrp(NULL);
 
     TRACE("returning %08x\n", Status);
+
+    return Status;
 }
 
 _Function_class_(WORKER_THREAD_ROUTINE)
-#ifdef __REACTOS__
-static void NTAPI do_job(void* context) {
-#else
-static void do_job(void* context) {
-#endif
+static void __stdcall do_job(void* context) {
     job_info* ji = context;
     PIO_STACK_LOCATION IrpSp = ji->Irp ? IoGetCurrentIrpStackLocation(ji->Irp) : NULL;
 
@@ -106,13 +106,13 @@ static void do_job(void* context) {
     ExFreePool(ji);
 }
 
-BOOL add_thread_job(device_extension* Vcb, PIRP Irp) {
+bool add_thread_job(device_extension* Vcb, PIRP Irp) {
     job_info* ji;
 
     ji = ExAllocatePoolWithTag(NonPagedPool, sizeof(job_info), ALLOC_TAG);
     if (!ji) {
         ERR("out of memory\n");
-        return FALSE;
+        return false;
     }
 
     ji->Vcb = Vcb;
@@ -133,15 +133,15 @@ BOOL add_thread_job(device_extension* Vcb, PIRP Irp) {
         } else {
             ERR("unexpected major function %u\n", IrpSp->MajorFunction);
             ExFreePool(ji);
-            return FALSE;
+            return false;
         }
 
-        Mdl = IoAllocateMdl(Irp->UserBuffer, len, FALSE, FALSE, Irp);
+        Mdl = IoAllocateMdl(Irp->UserBuffer, len, false, false, Irp);
 
         if (!Mdl) {
             ERR("out of memory\n");
             ExFreePool(ji);
-            return FALSE;
+            return false;
         }
 
         _SEH2_TRY {
@@ -160,5 +160,5 @@ BOOL add_thread_job(device_extension* Vcb, PIRP Irp) {
     ExInitializeWorkItem(&ji->item, do_job, ji);
     ExQueueWorkItem(&ji->item, DelayedWorkQueue);
 
-    return TRUE;
+    return true;
 }
diff --git a/drivers/filesystems/btrfs/write.c b/drivers/filesystems/btrfs/write.c
index a38ea7fb890..c982e939b17 100644
--- a/drivers/filesystems/btrfs/write.c
+++ b/drivers/filesystems/btrfs/write.c
@@ -18,47 +18,43 @@
 #include "btrfs_drv.h"
 
 typedef struct {
-    UINT64 start;
-    UINT64 end;
-    UINT8* data;
+    uint64_t start;
+    uint64_t end;
+    uint8_t* data;
     PMDL mdl;
-    UINT64 irp_offset;
+    uint64_t irp_offset;
 } write_stripe;
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI write_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr);
-#else
-static NTSTATUS write_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr);
-#endif
+static NTSTATUS __stdcall write_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr);
 
 static void remove_fcb_extent(fcb* fcb, extent* ext, LIST_ENTRY* rollback);
 
 extern tPsUpdateDiskCounters fPsUpdateDiskCounters;
 extern tCcCopyWriteEx fCcCopyWriteEx;
 extern tFsRtlUpdateDiskCounters fFsRtlUpdateDiskCounters;
-extern BOOL diskacc;
+extern bool diskacc;
 
-BOOL find_data_address_in_chunk(device_extension* Vcb, chunk* c, UINT64 length, UINT64* address) {
+bool find_data_address_in_chunk(device_extension* Vcb, chunk* c, uint64_t length, uint64_t* address) {
     LIST_ENTRY* le;
     space* s;
 
-    TRACE("(%p, %llx, %llx, %p)\n", Vcb, c->offset, length, address);
+    TRACE("(%p, %I64x, %I64x, %p)\n", Vcb, c->offset, length, address);
 
     if (length > c->chunk_item->size - c->used)
-        return FALSE;
+        return false;
 
     if (!c->cache_loaded) {
         NTSTATUS Status = load_cache_chunk(Vcb, c, NULL);
 
         if (!NT_SUCCESS(Status)) {
             ERR("load_cache_chunk returned %08x\n", Status);
-            return FALSE;
+            return false;
         }
     }
 
     if (IsListEmpty(&c->space_size))
-        return FALSE;
+        return false;
 
     le = c->space_size.Flink;
     while (le != &c->space_size) {
@@ -66,15 +62,15 @@ BOOL find_data_address_in_chunk(device_extension* Vcb, chunk* c, UINT64 length,
 
         if (s->size == length) {
             *address = s->address;
-            return TRUE;
+            return true;
         } else if (s->size < length) {
             if (le == c->space_size.Flink)
-                return FALSE;
+                return false;
 
             s = CONTAINING_RECORD(le->Blink, space, list_entry_size);
 
             *address = s->address;
-            return TRUE;
+            return true;
         }
 
         le = le->Flink;
@@ -84,16 +80,16 @@ BOOL find_data_address_in_chunk(device_extension* Vcb, chunk* c, UINT64 length,
 
     if (s->size > length) {
         *address = s->address;
-        return TRUE;
+        return true;
     }
 
-    return FALSE;
+    return false;
 }
 
-chunk* get_chunk_from_address(device_extension* Vcb, UINT64 address) {
+chunk* get_chunk_from_address(device_extension* Vcb, uint64_t address) {
     LIST_ENTRY* le2;
 
-    ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
     le2 = Vcb->chunks.Flink;
     while (le2 != &Vcb->chunks) {
@@ -117,8 +113,8 @@ typedef struct {
     device* device;
 } stripe;
 
-static UINT64 find_new_chunk_address(device_extension* Vcb, UINT64 size) {
-    UINT64 lastaddr;
+static uint64_t find_new_chunk_address(device_extension* Vcb, uint64_t size) {
+    uint64_t lastaddr;
     LIST_ENTRY* le;
 
     lastaddr = 0xc00000;
@@ -138,8 +134,8 @@ static UINT64 find_new_chunk_address(device_extension* Vcb, UINT64 size) {
     return lastaddr;
 }
 
-static BOOL find_new_dup_stripes(device_extension* Vcb, stripe* stripes, UINT64 max_stripe_size, BOOL full_size) {
-    UINT64 devusage = 0xffffffffffffffff;
+static bool find_new_dup_stripes(device_extension* Vcb, stripe* stripes, uint64_t max_stripe_size, bool full_size) {
+    uint64_t devusage = 0xffffffffffffffff;
     space *devdh1 = NULL, *devdh2 = NULL;
     LIST_ENTRY* le;
     device* dev2 = NULL;
@@ -150,7 +146,7 @@ static BOOL find_new_dup_stripes(device_extension* Vcb, stripe* stripes, UINT64
         device* dev = CONTAINING_RECORD(le, device, list_entry);
 
         if (!dev->readonly && !dev->reloc && dev->devobj) {
-            UINT64 usage = (dev->devitem.bytes_used * 4096) / dev->devitem.num_bytes;
+            uint64_t usage = (dev->devitem.bytes_used * 4096) / dev->devitem.num_bytes;
 
             // favour devices which have been used the least
             if (usage < devusage) {
@@ -184,12 +180,12 @@ static BOOL find_new_dup_stripes(device_extension* Vcb, stripe* stripes, UINT64
     }
 
     if (!devdh1) {
-        UINT64 size = 0;
+        uint64_t size = 0;
 
         // Can't find hole of at least max_stripe_size; look for the largest one we can find
 
         if (full_size)
-            return FALSE;
+            return false;
 
         le = Vcb->devices.Flink;
         while (le != &Vcb->devices) {
@@ -213,7 +209,7 @@ static BOOL find_new_dup_stripes(device_extension* Vcb, stripe* stripes, UINT64
                     }
 
                     if (dh1) {
-                        UINT64 devsize;
+                        uint64_t devsize;
 
                         if (dh2)
                             devsize = max(dh1->size / 2, min(dh1->size, dh2->size));
@@ -239,18 +235,18 @@ static BOOL find_new_dup_stripes(device_extension* Vcb, stripe* stripes, UINT64
         }
 
         if (!devdh1)
-            return FALSE;
+            return false;
     }
 
     stripes[0].device = stripes[1].device = dev2;
     stripes[0].dh = devdh1;
     stripes[1].dh = devdh2;
 
-    return TRUE;
+    return true;
 }
 
-static BOOL find_new_stripe(device_extension* Vcb, stripe* stripes, UINT16 i, UINT64 max_stripe_size, BOOL allow_missing, BOOL full_size) {
-    UINT64 k, devusage = 0xffffffffffffffff;
+static bool find_new_stripe(device_extension* Vcb, stripe* stripes, uint16_t i, uint64_t max_stripe_size, bool allow_missing, bool full_size) {
+    uint64_t k, devusage = 0xffffffffffffffff;
     space* devdh = NULL;
     LIST_ENTRY* le;
     device* dev2 = NULL;
@@ -258,8 +254,8 @@ static BOOL find_new_stripe(device_extension* Vcb, stripe* stripes, UINT16 i, UI
     le = Vcb->devices.Flink;
     while (le != &Vcb->devices) {
         device* dev = CONTAINING_RECORD(le, device, list_entry);
-        UINT64 usage;
-        BOOL skip = FALSE;
+        uint64_t usage;
+        bool skip = false;
 
         if (dev->readonly || dev->reloc || (!dev->devobj && !allow_missing)) {
             le = le->Flink;
@@ -270,7 +266,7 @@ static BOOL find_new_stripe(device_extension* Vcb, stripe* stripes, UINT16 i, UI
         if (i > 0) {
             for (k = 0; k < i; k++) {
                 if (stripes[k].device == dev) {
-                    skip = TRUE;
+                    skip = true;
                     break;
                 }
             }
@@ -309,12 +305,12 @@ static BOOL find_new_stripe(device_extension* Vcb, stripe* stripes, UINT16 i, UI
         // Can't find hole of at least max_stripe_size; look for the largest one we can find
 
         if (full_size)
-            return FALSE;
+            return false;
 
         le = Vcb->devices.Flink;
         while (le != &Vcb->devices) {
             device* dev = CONTAINING_RECORD(le, device, list_entry);
-            BOOL skip = FALSE;
+            bool skip = false;
 
             if (dev->readonly || dev->reloc || (!dev->devobj && !allow_missing)) {
                 le = le->Flink;
@@ -325,7 +321,7 @@ static BOOL find_new_stripe(device_extension* Vcb, stripe* stripes, UINT16 i, UI
             if (i > 0) {
                 for (k = 0; k < i; k++) {
                     if (stripes[k].device == dev) {
-                        skip = TRUE;
+                        skip = true;
                         break;
                     }
                 }
@@ -353,22 +349,22 @@ static BOOL find_new_stripe(device_extension* Vcb, stripe* stripes, UINT16 i, UI
         }
 
         if (!devdh)
-            return FALSE;
+            return false;
     }
 
     stripes[i].dh = devdh;
     stripes[i].device = dev2;
 
-    return TRUE;
+    return true;
 }
 
-NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_size) {
+NTSTATUS alloc_chunk(device_extension* Vcb, uint64_t flags, chunk** pc, bool full_size) {
     NTSTATUS Status;
-    UINT64 max_stripe_size, max_chunk_size, stripe_size, stripe_length, factor;
-    UINT64 total_size = 0, logaddr;
-    UINT16 i, type, num_stripes, sub_stripes, max_stripes, min_stripes, allowed_missing;
+    uint64_t max_stripe_size, max_chunk_size, stripe_size, stripe_length, factor;
+    uint64_t total_size = 0, logaddr;
+    uint16_t i, type, num_stripes, sub_stripes, max_stripes, min_stripes, allowed_missing;
     stripe* stripes = NULL;
-    UINT16 cisize;
+    uint16_t cisize;
     CHUNK_ITEM_STRIPE* cis;
     chunk* c = NULL;
     space* s = NULL;
@@ -382,7 +378,7 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_
         le = le->Flink;
     }
 
-    TRACE("total_size = %llx\n", total_size);
+    TRACE("total_size = %I64x\n", total_size);
 
     // We purposely check for DATA first - mixed blocks have the same size
     // as DATA ones.
@@ -412,7 +408,7 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_
         allowed_missing = 0;
     } else if (flags & BLOCK_FLAG_RAID0) {
         min_stripes = 2;
-        max_stripes = (UINT16)min(0xffff, Vcb->superblock.num_devices);
+        max_stripes = (uint16_t)min(0xffff, Vcb->superblock.num_devices);
         sub_stripes = 0;
         type = BLOCK_FLAG_RAID0;
         allowed_missing = 0;
@@ -424,13 +420,13 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_
         allowed_missing = 1;
     } else if (flags & BLOCK_FLAG_RAID10) {
         min_stripes = 4;
-        max_stripes = (UINT16)min(0xffff, Vcb->superblock.num_devices);
+        max_stripes = (uint16_t)min(0xffff, Vcb->superblock.num_devices);
         sub_stripes = 2;
         type = BLOCK_FLAG_RAID10;
         allowed_missing = 1;
     } else if (flags & BLOCK_FLAG_RAID5) {
         min_stripes = 3;
-        max_stripes = (UINT16)min(0xffff, Vcb->superblock.num_devices);
+        max_stripes = (uint16_t)min(0xffff, Vcb->superblock.num_devices);
         sub_stripes = 1;
         type = BLOCK_FLAG_RAID5;
         allowed_missing = 1;
@@ -453,7 +449,7 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_
         max_stripe_size = max_chunk_size / min_stripes;
     }
 
-    TRACE("would allocate a new chunk of %llx bytes and stripe %llx\n", max_chunk_size, max_stripe_size);
+    TRACE("would allocate a new chunk of %I64x bytes and stripe %I64x\n", max_chunk_size, max_stripe_size);
 
     stripes = ExAllocatePoolWithTag(PagedPool, sizeof(stripe) * max_stripes, ALLOC_TAG);
     if (!stripes) {
@@ -473,7 +469,7 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_
             num_stripes = max_stripes;
     } else {
         for (i = 0; i < max_stripes; i++) {
-            if (!find_new_stripe(Vcb, stripes, i, max_stripe_size, FALSE, full_size))
+            if (!find_new_stripe(Vcb, stripes, i, max_stripe_size, false, full_size))
                 break;
             else
                 num_stripes++;
@@ -481,10 +477,10 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_
     }
 
     if (num_stripes < min_stripes && Vcb->options.allow_degraded && allowed_missing > 0) {
-        UINT16 added_missing = 0;
+        uint16_t added_missing = 0;
 
         for (i = num_stripes; i < max_stripes; i++) {
-            if (!find_new_stripe(Vcb, stripes, i, max_stripe_size, TRUE, full_size))
+            if (!find_new_stripe(Vcb, stripes, i, max_stripe_size, true, full_size))
                 break;
             else {
                 added_missing++;
@@ -563,8 +559,8 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_
     c->chunk_item->root_id = Vcb->extent_root->id;
     c->chunk_item->stripe_length = stripe_length;
     c->chunk_item->type = flags;
-    c->chunk_item->opt_io_alignment = (UINT32)c->chunk_item->stripe_length;
-    c->chunk_item->opt_io_width = (UINT32)c->chunk_item->stripe_length;
+    c->chunk_item->opt_io_alignment = (uint32_t)c->chunk_item->stripe_length;
+    c->chunk_item->opt_io_width = (uint32_t)c->chunk_item->stripe_length;
     c->chunk_item->sector_size = stripes[0].device->devitem.minimal_io_size;
     c->chunk_item->num_stripes = num_stripes;
     c->chunk_item->sub_stripes = sub_stripes;
@@ -598,13 +594,13 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_
     c->offset = logaddr;
     c->used = c->oldused = 0;
     c->cache = c->old_cache = NULL;
-    c->readonly = FALSE;
-    c->reloc = FALSE;
-    c->last_alloc_set = FALSE;
+    c->readonly = false;
+    c->reloc = false;
+    c->last_alloc_set = false;
     c->last_stripe = 0;
-    c->cache_loaded = TRUE;
-    c->changed = FALSE;
-    c->space_changed = FALSE;
+    c->cache_loaded = true;
+    c->changed = false;
+    c->space_changed = false;
     c->balance_num = 0;
 
     InitializeListHead(&c->space);
@@ -614,7 +610,7 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_
 
     InitializeListHead(&c->range_locks);
     ExInitializeResourceLite(&c->range_locks_lock);
-    KeInitializeEvent(&c->range_locks_event, NotificationEvent, FALSE);
+    KeInitializeEvent(&c->range_locks_event, NotificationEvent, false);
 
     InitializeListHead(&c->partial_stripes);
     ExInitializeResourceLite(&c->partial_stripes_lock);
@@ -664,7 +660,7 @@ end:
 
         if (s) ExFreePool(s);
     } else {
-        BOOL done = FALSE;
+        bool done = false;
 
         le = Vcb->chunks.Flink;
         while (le != &Vcb->chunks) {
@@ -672,7 +668,7 @@ end:
 
             if (c2->offset > c->offset) {
                 InsertHeadList(le->Blink, &c->list_entry);
-                done = TRUE;
+                done = true;
                 break;
             }
 
@@ -682,9 +678,9 @@ end:
         if (!done)
             InsertTailList(&Vcb->chunks, &c->list_entry);
 
-        c->created = TRUE;
-        c->changed = TRUE;
-        c->space_changed = TRUE;
+        c->created = true;
+        c->changed = true;
+        c->space_changed = true;
         c->list_entry_balance.Flink = NULL;
 
         *pc = c;
@@ -693,17 +689,17 @@ end:
     return Status;
 }
 
-static NTSTATUS prepare_raid0_write(_Pre_satisfies_(_Curr_->chunk_item->num_stripes>0) _In_ chunk* c, _In_ UINT64 address, _In_reads_bytes_(length) void* data,
-                                    _In_ UINT32 length, _In_ write_stripe* stripes, _In_ PIRP Irp, _In_ UINT64 irp_offset, _In_ write_data_context* wtc) {
-    UINT64 startoff, endoff;
-    UINT16 startoffstripe, endoffstripe, stripenum;
-    UINT64 pos, *stripeoff;
-    UINT32 i;
-    BOOL file_write = Irp && Irp->MdlAddress && (Irp->MdlAddress->ByteOffset == 0);
+static NTSTATUS prepare_raid0_write(_Pre_satisfies_(_Curr_->chunk_item->num_stripes>0) _In_ chunk* c, _In_ uint64_t address, _In_reads_bytes_(length) void* data,
+                                    _In_ uint32_t length, _In_ write_stripe* stripes, _In_ PIRP Irp, _In_ uint64_t irp_offset, _In_ write_data_context* wtc) {
+    uint64_t startoff, endoff;
+    uint16_t startoffstripe, endoffstripe, stripenum;
+    uint64_t pos, *stripeoff;
+    uint32_t i;
+    bool file_write = Irp && Irp->MdlAddress && (Irp->MdlAddress->ByteOffset == 0);
     PMDL master_mdl;
     PFN_NUMBER* pfns;
 
-    stripeoff = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64) * c->chunk_item->num_stripes, ALLOC_TAG);
+    stripeoff = ExAllocatePoolWithTag(PagedPool, sizeof(uint64_t) * c->chunk_item->num_stripes, ALLOC_TAG);
     if (!stripeoff) {
         ERR("out of memory\n");
         return STATUS_INSUFFICIENT_RESOURCES;
@@ -726,7 +722,7 @@ static NTSTATUS prepare_raid0_write(_Pre_satisfies_(_Curr_->chunk_item->num_stri
 
         RtlCopyMemory(wtc->scratch, data, length);
 
-        master_mdl = IoAllocateMdl(wtc->scratch, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl(wtc->scratch, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             return STATUS_INSUFFICIENT_RESOURCES;
@@ -740,7 +736,7 @@ static NTSTATUS prepare_raid0_write(_Pre_satisfies_(_Curr_->chunk_item->num_stri
     } else {
         NTSTATUS Status = STATUS_SUCCESS;
 
-        master_mdl = IoAllocateMdl(data, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl(data, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             return STATUS_INSUFFICIENT_RESOURCES;
@@ -779,7 +775,7 @@ static NTSTATUS prepare_raid0_write(_Pre_satisfies_(_Curr_->chunk_item->num_stri
             stripes[i].end = endoff - (endoff % c->chunk_item->stripe_length);
 
         if (stripes[i].start != stripes[i].end) {
-            stripes[i].mdl = IoAllocateMdl(NULL, (ULONG)(stripes[i].end - stripes[i].start), FALSE, FALSE, NULL);
+            stripes[i].mdl = IoAllocateMdl(NULL, (ULONG)(stripes[i].end - stripes[i].start), false, false, NULL);
             if (!stripes[i].mdl) {
                 ERR("IoAllocateMdl failed\n");
                 ExFreePool(stripeoff);
@@ -789,7 +785,7 @@ static NTSTATUS prepare_raid0_write(_Pre_satisfies_(_Curr_->chunk_item->num_stri
     }
 
     pos = 0;
-    RtlZeroMemory(stripeoff, sizeof(UINT64) * c->chunk_item->num_stripes);
+    RtlZeroMemory(stripeoff, sizeof(uint64_t) * c->chunk_item->num_stripes);
 
     stripenum = startoffstripe;
 
@@ -797,7 +793,7 @@ static NTSTATUS prepare_raid0_write(_Pre_satisfies_(_Curr_->chunk_item->num_stri
         PFN_NUMBER* stripe_pfns = (PFN_NUMBER*)(stripes[stripenum].mdl + 1);
 
         if (pos == 0) {
-            UINT32 writelen = (UINT32)min(stripes[stripenum].end - stripes[stripenum].start,
+            uint32_t writelen = (uint32_t)min(stripes[stripenum].end - stripes[stripenum].start,
                                           c->chunk_item->stripe_length - (stripes[stripenum].start % c->chunk_item->stripe_length));
 
             RtlCopyMemory(stripe_pfns, pfns, writelen * sizeof(PFN_NUMBER) >> PAGE_SHIFT);
@@ -823,13 +819,13 @@ static NTSTATUS prepare_raid0_write(_Pre_satisfies_(_Curr_->chunk_item->num_stri
 }
 
 static NTSTATUS prepare_raid10_write(_Pre_satisfies_(_Curr_->chunk_item->sub_stripes>0&&_Curr_->chunk_item->num_stripes>=_Curr_->chunk_item->sub_stripes) _In_ chunk* c,
-                                     _In_ UINT64 address, _In_reads_bytes_(length) void* data, _In_ UINT32 length, _In_ write_stripe* stripes,
-                                     _In_ PIRP Irp, _In_ UINT64 irp_offset, _In_ write_data_context* wtc) {
-    UINT64 startoff, endoff;
-    UINT16 startoffstripe, endoffstripe, stripenum;
-    UINT64 pos, *stripeoff;
-    UINT32 i;
-    BOOL file_write = Irp && Irp->MdlAddress && (Irp->MdlAddress->ByteOffset == 0);
+                                     _In_ uint64_t address, _In_reads_bytes_(length) void* data, _In_ uint32_t length, _In_ write_stripe* stripes,
+                                     _In_ PIRP Irp, _In_ uint64_t irp_offset, _In_ write_data_context* wtc) {
+    uint64_t startoff, endoff;
+    uint16_t startoffstripe, endoffstripe, stripenum;
+    uint64_t pos, *stripeoff;
+    uint32_t i;
+    bool file_write = Irp && Irp->MdlAddress && (Irp->MdlAddress->ByteOffset == 0);
     PMDL master_mdl;
     PFN_NUMBER* pfns;
 
@@ -854,7 +850,7 @@ static NTSTATUS prepare_raid10_write(_Pre_satisfies_(_Curr_->chunk_item->sub_str
 
         RtlCopyMemory(wtc->scratch, data, length);
 
-        master_mdl = IoAllocateMdl(wtc->scratch, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl(wtc->scratch, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             return STATUS_INSUFFICIENT_RESOURCES;
@@ -868,7 +864,7 @@ static NTSTATUS prepare_raid10_write(_Pre_satisfies_(_Curr_->chunk_item->sub_str
     } else {
         NTSTATUS Status = STATUS_SUCCESS;
 
-        master_mdl = IoAllocateMdl(data, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl(data, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             return STATUS_INSUFFICIENT_RESOURCES;
@@ -892,7 +888,7 @@ static NTSTATUS prepare_raid10_write(_Pre_satisfies_(_Curr_->chunk_item->sub_str
     }
 
     for (i = 0; i < c->chunk_item->num_stripes; i += c->chunk_item->sub_stripes) {
-        UINT16 j;
+        uint16_t j;
 
         if (startoffstripe > i)
             stripes[i].start = startoff - (startoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length;
@@ -908,7 +904,7 @@ static NTSTATUS prepare_raid10_write(_Pre_satisfies_(_Curr_->chunk_item->sub_str
         else
             stripes[i].end = endoff - (endoff % c->chunk_item->stripe_length);
 
-        stripes[i].mdl = IoAllocateMdl(NULL, (ULONG)(stripes[i].end - stripes[i].start), FALSE, FALSE, NULL);
+        stripes[i].mdl = IoAllocateMdl(NULL, (ULONG)(stripes[i].end - stripes[i].start), false, false, NULL);
         if (!stripes[i].mdl) {
             ERR("IoAllocateMdl failed\n");
             return STATUS_INSUFFICIENT_RESOURCES;
@@ -924,19 +920,19 @@ static NTSTATUS prepare_raid10_write(_Pre_satisfies_(_Curr_->chunk_item->sub_str
 
     pos = 0;
 
-    stripeoff = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64) * c->chunk_item->num_stripes / c->chunk_item->sub_stripes, ALLOC_TAG);
+    stripeoff = ExAllocatePoolWithTag(PagedPool, sizeof(uint64_t) * c->chunk_item->num_stripes / c->chunk_item->sub_stripes, ALLOC_TAG);
     if (!stripeoff) {
         ERR("out of memory\n");
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
-    RtlZeroMemory(stripeoff, sizeof(UINT64) * c->chunk_item->num_stripes / c->chunk_item->sub_stripes);
+    RtlZeroMemory(stripeoff, sizeof(uint64_t) * c->chunk_item->num_stripes / c->chunk_item->sub_stripes);
 
     while (pos < length) {
         PFN_NUMBER* stripe_pfns = (PFN_NUMBER*)(stripes[stripenum * c->chunk_item->sub_stripes].mdl + 1);
 
         if (pos == 0) {
-            UINT32 writelen = (UINT32)min(stripes[stripenum * c->chunk_item->sub_stripes].end - stripes[stripenum * c->chunk_item->sub_stripes].start,
+            uint32_t writelen = (uint32_t)min(stripes[stripenum * c->chunk_item->sub_stripes].end - stripes[stripenum * c->chunk_item->sub_stripes].start,
                                           c->chunk_item->stripe_length - (stripes[stripenum * c->chunk_item->sub_stripes].start % c->chunk_item->stripe_length));
 
             RtlCopyMemory(stripe_pfns, pfns, writelen * sizeof(PFN_NUMBER) >> PAGE_SHIFT);
@@ -961,18 +957,17 @@ static NTSTATUS prepare_raid10_write(_Pre_satisfies_(_Curr_->chunk_item->sub_str
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS add_partial_stripe(device_extension* Vcb, chunk *c, UINT64 address, UINT32 length, void* data) {
+static NTSTATUS add_partial_stripe(device_extension* Vcb, chunk *c, uint64_t address, uint32_t length, void* data) {
     NTSTATUS Status;
     LIST_ENTRY* le;
     partial_stripe* ps;
-    UINT64 stripe_addr;
-    UINT16 num_data_stripes;
-    ULONG bmplen;
+    uint64_t stripe_addr;
+    uint16_t num_data_stripes;
 
     num_data_stripes = c->chunk_item->num_stripes - (c->chunk_item->type & BLOCK_FLAG_RAID5 ? 1 : 2);
     stripe_addr = address - ((address - c->offset) % (num_data_stripes * c->chunk_item->stripe_length));
 
-    ExAcquireResourceExclusiveLite(&c->partial_stripes_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&c->partial_stripes_lock, true);
 
     le = c->partial_stripes.Flink;
     while (le != &c->partial_stripes) {
@@ -1017,10 +1012,10 @@ static NTSTATUS add_partial_stripe(device_extension* Vcb, chunk *c, UINT64 addre
         goto end;
     }
 
-    bmplen = (ULONG)sector_align(((num_data_stripes * c->chunk_item->stripe_length) / (8 * Vcb->superblock.sector_size) + 1), sizeof(ULONG));
+    ps->bmplen = (ULONG)(num_data_stripes * c->chunk_item->stripe_length) / Vcb->superblock.sector_size;
 
     ps->address = stripe_addr;
-    ps->bmparr = ExAllocatePoolWithTag(NonPagedPool, bmplen, ALLOC_TAG);
+    ps->bmparr = ExAllocatePoolWithTag(NonPagedPool, (size_t)sector_align(((ps->bmplen / 8) + 1), sizeof(ULONG)), ALLOC_TAG);
     if (!ps->bmparr) {
         ERR("out of memory\n");
         ExFreePool(ps);
@@ -1028,7 +1023,7 @@ static NTSTATUS add_partial_stripe(device_extension* Vcb, chunk *c, UINT64 addre
         goto end;
     }
 
-    RtlInitializeBitMap(&ps->bmp, ps->bmparr, (ULONG)((num_data_stripes * c->chunk_item->stripe_length) / Vcb->superblock.sector_size));
+    RtlInitializeBitMap(&ps->bmp, ps->bmparr, ps->bmplen);
     RtlSetAllBits(&ps->bmp);
 
     RtlCopyMemory(ps->data + address - stripe_addr, data, length);
@@ -1049,42 +1044,42 @@ typedef struct {
     PFN_NUMBER* pfns;
 } log_stripe;
 
-static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 address, void* data, UINT32 length, write_stripe* stripes, PIRP Irp,
-                                    UINT64 irp_offset, ULONG priority, write_data_context* wtc) {
-    UINT64 startoff, endoff, parity_start, parity_end;
-    UINT16 startoffstripe, endoffstripe, parity, num_data_stripes = c->chunk_item->num_stripes - 1;
-    UINT64 pos, parity_pos, *stripeoff = NULL;
-    UINT32 i;
-    BOOL file_write = Irp && Irp->MdlAddress && (Irp->MdlAddress->ByteOffset == 0);
+static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, uint64_t address, void* data, uint32_t length, write_stripe* stripes, PIRP Irp,
+                                    uint64_t irp_offset, ULONG priority, write_data_context* wtc) {
+    uint64_t startoff, endoff, parity_start, parity_end;
+    uint16_t startoffstripe, endoffstripe, parity, num_data_stripes = c->chunk_item->num_stripes - 1;
+    uint64_t pos, parity_pos, *stripeoff = NULL;
+    uint32_t i;
+    bool file_write = Irp && Irp->MdlAddress && (Irp->MdlAddress->ByteOffset == 0);
     PMDL master_mdl;
     NTSTATUS Status;
     PFN_NUMBER *pfns, *parity_pfns;
     log_stripe* log_stripes = NULL;
 
     if ((address + length - c->offset) % (num_data_stripes * c->chunk_item->stripe_length) > 0) {
-        UINT64 delta = (address + length - c->offset) % (num_data_stripes * c->chunk_item->stripe_length);
+        uint64_t delta = (address + length - c->offset) % (num_data_stripes * c->chunk_item->stripe_length);
 
         delta = min(irp_offset + length, delta);
-        Status = add_partial_stripe(Vcb, c, address + length - delta, (UINT32)delta, (UINT8*)data + irp_offset + length - delta);
+        Status = add_partial_stripe(Vcb, c, address + length - delta, (uint32_t)delta, (uint8_t*)data + irp_offset + length - delta);
         if (!NT_SUCCESS(Status)) {
             ERR("add_partial_stripe returned %08x\n", Status);
             goto exit;
         }
 
-        length -= (UINT32)delta;
+        length -= (uint32_t)delta;
     }
 
     if (length > 0 && (address - c->offset) % (num_data_stripes * c->chunk_item->stripe_length) > 0) {
-        UINT64 delta = (num_data_stripes * c->chunk_item->stripe_length) - ((address - c->offset) % (num_data_stripes * c->chunk_item->stripe_length));
+        uint64_t delta = (num_data_stripes * c->chunk_item->stripe_length) - ((address - c->offset) % (num_data_stripes * c->chunk_item->stripe_length));
 
-        Status = add_partial_stripe(Vcb, c, address, (UINT32)delta, (UINT8*)data + irp_offset);
+        Status = add_partial_stripe(Vcb, c, address, (uint32_t)delta, (uint8_t*)data + irp_offset);
         if (!NT_SUCCESS(Status)) {
             ERR("add_partial_stripe returned %08x\n", Status);
             goto exit;
         }
 
         address += delta;
-        length -= (UINT32)delta;
+        length -= (uint32_t)delta;
         irp_offset += delta;
     }
 
@@ -1101,7 +1096,7 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
         parity = (((address - c->offset + pos) / (num_data_stripes * c->chunk_item->stripe_length)) + num_data_stripes) % c->chunk_item->num_stripes;
 
         if (pos == 0) {
-            UINT16 stripe = (parity + startoffstripe + 1) % c->chunk_item->num_stripes;
+            uint16_t stripe = (parity + startoffstripe + 1) % c->chunk_item->num_stripes;
             ULONG skip, writelen;
 
             i = startoffstripe;
@@ -1159,7 +1154,7 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
 
             pos += c->chunk_item->stripe_length * num_data_stripes;
         } else {
-            UINT16 stripe = (parity + 1) % c->chunk_item->num_stripes;
+            uint16_t stripe = (parity + 1) % c->chunk_item->num_stripes;
 
             i = 0;
             while (stripe != parity) {
@@ -1208,7 +1203,7 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
     RtlZeroMemory(log_stripes, sizeof(log_stripe) * num_data_stripes);
 
     for (i = 0; i < num_data_stripes; i++) {
-        log_stripes[i].mdl = IoAllocateMdl(NULL, (ULONG)(parity_end - parity_start), FALSE, FALSE, NULL);
+        log_stripes[i].mdl = IoAllocateMdl(NULL, (ULONG)(parity_end - parity_start), false, false, NULL);
         if (!log_stripes[i].mdl) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1226,7 +1221,7 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
         goto exit;
     }
 
-    wtc->parity1_mdl = IoAllocateMdl(wtc->parity1, (ULONG)(parity_end - parity_start), FALSE, FALSE, NULL);
+    wtc->parity1_mdl = IoAllocateMdl(wtc->parity1, (ULONG)(parity_end - parity_start), false, false, NULL);
     if (!wtc->parity1_mdl) {
         ERR("out of memory\n");
         Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1245,9 +1240,9 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
             goto exit;
         }
 
-        RtlCopyMemory(wtc->scratch, (UINT8*)data + irp_offset, length);
+        RtlCopyMemory(wtc->scratch, (uint8_t*)data + irp_offset, length);
 
-        master_mdl = IoAllocateMdl(wtc->scratch, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl(wtc->scratch, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1258,7 +1253,7 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
 
         wtc->mdl = master_mdl;
     } else {
-        master_mdl = IoAllocateMdl((UINT8*)data + irp_offset, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl((uint8_t*)data + irp_offset, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1290,7 +1285,7 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
 
     for (i = 0; i < c->chunk_item->num_stripes; i++) {
         if (stripes[i].start != stripes[i].end) {
-            stripes[i].mdl = IoAllocateMdl((UINT8*)MmGetMdlVirtualAddress(master_mdl) + irp_offset, (ULONG)(stripes[i].end - stripes[i].start), FALSE, FALSE, NULL);
+            stripes[i].mdl = IoAllocateMdl((uint8_t*)MmGetMdlVirtualAddress(master_mdl) + irp_offset, (ULONG)(stripes[i].end - stripes[i].start), false, false, NULL);
             if (!stripes[i].mdl) {
                 ERR("IoAllocateMdl failed\n");
                 Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1299,14 +1294,14 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
         }
     }
 
-    stripeoff = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64) * c->chunk_item->num_stripes, ALLOC_TAG);
+    stripeoff = ExAllocatePoolWithTag(PagedPool, sizeof(uint64_t) * c->chunk_item->num_stripes, ALLOC_TAG);
     if (!stripeoff) {
         ERR("out of memory\n");
         Status = STATUS_INSUFFICIENT_RESOURCES;
         goto exit;
     }
 
-    RtlZeroMemory(stripeoff, sizeof(UINT64) * c->chunk_item->num_stripes);
+    RtlZeroMemory(stripeoff, sizeof(uint64_t) * c->chunk_item->num_stripes);
 
     pos = 0;
     parity_pos = 0;
@@ -1317,10 +1312,10 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
         parity = (((address - c->offset + pos) / (num_data_stripes * c->chunk_item->stripe_length)) + num_data_stripes) % c->chunk_item->num_stripes;
 
         if (pos == 0) {
-            UINT16 stripe = (parity + startoffstripe + 1) % c->chunk_item->num_stripes;
-            UINT32 writelen = (UINT32)min(length - pos, min(stripes[stripe].end - stripes[stripe].start,
+            uint16_t stripe = (parity + startoffstripe + 1) % c->chunk_item->num_stripes;
+            uint32_t writelen = (uint32_t)min(length - pos, min(stripes[stripe].end - stripes[stripe].start,
                                                             c->chunk_item->stripe_length - (stripes[stripe].start % c->chunk_item->stripe_length)));
-            UINT32 maxwritelen = writelen;
+            uint32_t maxwritelen = writelen;
 
             stripe_pfns = (PFN_NUMBER*)(stripes[stripe].mdl + 1);
 
@@ -1337,7 +1332,7 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
 
             while (stripe != parity) {
                 stripe_pfns = (PFN_NUMBER*)(stripes[stripe].mdl + 1);
-                writelen = (UINT32)min(length - pos, min(stripes[stripe].end - stripes[stripe].start, c->chunk_item->stripe_length));
+                writelen = (uint32_t)min(length - pos, min(stripes[stripe].end - stripes[stripe].start, c->chunk_item->stripe_length));
 
                 if (writelen == 0)
                     break;
@@ -1363,7 +1358,7 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
             stripeoff[parity] = maxwritelen;
             parity_pos = maxwritelen;
         } else if (length - pos >= c->chunk_item->stripe_length * num_data_stripes) {
-            UINT16 stripe = (parity + 1) % c->chunk_item->num_stripes;
+            uint16_t stripe = (parity + 1) % c->chunk_item->num_stripes;
 
             i = 0;
             while (stripe != parity) {
@@ -1387,13 +1382,13 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
             stripeoff[parity] += c->chunk_item->stripe_length;
             parity_pos += c->chunk_item->stripe_length;
         } else {
-            UINT16 stripe = (parity + 1) % c->chunk_item->num_stripes;
-            UINT32 writelen, maxwritelen = 0;
+            uint16_t stripe = (parity + 1) % c->chunk_item->num_stripes;
+            uint32_t writelen, maxwritelen = 0;
 
             i = 0;
             while (pos < length) {
                 stripe_pfns = (PFN_NUMBER*)(stripes[stripe].mdl + 1);
-                writelen = (UINT32)min(length - pos, min(stripes[stripe].end - stripes[stripe].start, c->chunk_item->stripe_length));
+                writelen = (uint32_t)min(length - pos, min(stripes[stripe].end - stripes[stripe].start, c->chunk_item->stripe_length));
 
                 if (writelen == 0)
                     break;
@@ -1420,12 +1415,12 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr
     }
 
     for (i = 0; i < num_data_stripes; i++) {
-        UINT8* ss = MmGetSystemAddressForMdlSafe(log_stripes[i].mdl, priority);
+        uint8_t* ss = MmGetSystemAddressForMdlSafe(log_stripes[i].mdl, priority);
 
         if (i == 0)
-            RtlCopyMemory(wtc->parity1, ss, (UINT32)(parity_end - parity_start));
+            RtlCopyMemory(wtc->parity1, ss, (uint32_t)(parity_end - parity_start));
         else
-            do_xor(wtc->parity1, ss, (UINT32)(parity_end - parity_start));
+            do_xor(wtc->parity1, ss, (uint32_t)(parity_end - parity_start));
     }
 
     Status = STATUS_SUCCESS;
@@ -1446,42 +1441,42 @@ exit:
     return Status;
 }
 
-static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 address, void* data, UINT32 length, write_stripe* stripes, PIRP Irp,
-                                    UINT64 irp_offset, ULONG priority, write_data_context* wtc) {
-    UINT64 startoff, endoff, parity_start, parity_end;
-    UINT16 startoffstripe, endoffstripe, parity1, num_data_stripes = c->chunk_item->num_stripes - 2;
-    UINT64 pos, parity_pos, *stripeoff = NULL;
-    UINT32 i;
-    BOOL file_write = Irp && Irp->MdlAddress && (Irp->MdlAddress->ByteOffset == 0);
+static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, uint64_t address, void* data, uint32_t length, write_stripe* stripes, PIRP Irp,
+                                    uint64_t irp_offset, ULONG priority, write_data_context* wtc) {
+    uint64_t startoff, endoff, parity_start, parity_end;
+    uint16_t startoffstripe, endoffstripe, parity1, num_data_stripes = c->chunk_item->num_stripes - 2;
+    uint64_t pos, parity_pos, *stripeoff = NULL;
+    uint32_t i;
+    bool file_write = Irp && Irp->MdlAddress && (Irp->MdlAddress->ByteOffset == 0);
     PMDL master_mdl;
     NTSTATUS Status;
     PFN_NUMBER *pfns, *parity1_pfns, *parity2_pfns;
     log_stripe* log_stripes = NULL;
 
     if ((address + length - c->offset) % (num_data_stripes * c->chunk_item->stripe_length) > 0) {
-        UINT64 delta = (address + length - c->offset) % (num_data_stripes * c->chunk_item->stripe_length);
+        uint64_t delta = (address + length - c->offset) % (num_data_stripes * c->chunk_item->stripe_length);
 
         delta = min(irp_offset + length, delta);
-        Status = add_partial_stripe(Vcb, c, address + length - delta, (UINT32)delta, (UINT8*)data + irp_offset + length - delta);
+        Status = add_partial_stripe(Vcb, c, address + length - delta, (uint32_t)delta, (uint8_t*)data + irp_offset + length - delta);
         if (!NT_SUCCESS(Status)) {
             ERR("add_partial_stripe returned %08x\n", Status);
             goto exit;
         }
 
-        length -= (UINT32)delta;
+        length -= (uint32_t)delta;
     }
 
     if (length > 0 && (address - c->offset) % (num_data_stripes * c->chunk_item->stripe_length) > 0) {
-        UINT64 delta = (num_data_stripes * c->chunk_item->stripe_length) - ((address - c->offset) % (num_data_stripes * c->chunk_item->stripe_length));
+        uint64_t delta = (num_data_stripes * c->chunk_item->stripe_length) - ((address - c->offset) % (num_data_stripes * c->chunk_item->stripe_length));
 
-        Status = add_partial_stripe(Vcb, c, address, (UINT32)delta, (UINT8*)data + irp_offset);
+        Status = add_partial_stripe(Vcb, c, address, (uint32_t)delta, (uint8_t*)data + irp_offset);
         if (!NT_SUCCESS(Status)) {
             ERR("add_partial_stripe returned %08x\n", Status);
             goto exit;
         }
 
         address += delta;
-        length -= (UINT32)delta;
+        length -= (uint32_t)delta;
         irp_offset += delta;
     }
 
@@ -1498,8 +1493,8 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
         parity1 = (((address - c->offset + pos) / (num_data_stripes * c->chunk_item->stripe_length)) + num_data_stripes) % c->chunk_item->num_stripes;
 
         if (pos == 0) {
-            UINT16 stripe = (parity1 + startoffstripe + 2) % c->chunk_item->num_stripes;
-            UINT16 parity2 = (parity1 + 1) % c->chunk_item->num_stripes;
+            uint16_t stripe = (parity1 + startoffstripe + 2) % c->chunk_item->num_stripes;
+            uint16_t parity2 = (parity1 + 1) % c->chunk_item->num_stripes;
             ULONG skip, writelen;
 
             i = startoffstripe;
@@ -1558,7 +1553,7 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
 
             pos += c->chunk_item->stripe_length * num_data_stripes;
         } else {
-            UINT16 stripe = (parity1 + 2) % c->chunk_item->num_stripes;
+            uint16_t stripe = (parity1 + 2) % c->chunk_item->num_stripes;
 
             i = 0;
             while (stripe != parity1) {
@@ -1607,7 +1602,7 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
     RtlZeroMemory(log_stripes, sizeof(log_stripe) * num_data_stripes);
 
     for (i = 0; i < num_data_stripes; i++) {
-        log_stripes[i].mdl = IoAllocateMdl(NULL, (ULONG)(parity_end - parity_start), FALSE, FALSE, NULL);
+        log_stripes[i].mdl = IoAllocateMdl(NULL, (ULONG)(parity_end - parity_start), false, false, NULL);
         if (!log_stripes[i].mdl) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1632,7 +1627,7 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
         goto exit;
     }
 
-    wtc->parity1_mdl = IoAllocateMdl(wtc->parity1, (ULONG)(parity_end - parity_start), FALSE, FALSE, NULL);
+    wtc->parity1_mdl = IoAllocateMdl(wtc->parity1, (ULONG)(parity_end - parity_start), false, false, NULL);
     if (!wtc->parity1_mdl) {
         ERR("out of memory\n");
         Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1641,7 +1636,7 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
 
     MmBuildMdlForNonPagedPool(wtc->parity1_mdl);
 
-    wtc->parity2_mdl = IoAllocateMdl(wtc->parity2, (ULONG)(parity_end - parity_start), FALSE, FALSE, NULL);
+    wtc->parity2_mdl = IoAllocateMdl(wtc->parity2, (ULONG)(parity_end - parity_start), false, false, NULL);
     if (!wtc->parity2_mdl) {
         ERR("out of memory\n");
         Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1660,9 +1655,9 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
             goto exit;
         }
 
-        RtlCopyMemory(wtc->scratch, (UINT8*)data + irp_offset, length);
+        RtlCopyMemory(wtc->scratch, (uint8_t*)data + irp_offset, length);
 
-        master_mdl = IoAllocateMdl(wtc->scratch, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl(wtc->scratch, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1673,7 +1668,7 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
 
         wtc->mdl = master_mdl;
     } else {
-        master_mdl = IoAllocateMdl((UINT8*)data + irp_offset, length, FALSE, FALSE, NULL);
+        master_mdl = IoAllocateMdl((uint8_t*)data + irp_offset, length, false, false, NULL);
         if (!master_mdl) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1706,7 +1701,7 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
 
     for (i = 0; i < c->chunk_item->num_stripes; i++) {
         if (stripes[i].start != stripes[i].end) {
-            stripes[i].mdl = IoAllocateMdl((UINT8*)MmGetMdlVirtualAddress(master_mdl) + irp_offset, (ULONG)(stripes[i].end - stripes[i].start), FALSE, FALSE, NULL);
+            stripes[i].mdl = IoAllocateMdl((uint8_t*)MmGetMdlVirtualAddress(master_mdl) + irp_offset, (ULONG)(stripes[i].end - stripes[i].start), false, false, NULL);
             if (!stripes[i].mdl) {
                 ERR("IoAllocateMdl failed\n");
                 Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1715,14 +1710,14 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
         }
     }
 
-    stripeoff = ExAllocatePoolWithTag(PagedPool, sizeof(UINT64) * c->chunk_item->num_stripes, ALLOC_TAG);
+    stripeoff = ExAllocatePoolWithTag(PagedPool, sizeof(uint64_t) * c->chunk_item->num_stripes, ALLOC_TAG);
     if (!stripeoff) {
         ERR("out of memory\n");
         Status = STATUS_INSUFFICIENT_RESOURCES;
         goto exit;
     }
 
-    RtlZeroMemory(stripeoff, sizeof(UINT64) * c->chunk_item->num_stripes);
+    RtlZeroMemory(stripeoff, sizeof(uint64_t) * c->chunk_item->num_stripes);
 
     pos = 0;
     parity_pos = 0;
@@ -1733,10 +1728,10 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
         parity1 = (((address - c->offset + pos) / (num_data_stripes * c->chunk_item->stripe_length)) + num_data_stripes) % c->chunk_item->num_stripes;
 
         if (pos == 0) {
-            UINT16 stripe = (parity1 + startoffstripe + 2) % c->chunk_item->num_stripes, parity2;
-            UINT32 writelen = (UINT32)min(length - pos, min(stripes[stripe].end - stripes[stripe].start,
+            uint16_t stripe = (parity1 + startoffstripe + 2) % c->chunk_item->num_stripes, parity2;
+            uint32_t writelen = (uint32_t)min(length - pos, min(stripes[stripe].end - stripes[stripe].start,
                                                             c->chunk_item->stripe_length - (stripes[stripe].start % c->chunk_item->stripe_length)));
-            UINT32 maxwritelen = writelen;
+            uint32_t maxwritelen = writelen;
 
             stripe_pfns = (PFN_NUMBER*)(stripes[stripe].mdl + 1);
 
@@ -1753,7 +1748,7 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
 
             while (stripe != parity1) {
                 stripe_pfns = (PFN_NUMBER*)(stripes[stripe].mdl + 1);
-                writelen = (UINT32)min(length - pos, min(stripes[stripe].end - stripes[stripe].start, c->chunk_item->stripe_length));
+                writelen = (uint32_t)min(length - pos, min(stripes[stripe].end - stripes[stripe].start, c->chunk_item->stripe_length));
 
                 if (writelen == 0)
                     break;
@@ -1785,7 +1780,7 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
 
             parity_pos = maxwritelen;
         } else if (length - pos >= c->chunk_item->stripe_length * num_data_stripes) {
-            UINT16 stripe = (parity1 + 2) % c->chunk_item->num_stripes, parity2;
+            uint16_t stripe = (parity1 + 2) % c->chunk_item->num_stripes, parity2;
 
             i = 0;
             while (stripe != parity1) {
@@ -1815,13 +1810,13 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
 
             parity_pos += c->chunk_item->stripe_length;
         } else {
-            UINT16 stripe = (parity1 + 2) % c->chunk_item->num_stripes, parity2;
-            UINT32 writelen, maxwritelen = 0;
+            uint16_t stripe = (parity1 + 2) % c->chunk_item->num_stripes, parity2;
+            uint32_t writelen, maxwritelen = 0;
 
             i = 0;
             while (pos < length) {
                 stripe_pfns = (PFN_NUMBER*)(stripes[stripe].mdl + 1);
-                writelen = (UINT32)min(length - pos, min(stripes[stripe].end - stripes[stripe].start, c->chunk_item->stripe_length));
+                writelen = (uint32_t)min(length - pos, min(stripes[stripe].end - stripes[stripe].start, c->chunk_item->stripe_length));
 
                 if (writelen == 0)
                     break;
@@ -1852,16 +1847,16 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr
     }
 
     for (i = 0; i < num_data_stripes; i++) {
-        UINT8* ss = MmGetSystemAddressForMdlSafe(log_stripes[c->chunk_item->num_stripes - 3 - i].mdl, priority);
+        uint8_t* ss = MmGetSystemAddressForMdlSafe(log_stripes[c->chunk_item->num_stripes - 3 - i].mdl, priority);
 
         if (i == 0) {
             RtlCopyMemory(wtc->parity1, ss, (ULONG)(parity_end - parity_start));
             RtlCopyMemory(wtc->parity2, ss, (ULONG)(parity_end - parity_start));
         } else {
-            do_xor(wtc->parity1, ss, (UINT32)(parity_end - parity_start));
+            do_xor(wtc->parity1, ss, (uint32_t)(parity_end - parity_start));
 
-            galois_double(wtc->parity2, (UINT32)(parity_end - parity_start));
-            do_xor(wtc->parity2, ss, (UINT32)(parity_end - parity_start));
+            galois_double(wtc->parity2, (uint32_t)(parity_end - parity_start));
+            do_xor(wtc->parity2, ss, (uint32_t)(parity_end - parity_start));
         }
     }
 
@@ -1883,21 +1878,21 @@ exit:
     return Status;
 }
 
-NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_bytes_(length) void* data, _In_ UINT32 length, _In_ write_data_context* wtc,
-                    _In_opt_ PIRP Irp, _In_opt_ chunk* c, _In_ BOOL file_write, _In_ UINT64 irp_offset, _In_ ULONG priority) {
+NTSTATUS write_data(_In_ device_extension* Vcb, _In_ uint64_t address, _In_reads_bytes_(length) void* data, _In_ uint32_t length, _In_ write_data_context* wtc,
+                    _In_opt_ PIRP Irp, _In_opt_ chunk* c, _In_ bool file_write, _In_ uint64_t irp_offset, _In_ ULONG priority) {
     NTSTATUS Status;
-    UINT32 i;
+    uint32_t i;
     CHUNK_ITEM_STRIPE* cis;
     write_stripe* stripes = NULL;
-    UINT64 total_writing = 0;
+    uint64_t total_writing = 0;
     ULONG allowed_missing, missing;
 
-    TRACE("(%p, %llx, %p, %x)\n", Vcb, address, data, length);
+    TRACE("(%p, %I64x, %p, %x)\n", Vcb, address, data, length);
 
     if (!c) {
         c = get_chunk_from_address(Vcb, address);
         if (!c) {
-            ERR("could not get chunk for address %llx\n", address);
+            ERR("could not get chunk for address %I64x\n", address);
             return STATUS_INTERNAL_ERROR;
         }
     }
@@ -1953,12 +1948,12 @@ NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_b
 
             if (c->devices[i]->devobj) {
                 if (file_write) {
-                    UINT8* va;
+                    uint8_t* va;
                     ULONG writelen = (ULONG)(stripes[i].end - stripes[i].start);
 
-                    va = (UINT8*)MmGetMdlVirtualAddress(Irp->MdlAddress) + stripes[i].irp_offset;
+                    va = (uint8_t*)MmGetMdlVirtualAddress(Irp->MdlAddress) + stripes[i].irp_offset;
 
-                    stripes[i].mdl = IoAllocateMdl(va, writelen, FALSE, FALSE, NULL);
+                    stripes[i].mdl = IoAllocateMdl(va, writelen, false, false, NULL);
                     if (!stripes[i].mdl) {
                         ERR("IoAllocateMdl failed\n");
                         Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -1967,7 +1962,7 @@ NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_b
 
                     IoBuildPartialMdl(Irp->MdlAddress, stripes[i].mdl, va, writelen);
                 } else {
-                    stripes[i].mdl = IoAllocateMdl(stripes[i].data, (ULONG)(stripes[i].end - stripes[i].start), FALSE, FALSE, NULL);
+                    stripes[i].mdl = IoAllocateMdl(stripes[i].data, (ULONG)(stripes[i].end - stripes[i].start), false, false, NULL);
                     if (!stripes[i].mdl) {
                         ERR("IoAllocateMdl failed\n");
                         Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2032,7 +2027,7 @@ NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_b
             stripe->mdl = stripes[i].mdl;
 
             if (!Irp) {
-                stripe->Irp = IoAllocateIrp(stripe->device->devobj->StackSize, FALSE);
+                stripe->Irp = IoAllocateIrp(stripe->device->devobj->StackSize, false);
 
                 if (!stripe->Irp) {
                     ERR("IoAllocateIrp failed\n");
@@ -2053,6 +2048,7 @@ NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_b
 
             IrpSp = IoGetNextIrpStackLocation(stripe->Irp);
             IrpSp->MajorFunction = IRP_MJ_WRITE;
+            IrpSp->FileObject = stripe->device->fileobj;
 
             if (stripe->device->devobj->Flags & DO_BUFFERED_IO) {
                 stripe->Irp->AssociatedIrp.SystemBuffer = MmGetSystemAddressForMdlSafe(stripes[i].mdl, priority);
@@ -2065,7 +2061,7 @@ NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_b
 
 #ifdef DEBUG_PARANOID
             if (stripes[i].end < stripes[i].start) {
-                ERR("trying to write stripe with negative length (%llx < %llx)\n", stripes[i].end, stripes[i].start);
+                ERR("trying to write stripe with negative length (%I64x < %I64x)\n", stripes[i].end, stripes[i].start);
                 int3;
             }
 #endif
@@ -2078,7 +2074,7 @@ NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_b
             stripe->Irp->UserIosb = &stripe->iosb;
             wtc->stripes_left++;
 
-            IoSetCompletionRoutine(stripe->Irp, write_data_completion, stripe, TRUE, TRUE, TRUE);
+            IoSetCompletionRoutine(stripe->Irp, write_data_completion, stripe, true, true, true);
         }
 
         InsertTailList(&wtc->stripes, &stripe->list_entry);
@@ -2151,9 +2147,9 @@ prepare_failed:
     return Status;
 }
 
-void get_raid56_lock_range(chunk* c, UINT64 address, UINT64 length, UINT64* lockaddr, UINT64* locklen) {
-    UINT64 startoff, endoff;
-    UINT16 startoffstripe, endoffstripe, datastripes;
+void get_raid56_lock_range(chunk* c, uint64_t address, uint64_t length, uint64_t* lockaddr, uint64_t* locklen) {
+    uint64_t startoff, endoff;
+    uint16_t startoffstripe, endoffstripe, datastripes;
 
     datastripes = c->chunk_item->num_stripes - (c->chunk_item->type & BLOCK_FLAG_RAID5 ? 1 : 2);
 
@@ -2167,12 +2163,12 @@ void get_raid56_lock_range(chunk* c, UINT64 address, UINT64 length, UINT64* lock
     *locklen = (endoff - startoff) * datastripes;
 }
 
-NTSTATUS write_data_complete(device_extension* Vcb, UINT64 address, void* data, UINT32 length, PIRP Irp, chunk* c, BOOL file_write, UINT64 irp_offset, ULONG priority) {
+NTSTATUS write_data_complete(device_extension* Vcb, uint64_t address, void* data, uint32_t length, PIRP Irp, chunk* c, bool file_write, uint64_t irp_offset, ULONG priority) {
     write_data_context wtc;
     NTSTATUS Status;
-    UINT64 lockaddr, locklen;
+    uint64_t lockaddr, locklen;
 
-    KeInitializeEvent(&wtc.Event, NotificationEvent, FALSE);
+    KeInitializeEvent(&wtc.Event, NotificationEvent, false);
     InitializeListHead(&wtc.stripes);
     wtc.stripes_left = 0;
     wtc.parity1 = wtc.parity2 = wtc.scratch = NULL;
@@ -2181,7 +2177,7 @@ NTSTATUS write_data_complete(device_extension* Vcb, UINT64 address, void* data,
     if (!c) {
         c = get_chunk_from_address(Vcb, address);
         if (!c) {
-            ERR("could not get chunk for address %llx\n", address);
+            ERR("could not get chunk for address %I64x\n", address);
             return STATUS_INTERNAL_ERROR;
         }
     }
@@ -2210,21 +2206,21 @@ NTSTATUS write_data_complete(device_extension* Vcb, UINT64 address, void* data,
     if (wtc.stripes.Flink != &wtc.stripes) {
         // launch writes and wait
         LIST_ENTRY* le = wtc.stripes.Flink;
-        BOOL no_wait = TRUE;
+        bool no_wait = true;
 
         while (le != &wtc.stripes) {
             write_data_stripe* stripe = CONTAINING_RECORD(le, write_data_stripe, list_entry);
 
             if (stripe->status != WriteDataStatus_Ignore) {
                 IoCallDriver(stripe->device->devobj, stripe->Irp);
-                no_wait = FALSE;
+                no_wait = false;
             }
 
             le = le->Flink;
         }
 
         if (!no_wait)
-            KeWaitForSingleObject(&wtc.Event, Executive, KernelMode, FALSE, NULL);
+            KeWaitForSingleObject(&wtc.Event, Executive, KernelMode, false, NULL);
 
         le = wtc.stripes.Flink;
         while (le != &wtc.stripes) {
@@ -2250,11 +2246,7 @@ NTSTATUS write_data_complete(device_extension* Vcb, UINT64 address, void* data,
 }
 
 _Function_class_(IO_COMPLETION_ROUTINE)
-#ifdef __REACTOS__
-static NTSTATUS NTAPI write_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#else
-static NTSTATUS write_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
-#endif
+static NTSTATUS __stdcall write_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
     write_data_stripe* stripe = conptr;
     write_data_context* context = (write_data_context*)stripe->context;
     LIST_ENTRY* le;
@@ -2291,7 +2283,7 @@ static NTSTATUS write_data_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVO
 
 end:
     if (InterlockedDecrement(&context->stripes_left) == 0)
-        KeSetEvent(&context->Event, 0, FALSE);
+        KeSetEvent(&context->Event, 0, false);
 
     return STATUS_MORE_PROCESSING_REQUIRED;
 }
@@ -2373,7 +2365,7 @@ void add_extent(_In_ fcb* fcb, _In_ LIST_ENTRY* prevextle, _In_ __drv_aliasesMem
     InsertTailList(&fcb->extents, &newext->list_entry);
 }
 
-NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT64 end_data, PIRP Irp, LIST_ENTRY* rollback) {
+NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, uint64_t start_data, uint64_t end_data, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     LIST_ENTRY* le;
 
@@ -2384,7 +2376,7 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
         extent* ext = CONTAINING_RECORD(le, extent, list_entry);
         EXTENT_DATA* ed = &ext->extent_data;
         EXTENT_DATA2* ed2 = NULL;
-        UINT64 len;
+        uint64_t len;
 
         if (!ext->ignore) {
             if (ed->type != EXTENT_TYPE_INLINE)
@@ -2398,7 +2390,7 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                         remove_fcb_extent(fcb, ext, rollback);
 
                         fcb->inode_item.st_blocks -= len;
-                        fcb->inode_item_changed = TRUE;
+                        fcb->inode_item_changed = true;
                     } else {
                         ERR("trying to split inline extent\n");
 #ifdef DEBUG_PARANOID
@@ -2412,15 +2404,15 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                             chunk* c;
 
                             fcb->inode_item.st_blocks -= len;
-                            fcb->inode_item_changed = TRUE;
+                            fcb->inode_item_changed = true;
 
                             c = get_chunk_from_address(Vcb, ed2->address);
 
                             if (!c) {
-                                ERR("get_chunk_from_address(%llx) failed\n", ed2->address);
+                                ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
                             } else {
                                 Status = update_changed_extent_ref(Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, -1,
-                                                                   fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, Irp);
+                                                                   fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("update_changed_extent_ref returned %08x\n", Status);
                                     goto end;
@@ -2435,7 +2427,7 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
 
                         if (ed2->size != 0) {
                             fcb->inode_item.st_blocks -= end_data - ext->offset;
-                            fcb->inode_item_changed = TRUE;
+                            fcb->inode_item_changed = true;
                         }
 
                         newext = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2), ALLOC_TAG);
@@ -2461,12 +2453,12 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                         newext->offset = end_data;
                         newext->datalen = sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
                         newext->unique = ext->unique;
-                        newext->ignore = FALSE;
-                        newext->inserted = TRUE;
+                        newext->ignore = false;
+                        newext->inserted = true;
 
                         if (ext->csum) {
                             if (ed->compression == BTRFS_COMPRESSION_NONE) {
-                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ned2->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ned2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                 if (!newext->csum) {
                                     ERR("out of memory\n");
                                     Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2475,9 +2467,9 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                                 }
 
                                 RtlCopyMemory(newext->csum, &ext->csum[(end_data - ext->offset) / Vcb->superblock.sector_size],
-                                              (ULONG)(ned2->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                              (ULONG)(ned2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size));
                             } else {
-                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                 if (!newext->csum) {
                                     ERR("out of memory\n");
                                     Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2485,7 +2477,7 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                                     goto end;
                                 }
 
-                                RtlCopyMemory(newext->csum, ext->csum, (ULONG)(ed2->size * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                RtlCopyMemory(newext->csum, ext->csum, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size));
                             }
                         } else
                             newext->csum = NULL;
@@ -2499,7 +2491,7 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
 
                         if (ed2->size != 0) {
                             fcb->inode_item.st_blocks -= ext->offset + len - start_data;
-                            fcb->inode_item_changed = TRUE;
+                            fcb->inode_item_changed = true;
                         }
 
                         newext = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2), ALLOC_TAG);
@@ -2525,12 +2517,12 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                         newext->offset = ext->offset;
                         newext->datalen = sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
                         newext->unique = ext->unique;
-                        newext->ignore = FALSE;
-                        newext->inserted = TRUE;
+                        newext->ignore = false;
+                        newext->inserted = true;
 
                         if (ext->csum) {
                             if (ed->compression == BTRFS_COMPRESSION_NONE) {
-                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ned2->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ned2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                 if (!newext->csum) {
                                     ERR("out of memory\n");
                                     Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2538,9 +2530,9 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                                     goto end;
                                 }
 
-                                RtlCopyMemory(newext->csum, ext->csum, (ULONG)(ned2->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                RtlCopyMemory(newext->csum, ext->csum, (ULONG)(ned2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size));
                             } else {
-                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                 if (!newext->csum) {
                                     ERR("out of memory\n");
                                     Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2548,7 +2540,7 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                                     goto end;
                                 }
 
-                                RtlCopyMemory(newext->csum, ext->csum, (ULONG)(ed2->size * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                RtlCopyMemory(newext->csum, ext->csum, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size));
                             }
                         } else
                             newext->csum = NULL;
@@ -2564,15 +2556,15 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                             chunk* c;
 
                             fcb->inode_item.st_blocks -= end_data - start_data;
-                            fcb->inode_item_changed = TRUE;
+                            fcb->inode_item_changed = true;
 
                             c = get_chunk_from_address(Vcb, ed2->address);
 
                             if (!c) {
-                                ERR("get_chunk_from_address(%llx) failed\n", ed2->address);
+                                ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
                             } else {
                                 Status = update_changed_extent_ref(Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, 1,
-                                                                   fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, Irp);
+                                                                   fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
                                 if (!NT_SUCCESS(Status)) {
                                     ERR("update_changed_extent_ref returned %08x\n", Status);
                                     goto end;
@@ -2624,18 +2616,18 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                         newext1->offset = ext->offset;
                         newext1->datalen = sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
                         newext1->unique = ext->unique;
-                        newext1->ignore = FALSE;
-                        newext1->inserted = TRUE;
+                        newext1->ignore = false;
+                        newext1->inserted = true;
 
                         newext2->offset = end_data;
                         newext2->datalen = sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
                         newext2->unique = ext->unique;
-                        newext2->ignore = FALSE;
-                        newext2->inserted = TRUE;
+                        newext2->ignore = false;
+                        newext2->inserted = true;
 
                         if (ext->csum) {
                             if (ed->compression == BTRFS_COMPRESSION_NONE) {
-                                newext1->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(neda2->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+                                newext1->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(neda2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                 if (!newext1->csum) {
                                     ERR("out of memory\n");
                                     Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2644,7 +2636,7 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                                     goto end;
                                 }
 
-                                newext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(nedb2->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+                                newext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(nedb2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                 if (!newext2->csum) {
                                     ERR("out of memory\n");
                                     Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2654,11 +2646,11 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                                     goto end;
                                 }
 
-                                RtlCopyMemory(newext1->csum, ext->csum, (ULONG)(neda2->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                RtlCopyMemory(newext1->csum, ext->csum, (ULONG)(neda2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size));
                                 RtlCopyMemory(newext2->csum, &ext->csum[(end_data - ext->offset) / Vcb->superblock.sector_size],
-                                              (ULONG)(nedb2->num_bytes * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                              (ULONG)(nedb2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size));
                             } else {
-                                newext1->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+                                newext1->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                 if (!newext1->csum) {
                                     ERR("out of memory\n");
                                     Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2667,7 +2659,7 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                                     goto end;
                                 }
 
-                                newext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(UINT32) / Vcb->superblock.sector_size), ALLOC_TAG);
+                                newext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                 if (!newext2->csum) {
                                     ERR("out of memory\n");
                                     Status = STATUS_INSUFFICIENT_RESOURCES;
@@ -2677,8 +2669,8 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
                                     goto end;
                                 }
 
-                                RtlCopyMemory(newext1->csum, ext->csum, (ULONG)(ed2->size * sizeof(UINT32) / Vcb->superblock.sector_size));
-                                RtlCopyMemory(newext2->csum, ext->csum, (ULONG)(ed2->size * sizeof(UINT32) / Vcb->superblock.sector_size));
+                                RtlCopyMemory(newext1->csum, ext->csum, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size));
+                                RtlCopyMemory(newext2->csum, ext->csum, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size));
                             }
                         } else {
                             newext1->csum = NULL;
@@ -2700,7 +2692,7 @@ NTSTATUS excise_extents(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT
     Status = STATUS_SUCCESS;
 
 end:
-    fcb->extents_changed = TRUE;
+    fcb->extents_changed = true;
     mark_fcb_dirty(fcb);
 
     return Status;
@@ -2725,8 +2717,8 @@ void add_insert_extent_rollback(LIST_ENTRY* rollback, fcb* fcb, extent* ext) {
 #pragma warning(push)
 #pragma warning(suppress: 28194)
 #endif
-NTSTATUS add_extent_to_fcb(_In_ fcb* fcb, _In_ UINT64 offset, _In_reads_bytes_(edsize) EXTENT_DATA* ed, _In_ UINT16 edsize,
-                           _In_ BOOL unique, _In_opt_ _When_(return >= 0, __drv_aliasesMem) UINT32* csum, _In_ LIST_ENTRY* rollback) {
+NTSTATUS add_extent_to_fcb(_In_ fcb* fcb, _In_ uint64_t offset, _In_reads_bytes_(edsize) EXTENT_DATA* ed, _In_ uint16_t edsize,
+                           _In_ bool unique, _In_opt_ _When_(return >= 0, __drv_aliasesMem) uint32_t* csum, _In_ LIST_ENTRY* rollback) {
     extent* ext;
     LIST_ENTRY* le;
 
@@ -2739,8 +2731,8 @@ NTSTATUS add_extent_to_fcb(_In_ fcb* fcb, _In_ UINT64 offset, _In_reads_bytes_(e
     ext->offset = offset;
     ext->datalen = edsize;
     ext->unique = unique;
-    ext->ignore = FALSE;
-    ext->inserted = TRUE;
+    ext->ignore = false;
+    ext->inserted = true;
     ext->csum = csum;
 
     RtlCopyMemory(&ext->extent_data, ed, edsize);
@@ -2772,7 +2764,7 @@ static void remove_fcb_extent(fcb* fcb, extent* ext, LIST_ENTRY* rollback) {
     if (!ext->ignore) {
         rollback_extent* re;
 
-        ext->ignore = TRUE;
+        ext->ignore = true;
 
         re = ExAllocatePoolWithTag(NonPagedPool, sizeof(rollback_extent), ALLOC_TAG);
         if (!re) {
@@ -2787,15 +2779,15 @@ static void remove_fcb_extent(fcb* fcb, extent* ext, LIST_ENTRY* rollback) {
     }
 }
 
-NTSTATUS calc_csum(_In_ device_extension* Vcb, _In_reads_bytes_(sectors*Vcb->superblock.sector_size) UINT8* data,
-                   _In_ UINT32 sectors, _Out_writes_bytes_(sectors*sizeof(UINT32)) UINT32* csum) {
+NTSTATUS calc_csum(_In_ device_extension* Vcb, _In_reads_bytes_(sectors*Vcb->superblock.sector_size) uint8_t* data,
+                   _In_ uint32_t sectors, _Out_writes_bytes_(sectors*sizeof(uint32_t)) uint32_t* csum) {
     NTSTATUS Status;
     calc_job* cj;
 
     // From experimenting, it seems that 40 sectors is roughly the crossover
     // point where offloading the crc32 calculation becomes worth it.
 
-    if (sectors < 40 || KeQueryActiveProcessorCount(NULL) < 2) {
+    if (sectors < 40 || get_num_of_processors() < 2) {
         ULONG j;
 
         for (j = 0; j < sectors; j++) {
@@ -2811,7 +2803,7 @@ NTSTATUS calc_csum(_In_ device_extension* Vcb, _In_reads_bytes_(sectors*Vcb->sup
         return Status;
     }
 
-    KeWaitForSingleObject(&cj->event, Executive, KernelMode, FALSE, NULL);
+    KeWaitForSingleObject(&cj->event, Executive, KernelMode, false, NULL);
     free_calc_job(cj);
 
     return STATUS_SUCCESS;
@@ -2819,25 +2811,25 @@ NTSTATUS calc_csum(_In_ device_extension* Vcb, _In_reads_bytes_(sectors*Vcb->sup
 
 _Requires_lock_held_(c->lock)
 _When_(return != 0, _Releases_lock_(c->lock))
-BOOL insert_extent_chunk(_In_ device_extension* Vcb, _In_ fcb* fcb, _In_ chunk* c, _In_ UINT64 start_data, _In_ UINT64 length, _In_ BOOL prealloc, _In_opt_ void* data,
-                         _In_opt_ PIRP Irp, _In_ LIST_ENTRY* rollback, _In_ UINT8 compression, _In_ UINT64 decoded_size, _In_ BOOL file_write, _In_ UINT64 irp_offset) {
-    UINT64 address;
+bool insert_extent_chunk(_In_ device_extension* Vcb, _In_ fcb* fcb, _In_ chunk* c, _In_ uint64_t start_data, _In_ uint64_t length, _In_ bool prealloc, _In_opt_ void* data,
+                         _In_opt_ PIRP Irp, _In_ LIST_ENTRY* rollback, _In_ uint8_t compression, _In_ uint64_t decoded_size, _In_ bool file_write, _In_ uint64_t irp_offset) {
+    uint64_t address;
     NTSTATUS Status;
     EXTENT_DATA* ed;
     EXTENT_DATA2* ed2;
-    UINT16 edsize = (UINT16)(offsetof(EXTENT_DATA, data[0]) + sizeof(EXTENT_DATA2));
-    UINT32* csum = NULL;
+    uint16_t edsize = (uint16_t)(offsetof(EXTENT_DATA, data[0]) + sizeof(EXTENT_DATA2));
+    uint32_t* csum = NULL;
 
-    TRACE("(%p, (%llx, %llx), %llx, %llx, %llx, %u, %p, %p)\n", Vcb, fcb->subvol->id, fcb->inode, c->offset, start_data, length, prealloc, data, rollback);
+    TRACE("(%p, (%I64x, %I64x), %I64x, %I64x, %I64x, %u, %p, %p)\n", Vcb, fcb->subvol->id, fcb->inode, c->offset, start_data, length, prealloc, data, rollback);
 
     if (!find_data_address_in_chunk(Vcb, c, length, &address))
-        return FALSE;
+        return false;
 
     // add extent data to inode
     ed = ExAllocatePoolWithTag(PagedPool, edsize, ALLOC_TAG);
     if (!ed) {
         ERR("out of memory\n");
-        return FALSE;
+        return false;
     }
 
     ed->generation = Vcb->superblock.generation;
@@ -2856,11 +2848,11 @@ BOOL insert_extent_chunk(_In_ device_extension* Vcb, _In_ fcb* fcb, _In_ chunk*
     if (!prealloc && data && !(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
         ULONG sl = (ULONG)(length / Vcb->superblock.sector_size);
 
-        csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(UINT32), ALLOC_TAG);
+        csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(uint32_t), ALLOC_TAG);
         if (!csum) {
             ERR("out of memory\n");
             ExFreePool(ed);
-            return FALSE;
+            return false;
         }
 
         Status = calc_csum(Vcb, data, sl, csum);
@@ -2868,30 +2860,30 @@ BOOL insert_extent_chunk(_In_ device_extension* Vcb, _In_ fcb* fcb, _In_ chunk*
             ERR("calc_csum returned %08x\n", Status);
             ExFreePool(csum);
             ExFreePool(ed);
-            return FALSE;
+            return false;
         }
     }
 
-    Status = add_extent_to_fcb(fcb, start_data, ed, edsize, TRUE, csum, rollback);
+    Status = add_extent_to_fcb(fcb, start_data, ed, edsize, true, csum, rollback);
     if (!NT_SUCCESS(Status)) {
         ERR("add_extent_to_fcb returned %08x\n", Status);
         if (csum) ExFreePool(csum);
         ExFreePool(ed);
-        return FALSE;
+        return false;
     }
 
     ExFreePool(ed);
 
     c->used += length;
-    space_list_subtract(c, FALSE, address, length, rollback);
+    space_list_subtract(c, false, address, length, rollback);
 
     fcb->inode_item.st_blocks += decoded_size;
 
-    fcb->extents_changed = TRUE;
-    fcb->inode_item_changed = TRUE;
+    fcb->extents_changed = true;
+    fcb->inode_item_changed = true;
     mark_fcb_dirty(fcb);
 
-    ExAcquireResourceExclusiveLite(&c->changed_extents_lock, TRUE);
+    ExAcquireResourceExclusiveLite(&c->changed_extents_lock, true);
 
     add_changed_extent_ref(c, address, length, fcb->subvol->id, fcb->inode, start_data, 1, fcb->inode_item.flags & BTRFS_INODE_NODATASUM);
 
@@ -2900,18 +2892,18 @@ BOOL insert_extent_chunk(_In_ device_extension* Vcb, _In_ fcb* fcb, _In_ chunk*
     release_chunk_lock(c, Vcb);
 
     if (data) {
-        Status = write_data_complete(Vcb, address, data, (UINT32)length, Irp, NULL, file_write, irp_offset,
+        Status = write_data_complete(Vcb, address, data, (uint32_t)length, Irp, NULL, file_write, irp_offset,
                                      fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE ? HighPagePriority : NormalPagePriority);
         if (!NT_SUCCESS(Status))
             ERR("write_data_complete returned %08x\n", Status);
     }
 
-    return TRUE;
+    return true;
 }
 
-static BOOL try_extend_data(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT64 length, void* data,
-                            PIRP Irp, UINT64* written, BOOL file_write, UINT64 irp_offset, LIST_ENTRY* rollback) {
-    BOOL success = FALSE;
+static bool try_extend_data(device_extension* Vcb, fcb* fcb, uint64_t start_data, uint64_t length, void* data,
+                            PIRP Irp, uint64_t* written, bool file_write, uint64_t irp_offset, LIST_ENTRY* rollback) {
+    bool success = false;
     EXTENT_DATA* ed;
     EXTENT_DATA2* ed2;
     chunk* c;
@@ -2937,32 +2929,32 @@ static BOOL try_extend_data(device_extension* Vcb, fcb* fcb, UINT64 start_data,
     }
 
     if (!ext)
-        return FALSE;
+        return false;
 
     ed = &ext->extent_data;
 
     if (ed->type != EXTENT_TYPE_REGULAR && ed->type != EXTENT_TYPE_PREALLOC) {
         TRACE("not extending extent which is not regular or prealloc\n");
-        return FALSE;
+        return false;
     }
 
     ed2 = (EXTENT_DATA2*)ed->data;
 
     if (ext->offset + ed2->num_bytes != start_data) {
-        TRACE("last EXTENT_DATA does not run up to start_data (%llx + %llx != %llx)\n", ext->offset, ed2->num_bytes, start_data);
-        return FALSE;
+        TRACE("last EXTENT_DATA does not run up to start_data (%I64x + %I64x != %I64x)\n", ext->offset, ed2->num_bytes, start_data);
+        return false;
     }
 
     c = get_chunk_from_address(Vcb, ed2->address);
 
     if (c->reloc || c->readonly || c->chunk_item->type != Vcb->data_flags)
-        return FALSE;
+        return false;
 
     acquire_chunk_lock(c, Vcb);
 
     if (length > c->chunk_item->size - c->used) {
         release_chunk_lock(c, Vcb);
-        return FALSE;
+        return false;
     }
 
     if (!c->cache_loaded) {
@@ -2971,7 +2963,7 @@ static BOOL try_extend_data(device_extension* Vcb, fcb* fcb, UINT64 start_data,
         if (!NT_SUCCESS(Status)) {
             ERR("load_cache_chunk returned %08x\n", Status);
             release_chunk_lock(c, Vcb);
-            return FALSE;
+            return false;
         }
     }
 
@@ -2980,9 +2972,9 @@ static BOOL try_extend_data(device_extension* Vcb, fcb* fcb, UINT64 start_data,
         space* s = CONTAINING_RECORD(le, space, list_entry);
 
         if (s->address == ed2->address + ed2->size) {
-            UINT64 newlen = min(min(s->size, length), MAX_EXTENT_SIZE);
+            uint64_t newlen = min(min(s->size, length), MAX_EXTENT_SIZE);
 
-            success = insert_extent_chunk(Vcb, fcb, c, start_data, newlen, FALSE, data, Irp, rollback, BTRFS_COMPRESSION_NONE, newlen, file_write, irp_offset);
+            success = insert_extent_chunk(Vcb, fcb, c, start_data, newlen, false, data, Irp, rollback, BTRFS_COMPRESSION_NONE, newlen, file_write, irp_offset);
 
             if (success)
                 *written += newlen;
@@ -2998,21 +2990,21 @@ static BOOL try_extend_data(device_extension* Vcb, fcb* fcb, UINT64 start_data,
 
     release_chunk_lock(c, Vcb);
 
-    return FALSE;
+    return false;
 }
 
-static NTSTATUS insert_chunk_fragmented(fcb* fcb, UINT64 start, UINT64 length, UINT8* data, BOOL prealloc, LIST_ENTRY* rollback) {
+static NTSTATUS insert_chunk_fragmented(fcb* fcb, uint64_t start, uint64_t length, uint8_t* data, bool prealloc, LIST_ENTRY* rollback) {
     LIST_ENTRY* le;
-    UINT64 flags = fcb->Vcb->data_flags;
-    BOOL page_file = fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE;
+    uint64_t flags = fcb->Vcb->data_flags;
+    bool page_file = fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE;
     NTSTATUS Status;
     chunk* c;
 
-    ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, TRUE);
+    ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, true);
 
     // first create as many chunks as we can
     do {
-        Status = alloc_chunk(fcb->Vcb, flags, &c, FALSE);
+        Status = alloc_chunk(fcb->Vcb, flags, &c, false);
     } while (NT_SUCCESS(Status));
 
     if (Status != STATUS_DISK_FULL) {
@@ -3031,9 +3023,9 @@ static NTSTATUS insert_chunk_fragmented(fcb* fcb, UINT64 start, UINT64 length, U
             if (c->chunk_item->type == flags) {
                 while (!IsListEmpty(&c->space_size) && length > 0) {
                     space* s = CONTAINING_RECORD(c->space_size.Flink, space, list_entry_size);
-                    UINT64 extlen = min(length, s->size);
+                    uint64_t extlen = min(length, s->size);
 
-                    if (insert_extent_chunk(fcb->Vcb, fcb, c, start, extlen, prealloc && !page_file, data, NULL, rollback, BTRFS_COMPRESSION_NONE, extlen, FALSE, 0)) {
+                    if (insert_extent_chunk(fcb->Vcb, fcb, c, start, extlen, prealloc && !page_file, data, NULL, rollback, BTRFS_COMPRESSION_NONE, extlen, false, 0)) {
                         start += extlen;
                         length -= extlen;
                         if (data) data += extlen;
@@ -3057,19 +3049,19 @@ static NTSTATUS insert_chunk_fragmented(fcb* fcb, UINT64 start, UINT64 length, U
     return length == 0 ? STATUS_SUCCESS : STATUS_DISK_FULL;
 }
 
-static NTSTATUS insert_prealloc_extent(fcb* fcb, UINT64 start, UINT64 length, LIST_ENTRY* rollback) {
+static NTSTATUS insert_prealloc_extent(fcb* fcb, uint64_t start, uint64_t length, LIST_ENTRY* rollback) {
     LIST_ENTRY* le;
     chunk* c;
-    UINT64 flags;
+    uint64_t flags;
     NTSTATUS Status;
-    BOOL page_file = fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE;
+    bool page_file = fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE;
 
     flags = fcb->Vcb->data_flags;
 
     do {
-        UINT64 extlen = min(MAX_EXTENT_SIZE, length);
+        uint64_t extlen = min(MAX_EXTENT_SIZE, length);
 
-        ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, TRUE);
+        ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, true);
 
         le = fcb->Vcb->chunks.Flink;
         while (le != &fcb->Vcb->chunks) {
@@ -3079,7 +3071,7 @@ static NTSTATUS insert_prealloc_extent(fcb* fcb, UINT64 start, UINT64 length, LI
                 acquire_chunk_lock(c, fcb->Vcb);
 
                 if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= extlen) {
-                    if (insert_extent_chunk(fcb->Vcb, fcb, c, start, extlen, !page_file, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, extlen, FALSE, 0)) {
+                    if (insert_extent_chunk(fcb->Vcb, fcb, c, start, extlen, !page_file, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, extlen, false, 0)) {
                         ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
                         goto cont;
                     }
@@ -3093,9 +3085,9 @@ static NTSTATUS insert_prealloc_extent(fcb* fcb, UINT64 start, UINT64 length, LI
 
         ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
-        ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, true);
 
-        Status = alloc_chunk(fcb->Vcb, flags, &c, FALSE);
+        Status = alloc_chunk(fcb->Vcb, flags, &c, false);
 
         ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
 
@@ -3107,13 +3099,13 @@ static NTSTATUS insert_prealloc_extent(fcb* fcb, UINT64 start, UINT64 length, LI
         acquire_chunk_lock(c, fcb->Vcb);
 
         if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= extlen) {
-            if (insert_extent_chunk(fcb->Vcb, fcb, c, start, extlen, !page_file, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, extlen, FALSE, 0))
+            if (insert_extent_chunk(fcb->Vcb, fcb, c, start, extlen, !page_file, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, extlen, false, 0))
                 goto cont;
         }
 
         release_chunk_lock(c, fcb->Vcb);
 
-        Status = insert_chunk_fragmented(fcb, start, length, NULL, TRUE, rollback);
+        Status = insert_chunk_fragmented(fcb, start, length, NULL, true, rollback);
         if (!NT_SUCCESS(Status))
             ERR("insert_chunk_fragmented returned %08x\n", Status);
 
@@ -3130,14 +3122,14 @@ end:
     return Status;
 }
 
-static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, UINT64 start_data, UINT64 length, void* data,
-                              PIRP Irp, BOOL file_write, UINT64 irp_offset, LIST_ENTRY* rollback) {
+static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, uint64_t start_data, uint64_t length, void* data,
+                              PIRP Irp, bool file_write, uint64_t irp_offset, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     LIST_ENTRY* le;
     chunk* c;
-    UINT64 flags, orig_length = length, written = 0;
+    uint64_t flags, orig_length = length, written = 0;
 
-    TRACE("(%p, (%llx, %llx), %llx, %llx, %p)\n", Vcb, fcb->subvol->id, fcb->inode, start_data, length, data);
+    TRACE("(%p, (%I64x, %I64x), %I64x, %I64x, %p)\n", Vcb, fcb->subvol->id, fcb->inode, start_data, length, data);
 
     if (start_data > 0) {
         try_extend_data(Vcb, fcb, start_data, length, data, Irp, &written, file_write, irp_offset, rollback);
@@ -3148,20 +3140,20 @@ static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, UINT64 start_data
             start_data += written;
             irp_offset += written;
             length -= written;
-            data = &((UINT8*)data)[written];
+            data = &((uint8_t*)data)[written];
         }
     }
 
     flags = Vcb->data_flags;
 
     while (written < orig_length) {
-        UINT64 newlen = min(length, MAX_EXTENT_SIZE);
-        BOOL done = FALSE;
+        uint64_t newlen = min(length, MAX_EXTENT_SIZE);
+        bool done = false;
 
         // Rather than necessarily writing the whole extent at once, we deal with it in blocks of 128 MB.
         // First, see if we can write the extent part to an existing chunk.
 
-        ExAcquireResourceSharedLite(&Vcb->chunk_lock, TRUE);
+        ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
         le = Vcb->chunks.Flink;
         while (le != &Vcb->chunks) {
@@ -3171,18 +3163,18 @@ static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, UINT64 start_data
                 acquire_chunk_lock(c, Vcb);
 
                 if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= newlen &&
-                    insert_extent_chunk(Vcb, fcb, c, start_data, newlen, FALSE, data, Irp, rollback, BTRFS_COMPRESSION_NONE, newlen, file_write, irp_offset)) {
+                    insert_extent_chunk(Vcb, fcb, c, start_data, newlen, false, data, Irp, rollback, BTRFS_COMPRESSION_NONE, newlen, file_write, irp_offset)) {
                     written += newlen;
 
                     if (written == orig_length) {
                         ExReleaseResourceLite(&Vcb->chunk_lock);
                         return STATUS_SUCCESS;
                     } else {
-                        done = TRUE;
+                        done = true;
                         start_data += newlen;
                         irp_offset += newlen;
                         length -= newlen;
-                        data = &((UINT8*)data)[newlen];
+                        data = &((uint8_t*)data)[newlen];
                         break;
                     }
                 } else
@@ -3198,9 +3190,9 @@ static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, UINT64 start_data
 
         // Otherwise, see if we can put it in a new chunk.
 
-        ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE);
+        ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
-        Status = alloc_chunk(Vcb, flags, &c, FALSE);
+        Status = alloc_chunk(Vcb, flags, &c, false);
 
         ExReleaseResourceLite(&Vcb->chunk_lock);
 
@@ -3213,24 +3205,24 @@ static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, UINT64 start_data
             acquire_chunk_lock(c, Vcb);
 
             if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= newlen &&
-                insert_extent_chunk(Vcb, fcb, c, start_data, newlen, FALSE, data, Irp, rollback, BTRFS_COMPRESSION_NONE, newlen, file_write, irp_offset)) {
+                insert_extent_chunk(Vcb, fcb, c, start_data, newlen, false, data, Irp, rollback, BTRFS_COMPRESSION_NONE, newlen, file_write, irp_offset)) {
                 written += newlen;
 
                 if (written == orig_length)
                     return STATUS_SUCCESS;
                 else {
-                    done = TRUE;
+                    done = true;
                     start_data += newlen;
                     irp_offset += newlen;
                     length -= newlen;
-                    data = &((UINT8*)data)[newlen];
+                    data = &((uint8_t*)data)[newlen];
                 }
             } else
                 release_chunk_lock(c, Vcb);
         }
 
         if (!done) {
-            Status = insert_chunk_fragmented(fcb, start_data, length, data, FALSE, rollback);
+            Status = insert_chunk_fragmented(fcb, start_data, length, data, false, rollback);
             if (!NT_SUCCESS(Status))
                 ERR("insert_chunk_fragmented returned %08x\n", Status);
 
@@ -3241,14 +3233,14 @@ static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, UINT64 start_data
     return STATUS_DISK_FULL;
 }
 
-NTSTATUS truncate_file(fcb* fcb, UINT64 end, PIRP Irp, LIST_ENTRY* rollback) {
+NTSTATUS truncate_file(fcb* fcb, uint64_t end, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
 
     // FIXME - convert into inline extent if short enough
 
     if (end > 0 && fcb_is_inline(fcb)) {
-        UINT8* buf;
-        BOOL make_inline = end <= fcb->Vcb->options.max_inline;
+        uint8_t* buf;
+        bool make_inline = end <= fcb->Vcb->options.max_inline;
 
         buf = ExAllocatePoolWithTag(PagedPool, (ULONG)(make_inline ? (offsetof(EXTENT_DATA, data[0]) + end) : sector_align(end, fcb->Vcb->superblock.sector_size)), ALLOC_TAG);
         if (!buf) {
@@ -3273,7 +3265,7 @@ NTSTATUS truncate_file(fcb* fcb, UINT64 end, PIRP Irp, LIST_ENTRY* rollback) {
         if (!make_inline) {
             RtlZeroMemory(buf + end, (ULONG)(sector_align(end, fcb->Vcb->superblock.sector_size) - end));
 
-            Status = do_write_file(fcb, 0, sector_align(end, fcb->Vcb->superblock.sector_size), buf, Irp, FALSE, 0, rollback);
+            Status = do_write_file(fcb, 0, sector_align(end, fcb->Vcb->superblock.sector_size), buf, Irp, false, 0, rollback);
             if (!NT_SUCCESS(Status)) {
                 ERR("do_write_file returned %08x\n", Status);
                 ExFreePool(buf);
@@ -3289,7 +3281,7 @@ NTSTATUS truncate_file(fcb* fcb, UINT64 end, PIRP Irp, LIST_ENTRY* rollback) {
             ed->encoding = BTRFS_ENCODING_NONE;
             ed->type = EXTENT_TYPE_INLINE;
 
-            Status = add_extent_to_fcb(fcb, 0, ed, (UINT16)(offsetof(EXTENT_DATA, data[0]) + end), FALSE, NULL, rollback);
+            Status = add_extent_to_fcb(fcb, 0, ed, (uint16_t)(offsetof(EXTENT_DATA, data[0]) + end), false, NULL, rollback);
             if (!NT_SUCCESS(Status)) {
                 ERR("add_extent_to_fcb returned %08x\n", Status);
                 ExFreePool(buf);
@@ -3311,22 +3303,22 @@ NTSTATUS truncate_file(fcb* fcb, UINT64 end, PIRP Irp, LIST_ENTRY* rollback) {
     }
 
     fcb->inode_item.st_size = end;
-    fcb->inode_item_changed = TRUE;
-    TRACE("setting st_size to %llx\n", end);
+    fcb->inode_item_changed = true;
+    TRACE("setting st_size to %I64x\n", end);
 
     fcb->Header.AllocationSize.QuadPart = sector_align(fcb->inode_item.st_size, fcb->Vcb->superblock.sector_size);
     fcb->Header.FileSize.QuadPart = fcb->inode_item.st_size;
     fcb->Header.ValidDataLength.QuadPart = fcb->inode_item.st_size;
     // FIXME - inform cache manager of this
 
-    TRACE("fcb %p FileSize = %llx\n", fcb, fcb->Header.FileSize.QuadPart);
+    TRACE("fcb %p FileSize = %I64x\n", fcb, fcb->Header.FileSize.QuadPart);
 
     return STATUS_SUCCESS;
 }
 
-NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIRP Irp, LIST_ENTRY* rollback) {
-    UINT64 oldalloc, newalloc;
-    BOOL cur_inline;
+NTSTATUS extend_file(fcb* fcb, file_ref* fileref, uint64_t end, bool prealloc, PIRP Irp, LIST_ENTRY* rollback) {
+    uint64_t oldalloc, newalloc;
+    bool cur_inline;
     NTSTATUS Status;
 
     TRACE("(%p, %p, %x, %u)\n", fcb, fileref, end, prealloc);
@@ -3335,7 +3327,7 @@ NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIR
         if (end > 0xffff)
             return STATUS_DISK_FULL;
 
-        return stream_set_end_of_file_information(fcb->Vcb, (UINT16)end, fcb, fileref, FALSE);
+        return stream_set_end_of_file_information(fcb->Vcb, (uint16_t)end, fcb, fileref, false);
     } else {
         extent* ext = NULL;
         LIST_ENTRY* le;
@@ -3361,20 +3353,20 @@ NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIR
             cur_inline = ed->type == EXTENT_TYPE_INLINE;
 
             if (cur_inline && end > fcb->Vcb->options.max_inline) {
-                UINT64 origlength, length;
-                UINT8* data;
+                uint64_t origlength, length;
+                uint8_t* data;
 
                 TRACE("giving inline file proper extents\n");
 
                 origlength = ed->decoded_size;
 
-                cur_inline = FALSE;
+                cur_inline = false;
 
                 length = sector_align(origlength, fcb->Vcb->superblock.sector_size);
 
                 data = ExAllocatePoolWithTag(PagedPool, (ULONG)length, ALLOC_TAG);
                 if (!data) {
-                    ERR("could not allocate %llx bytes for data\n", length);
+                    ERR("could not allocate %I64x bytes for data\n", length);
                     return STATUS_INSUFFICIENT_RESOURCES;
                 }
 
@@ -3394,7 +3386,7 @@ NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIR
                     return Status;
                 }
 
-                Status = do_write_file(fcb, 0, length, data, Irp, FALSE, 0, rollback);
+                Status = do_write_file(fcb, 0, length, data, Irp, false, 0, rollback);
                 if (!NT_SUCCESS(Status)) {
                     ERR("do_write_file returned %08x\n", Status);
                     ExFreePool(data);
@@ -3407,10 +3399,10 @@ NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIR
             }
 
             if (cur_inline) {
-                UINT16 edsize;
+                uint16_t edsize;
 
                 if (end > oldalloc) {
-                    edsize = (UINT16)(offsetof(EXTENT_DATA, data[0]) + end - ext->offset);
+                    edsize = (uint16_t)(offsetof(EXTENT_DATA, data[0]) + end - ext->offset);
                     ed = ExAllocatePoolWithTag(PagedPool, edsize, ALLOC_TAG);
 
                     if (!ed) {
@@ -3445,14 +3437,14 @@ NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIR
 
                     ExFreePool(ed);
 
-                    fcb->extents_changed = TRUE;
+                    fcb->extents_changed = true;
                     mark_fcb_dirty(fcb);
                 }
 
-                TRACE("extending inline file (oldalloc = %llx, end = %llx)\n", oldalloc, end);
+                TRACE("extending inline file (oldalloc = %I64x, end = %I64x)\n", oldalloc, end);
 
                 fcb->inode_item.st_size = end;
-                TRACE("setting st_size to %llx\n", end);
+                TRACE("setting st_size to %I64x\n", end);
 
                 fcb->inode_item.st_blocks = end;
 
@@ -3472,16 +3464,16 @@ NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIR
                         }
                     }
 
-                    fcb->extents_changed = TRUE;
+                    fcb->extents_changed = true;
                 }
 
                 fcb->inode_item.st_size = end;
-                fcb->inode_item_changed = TRUE;
+                fcb->inode_item_changed = true;
                 mark_fcb_dirty(fcb);
 
-                TRACE("setting st_size to %llx\n", end);
+                TRACE("setting st_size to %I64x\n", end);
 
-                TRACE("newalloc = %llx\n", newalloc);
+                TRACE("newalloc = %I64x\n", newalloc);
 
                 fcb->Header.AllocationSize.QuadPart = newalloc;
                 fcb->Header.FileSize.QuadPart = fcb->Header.ValidDataLength.QuadPart = end;
@@ -3499,22 +3491,22 @@ NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIR
                     }
                 }
 
-                fcb->extents_changed = TRUE;
-                fcb->inode_item_changed = TRUE;
+                fcb->extents_changed = true;
+                fcb->inode_item_changed = true;
                 mark_fcb_dirty(fcb);
 
                 fcb->inode_item.st_size = end;
-                TRACE("setting st_size to %llx\n", end);
+                TRACE("setting st_size to %I64x\n", end);
 
-                TRACE("newalloc = %llx\n", newalloc);
+                TRACE("newalloc = %I64x\n", newalloc);
 
                 fcb->Header.AllocationSize.QuadPart = newalloc;
                 fcb->Header.FileSize.QuadPart = fcb->Header.ValidDataLength.QuadPart = end;
             } else {
                 EXTENT_DATA* ed;
-                UINT16 edsize;
+                uint16_t edsize;
 
-                edsize = (UINT16)(offsetof(EXTENT_DATA, data[0]) + end);
+                edsize = (uint16_t)(offsetof(EXTENT_DATA, data[0]) + end);
                 ed = ExAllocatePoolWithTag(PagedPool, edsize, ALLOC_TAG);
 
                 if (!ed) {
@@ -3531,7 +3523,7 @@ NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIR
 
                 RtlZeroMemory(ed->data, (ULONG)end);
 
-                Status = add_extent_to_fcb(fcb, 0, ed, edsize, FALSE, NULL, rollback);
+                Status = add_extent_to_fcb(fcb, 0, ed, edsize, false, NULL, rollback);
                 if (!NT_SUCCESS(Status)) {
                     ERR("add_extent_to_fcb returned %08x\n", Status);
                     ExFreePool(ed);
@@ -3540,12 +3532,12 @@ NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIR
 
                 ExFreePool(ed);
 
-                fcb->extents_changed = TRUE;
-                fcb->inode_item_changed = TRUE;
+                fcb->extents_changed = true;
+                fcb->inode_item_changed = true;
                 mark_fcb_dirty(fcb);
 
                 fcb->inode_item.st_size = end;
-                TRACE("setting st_size to %llx\n", end);
+                TRACE("setting st_size to %I64x\n", end);
 
                 fcb->inode_item.st_blocks = end;
 
@@ -3557,8 +3549,8 @@ NTSTATUS extend_file(fcb* fcb, file_ref* fileref, UINT64 end, BOOL prealloc, PIR
     return STATUS_SUCCESS;
 }
 
-static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data, UINT64 end_data, void* data, UINT64* written,
-                                       PIRP Irp, BOOL file_write, UINT64 irp_offset, ULONG priority, LIST_ENTRY* rollback) {
+static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, uint64_t start_data, uint64_t end_data, void* data, uint64_t* written,
+                                       PIRP Irp, bool file_write, uint64_t irp_offset, ULONG priority, LIST_ENTRY* rollback) {
     EXTENT_DATA* ed = &ext->extent_data;
     EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ed->data;
     NTSTATUS Status;
@@ -3577,7 +3569,7 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
 
         newext->extent_data.type = EXTENT_TYPE_REGULAR;
 
-        Status = write_data_complete(fcb->Vcb, ed2->address + ed2->offset, (UINT8*)data + ext->offset - start_data, (UINT32)ed2->num_bytes, Irp,
+        Status = write_data_complete(fcb->Vcb, ed2->address + ed2->offset, (uint8_t*)data + ext->offset - start_data, (uint32_t)ed2->num_bytes, Irp,
                                      NULL, file_write, irp_offset + ext->offset - start_data, priority);
         if (!NT_SUCCESS(Status)) {
             ERR("write_data_complete returned %08x\n", Status);
@@ -3586,7 +3578,7 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
 
         if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
             ULONG sl = (ULONG)(ed2->num_bytes / fcb->Vcb->superblock.sector_size);
-            UINT32* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(UINT32), ALLOC_TAG);
+            uint32_t* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(uint32_t), ALLOC_TAG);
 
             if (!csum) {
                 ERR("out of memory\n");
@@ -3594,7 +3586,7 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
                 return STATUS_INSUFFICIENT_RESOURCES;
             }
 
-            Status = calc_csum(fcb->Vcb, (UINT8*)data + ext->offset - start_data, sl, csum);
+            Status = calc_csum(fcb->Vcb, (uint8_t*)data + ext->offset - start_data, sl, csum);
             if (!NT_SUCCESS(Status)) {
                 ERR("calc_csum returned %08x\n", Status);
                 ExFreePool(csum);
@@ -3611,8 +3603,8 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         newext->offset = ext->offset;
         newext->datalen = ext->datalen;
         newext->unique = ext->unique;
-        newext->ignore = FALSE;
-        newext->inserted = TRUE;
+        newext->ignore = false;
+        newext->inserted = true;
         InsertHeadList(&ext->list_entry, &newext->list_entry);
 
         add_insert_extent_rollback(rollback, fcb, newext);
@@ -3647,7 +3639,7 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         ned2->offset += end_data - ext->offset;
         ned2->num_bytes -= end_data - ext->offset;
 
-        Status = write_data_complete(fcb->Vcb, ed2->address + ed2->offset, (UINT8*)data + ext->offset - start_data, (UINT32)(end_data - ext->offset),
+        Status = write_data_complete(fcb->Vcb, ed2->address + ed2->offset, (uint8_t*)data + ext->offset - start_data, (uint32_t)(end_data - ext->offset),
                                      Irp, NULL, file_write, irp_offset + ext->offset - start_data, priority);
         if (!NT_SUCCESS(Status)) {
             ERR("write_data_complete returned %08x\n", Status);
@@ -3658,7 +3650,7 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
 
         if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
             ULONG sl = (ULONG)((end_data - ext->offset) / fcb->Vcb->superblock.sector_size);
-            UINT32* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(UINT32), ALLOC_TAG);
+            uint32_t* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(uint32_t), ALLOC_TAG);
 
             if (!csum) {
                 ERR("out of memory\n");
@@ -3667,7 +3659,7 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
                 return STATUS_INSUFFICIENT_RESOURCES;
             }
 
-            Status = calc_csum(fcb->Vcb, (UINT8*)data + ext->offset - start_data, sl, csum);
+            Status = calc_csum(fcb->Vcb, (uint8_t*)data + ext->offset - start_data, sl, csum);
             if (!NT_SUCCESS(Status)) {
                 ERR("calc_csum returned %08x\n", Status);
                 ExFreePool(newext1);
@@ -3685,8 +3677,8 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         newext1->offset = ext->offset;
         newext1->datalen = ext->datalen;
         newext1->unique = ext->unique;
-        newext1->ignore = FALSE;
-        newext1->inserted = TRUE;
+        newext1->ignore = false;
+        newext1->inserted = true;
         InsertHeadList(&ext->list_entry, &newext1->list_entry);
 
         add_insert_extent_rollback(rollback, fcb, newext1);
@@ -3694,8 +3686,8 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         newext2->offset = end_data;
         newext2->datalen = ext->datalen;
         newext2->unique = ext->unique;
-        newext2->ignore = FALSE;
-        newext2->inserted = TRUE;
+        newext2->ignore = false;
+        newext2->inserted = true;
         newext2->csum = NULL;
         add_extent(fcb, &newext1->list_entry, newext2);
 
@@ -3704,10 +3696,10 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         c = get_chunk_from_address(fcb->Vcb, ed2->address);
 
         if (!c)
-            ERR("get_chunk_from_address(%llx) failed\n", ed2->address);
+            ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
         else {
             Status = update_changed_extent_ref(fcb->Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, 1,
-                                                fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, Irp);
+                                                fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
 
             if (!NT_SUCCESS(Status)) {
                 ERR("update_changed_extent_ref returned %08x\n", Status);
@@ -3745,7 +3737,7 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         ned2->offset += start_data - ext->offset;
         ned2->num_bytes = ext->offset + ed2->num_bytes - start_data;
 
-        Status = write_data_complete(fcb->Vcb, ed2->address + ned2->offset, data, (UINT32)ned2->num_bytes, Irp, NULL, file_write, irp_offset, priority);
+        Status = write_data_complete(fcb->Vcb, ed2->address + ned2->offset, data, (uint32_t)ned2->num_bytes, Irp, NULL, file_write, irp_offset, priority);
         if (!NT_SUCCESS(Status)) {
             ERR("write_data_complete returned %08x\n", Status);
             ExFreePool(newext1);
@@ -3755,7 +3747,7 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
 
         if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
             ULONG sl = (ULONG)(ned2->num_bytes / fcb->Vcb->superblock.sector_size);
-            UINT32* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(UINT32), ALLOC_TAG);
+            uint32_t* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(uint32_t), ALLOC_TAG);
 
             if (!csum) {
                 ERR("out of memory\n");
@@ -3782,8 +3774,8 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         newext1->offset = ext->offset;
         newext1->datalen = ext->datalen;
         newext1->unique = ext->unique;
-        newext1->ignore = FALSE;
-        newext1->inserted = TRUE;
+        newext1->ignore = false;
+        newext1->inserted = true;
         newext1->csum = NULL;
         InsertHeadList(&ext->list_entry, &newext1->list_entry);
 
@@ -3792,8 +3784,8 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         newext2->offset = start_data;
         newext2->datalen = ext->datalen;
         newext2->unique = ext->unique;
-        newext2->ignore = FALSE;
-        newext2->inserted = TRUE;
+        newext2->ignore = false;
+        newext2->inserted = true;
         add_extent(fcb, &newext1->list_entry, newext2);
 
         add_insert_extent_rollback(rollback, fcb, newext2);
@@ -3801,10 +3793,10 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         c = get_chunk_from_address(fcb->Vcb, ed2->address);
 
         if (!c)
-            ERR("get_chunk_from_address(%llx) failed\n", ed2->address);
+            ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
         else {
             Status = update_changed_extent_ref(fcb->Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, 1,
-                                               fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, Irp);
+                                               fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
 
             if (!NT_SUCCESS(Status)) {
                 ERR("update_changed_extent_ref returned %08x\n", Status);
@@ -3855,7 +3847,7 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         ned2->num_bytes -= end_data - ext->offset;
 
         ned2 = (EXTENT_DATA2*)newext2->extent_data.data;
-        Status = write_data_complete(fcb->Vcb, ed2->address + ned2->offset, data, (UINT32)(end_data - start_data), Irp, NULL, file_write, irp_offset, priority);
+        Status = write_data_complete(fcb->Vcb, ed2->address + ned2->offset, data, (uint32_t)(end_data - start_data), Irp, NULL, file_write, irp_offset, priority);
         if (!NT_SUCCESS(Status)) {
             ERR("write_data_complete returned %08x\n", Status);
             ExFreePool(newext1);
@@ -3866,7 +3858,7 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
 
         if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
             ULONG sl = (ULONG)((end_data - start_data) / fcb->Vcb->superblock.sector_size);
-            UINT32* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(UINT32), ALLOC_TAG);
+            uint32_t* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(uint32_t), ALLOC_TAG);
 
             if (!csum) {
                 ERR("out of memory\n");
@@ -3895,8 +3887,8 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         newext1->offset = ext->offset;
         newext1->datalen = ext->datalen;
         newext1->unique = ext->unique;
-        newext1->ignore = FALSE;
-        newext1->inserted = TRUE;
+        newext1->ignore = false;
+        newext1->inserted = true;
         newext1->csum = NULL;
         InsertHeadList(&ext->list_entry, &newext1->list_entry);
 
@@ -3905,8 +3897,8 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         newext2->offset = start_data;
         newext2->datalen = ext->datalen;
         newext2->unique = ext->unique;
-        newext2->ignore = FALSE;
-        newext2->inserted = TRUE;
+        newext2->ignore = false;
+        newext2->inserted = true;
         add_extent(fcb, &newext1->list_entry, newext2);
 
         add_insert_extent_rollback(rollback, fcb, newext2);
@@ -3914,8 +3906,8 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         newext3->offset = end_data;
         newext3->datalen = ext->datalen;
         newext3->unique = ext->unique;
-        newext3->ignore = FALSE;
-        newext3->inserted = TRUE;
+        newext3->ignore = false;
+        newext3->inserted = true;
         newext3->csum = NULL;
         add_extent(fcb, &newext2->list_entry, newext3);
 
@@ -3924,10 +3916,10 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
         c = get_chunk_from_address(fcb->Vcb, ed2->address);
 
         if (!c)
-            ERR("get_chunk_from_address(%llx) failed\n", ed2->address);
+            ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
         else {
             Status = update_changed_extent_ref(fcb->Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, 2,
-                                               fcb->inode_item.flags & BTRFS_INODE_NODATASUM, FALSE, Irp);
+                                               fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
 
             if (!NT_SUCCESS(Status)) {
                 ERR("update_changed_extent_ref returned %08x\n", Status);
@@ -3939,20 +3931,21 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data,
     }
 
     if (c)
-        c->changed = TRUE;
+        c->changed = true;
 
     return STATUS_SUCCESS;
 }
 
-NTSTATUS do_write_file(fcb* fcb, UINT64 start, UINT64 end_data, void* data, PIRP Irp, BOOL file_write, UINT32 irp_offset, LIST_ENTRY* rollback) {
+NTSTATUS do_write_file(fcb* fcb, uint64_t start, uint64_t end_data, void* data, PIRP Irp, bool file_write, uint32_t irp_offset, LIST_ENTRY* rollback) {
     NTSTATUS Status;
     LIST_ENTRY *le, *le2;
-    UINT64 written = 0, length = end_data - start;
-    UINT64 last_cow_start;
+    uint64_t written = 0, length = end_data - start;
+    uint64_t last_cow_start;
     ULONG priority = fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE ? HighPagePriority : NormalPagePriority;
 #ifdef DEBUG_PARANOID
-    UINT64 last_off;
+    uint64_t last_off;
 #endif
+    bool extents_changed = false;
 
     last_cow_start = 0;
 
@@ -3965,7 +3958,7 @@ NTSTATUS do_write_file(fcb* fcb, UINT64 start, UINT64 end_data, void* data, PIRP
         if (!ext->ignore) {
             EXTENT_DATA* ed = &ext->extent_data;
             EXTENT_DATA2* ed2 = ed->type == EXTENT_TYPE_INLINE ? NULL : (EXTENT_DATA2*)ed->data;
-            UINT64 len;
+            uint64_t len;
 
             len = ed->type == EXTENT_TYPE_INLINE ? ed->decoded_size : ed2->num_bytes;
 
@@ -3977,7 +3970,9 @@ NTSTATUS do_write_file(fcb* fcb, UINT64 start, UINT64 end_data, void* data, PIRP
 
             if ((fcb->inode_item.flags & BTRFS_INODE_NODATACOW || ed->type == EXTENT_TYPE_PREALLOC) && ext->unique && ed->compression == BTRFS_COMPRESSION_NONE) {
                 if (max(last_cow_start, start + written) < ext->offset) {
-                    UINT64 start_write = max(last_cow_start, start + written);
+                    uint64_t start_write = max(last_cow_start, start + written);
+
+                    extents_changed = true;
 
                     Status = excise_extents(fcb->Vcb, fcb, start_write, ext->offset, Irp, rollback);
                     if (!NT_SUCCESS(Status)) {
@@ -3985,7 +3980,7 @@ NTSTATUS do_write_file(fcb* fcb, UINT64 start, UINT64 end_data, void* data, PIRP
                         return Status;
                     }
 
-                    Status = insert_extent(fcb->Vcb, fcb, start_write, ext->offset - start_write, (UINT8*)data + written, Irp, file_write, irp_offset + written, rollback);
+                    Status = insert_extent(fcb->Vcb, fcb, start_write, ext->offset - start_write, (uint8_t*)data + written, Irp, file_write, irp_offset + written, rollback);
                     if (!NT_SUCCESS(Status)) {
                         ERR("insert_extent returned %08x\n", Status);
                         return Status;
@@ -3999,13 +3994,13 @@ NTSTATUS do_write_file(fcb* fcb, UINT64 start, UINT64 end_data, void* data, PIRP
                 }
 
                 if (ed->type == EXTENT_TYPE_REGULAR) {
-                    UINT64 writeaddr = ed2->address + ed2->offset + start + written - ext->offset;
-                    UINT64 write_len = min(len, length);
+                    uint64_t writeaddr = ed2->address + ed2->offset + start + written - ext->offset;
+                    uint64_t write_len = min(len, length);
                     chunk* c;
 
-                    TRACE("doing non-COW write to %llx\n", writeaddr);
+                    TRACE("doing non-COW write to %I64x\n", writeaddr);
 
-                    Status = write_data_complete(fcb->Vcb, writeaddr, (UINT8*)data + written, (UINT32)write_len, Irp, NULL, file_write, irp_offset + written, priority);
+                    Status = write_data_complete(fcb->Vcb, writeaddr, (uint8_t*)data + written, (uint32_t)write_len, Irp, NULL, file_write, irp_offset + written, priority);
                     if (!NT_SUCCESS(Status)) {
                         ERR("write_data_complete returned %08x\n", Status);
                         return Status;
@@ -4013,14 +4008,15 @@ NTSTATUS do_write_file(fcb* fcb, UINT64 start, UINT64 end_data, void* data, PIRP
 
                     c = get_chunk_from_address(fcb->Vcb, writeaddr);
                     if (c)
-                        c->changed = TRUE;
+                        c->changed = true;
 
                     // This shouldn't ever get called - nocow files should always also be nosum.
                     if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
-                        calc_csum(fcb->Vcb, (UINT8*)data + written, (UINT32)(write_len / fcb->Vcb->superblock.sector_size),
+                        calc_csum(fcb->Vcb, (uint8_t*)data + written, (uint32_t)(write_len / fcb->Vcb->superblock.sector_size),
                                   &ext->csum[(start + written - ext->offset) / fcb->Vcb->superblock.sector_size]);
 
-                        ext->inserted = TRUE;
+                        ext->inserted = true;
+                        extents_changed = true;
                     }
 
                     written += write_len;
@@ -4029,15 +4025,17 @@ NTSTATUS do_write_file(fcb* fcb, UINT64 start, UINT64 end_data, void* data, PIRP
                     if (length == 0)
                         break;
                 } else if (ed->type == EXTENT_TYPE_PREALLOC) {
-                    UINT64 write_len;
+                    uint64_t write_len;
 
-                    Status = do_write_file_prealloc(fcb, ext, start + written, end_data, (UINT8*)data + written, &write_len,
+                    Status = do_write_file_prealloc(fcb, ext, start + written, end_data, (uint8_t*)data + written, &write_len,
                                                     Irp, file_write, irp_offset + written, priority, rollback);
                     if (!NT_SUCCESS(Status)) {
                         ERR("do_write_file_prealloc returned %08x\n", Status);
                         return Status;
                     }
 
+                    extents_changed = true;
+
                     written += write_len;
                     length -= write_len;
 
@@ -4054,7 +4052,9 @@ nextitem:
     }
 
     if (length > 0) {
-        UINT64 start_write = max(last_cow_start, start + written);
+        uint64_t start_write = max(last_cow_start, start + written);
+
+        extents_changed = true;
 
         Status = excise_extents(fcb->Vcb, fcb, start_write, end_data, Irp, rollback);
         if (!NT_SUCCESS(Status)) {
@@ -4062,7 +4062,7 @@ nextitem:
             return Status;
         }
 
-        Status = insert_extent(fcb->Vcb, fcb, start_write, end_data - start_write, (UINT8*)data + written, Irp, file_write, irp_offset + written, rollback);
+        Status = insert_extent(fcb->Vcb, fcb, start_write, end_data - start_write, (uint8_t*)data + written, Irp, file_write, irp_offset + written, rollback);
         if (!NT_SUCCESS(Status)) {
             ERR("insert_extent returned %08x\n", Status);
             return Status;
@@ -4078,7 +4078,7 @@ nextitem:
 
         if (!ext->ignore) {
             if (ext->offset == last_off) {
-                ERR("offset %llx duplicated\n", ext->offset);
+                ERR("offset %I64x duplicated\n", ext->offset);
                 int3;
             } else if (ext->offset < last_off && last_off != 0xffffffffffffffff) {
                 ERR("offsets out of order\n");
@@ -4092,24 +4092,26 @@ nextitem:
     }
 #endif
 
-    fcb->extents_changed = TRUE;
-    mark_fcb_dirty(fcb);
+    if (extents_changed) {
+        fcb->extents_changed = true;
+        mark_fcb_dirty(fcb);
+    }
 
     return STATUS_SUCCESS;
 }
 
-NTSTATUS write_compressed(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, PIRP Irp, LIST_ENTRY* rollback) {
+NTSTATUS write_compressed(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, PIRP Irp, LIST_ENTRY* rollback) {
     NTSTATUS Status;
-    UINT64 i;
+    uint64_t i;
 
     for (i = 0; i < sector_align(end_data - start_data, COMPRESSED_EXTENT_SIZE) / COMPRESSED_EXTENT_SIZE; i++) {
-        UINT64 s2, e2;
-        BOOL compressed;
+        uint64_t s2, e2;
+        bool compressed;
 
         s2 = start_data + (i * COMPRESSED_EXTENT_SIZE);
         e2 = min(s2 + COMPRESSED_EXTENT_SIZE, end_data);
 
-        Status = write_compressed_bit(fcb, s2, e2, (UINT8*)data + (i * COMPRESSED_EXTENT_SIZE), &compressed, Irp, rollback);
+        Status = write_compressed_bit(fcb, s2, e2, (uint8_t*)data + (i * COMPRESSED_EXTENT_SIZE), &compressed, Irp, rollback);
 
         if (!NT_SUCCESS(Status)) {
             ERR("write_compressed_bit returned %08x\n", Status);
@@ -4120,12 +4122,12 @@ NTSTATUS write_compressed(fcb* fcb, UINT64 start_data, UINT64 end_data, void* da
         // bother with the rest of it.
         if (s2 == 0 && e2 == COMPRESSED_EXTENT_SIZE && !compressed && !fcb->Vcb->options.compress_force) {
             fcb->inode_item.flags |= BTRFS_INODE_NOCOMPRESS;
-            fcb->inode_item_changed = TRUE;
+            fcb->inode_item_changed = true;
             mark_fcb_dirty(fcb);
 
             // write subsequent data non-compressed
             if (e2 < end_data) {
-                Status = do_write_file(fcb, e2, end_data, (UINT8*)data + e2, Irp, FALSE, 0, rollback);
+                Status = do_write_file(fcb, e2, end_data, (uint8_t*)data + e2, Irp, false, 0, rollback);
 
                 if (!NT_SUCCESS(Status)) {
                     ERR("do_write_file returned %08x\n", Status);
@@ -4140,27 +4142,26 @@ NTSTATUS write_compressed(fcb* fcb, UINT64 start_data, UINT64 end_data, void* da
     return STATUS_SUCCESS;
 }
 
-NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void* buf, ULONG* length, BOOLEAN paging_io, BOOLEAN no_cache,
-                     BOOLEAN wait, BOOLEAN deferred_write, BOOLEAN write_irp, LIST_ENTRY* rollback) {
+NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void* buf, ULONG* length, bool paging_io, bool no_cache,
+                     bool wait, bool deferred_write, bool write_irp, LIST_ENTRY* rollback) {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     EXTENT_DATA* ed2;
-    UINT64 off64, newlength, start_data, end_data;
-    UINT32 bufhead;
-    BOOL make_inline;
-    UINT8* data;
+    uint64_t off64, newlength, start_data, end_data;
+    uint32_t bufhead;
+    bool make_inline;
     INODE_ITEM* origii;
-    BOOL changed_length = FALSE;
+    bool changed_length = false;
     NTSTATUS Status;
     LARGE_INTEGER time;
     BTRFS_TIME now;
     fcb* fcb;
     ccb* ccb;
     file_ref* fileref;
-    BOOL paging_lock = FALSE, fcb_lock = FALSE, tree_lock = FALSE, pagefile;
+    bool paging_lock = false, acquired_fcb_lock = false, acquired_tree_lock = false, pagefile;
     ULONG filter = 0;
 
-    TRACE("(%p, %p, %llx, %p, %x, %u, %u)\n", Vcb, FileObject, offset.QuadPart, buf, *length, paging_io, no_cache);
+    TRACE("(%p, %p, %I64x, %p, %x, %u, %u)\n", Vcb, FileObject, offset.QuadPart, buf, *length, paging_io, no_cache);
 
     if (*length == 0) {
         WARN("returning success for zero-length write\n");
@@ -4177,7 +4178,7 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
     fileref = ccb ? ccb->fileref : NULL;
 
     if (!fcb->ads && fcb->type != BTRFS_TYPE_FILE && fcb->type != BTRFS_TYPE_SYMLINK) {
-        WARN("tried to write to something other than a file or symlink (inode %llx, type %u, %p, %p)\n", fcb->inode, fcb->type, &fcb->type, fcb);
+        WARN("tried to write to something other than a file or symlink (inode %I64x, type %u, %p, %p)\n", fcb->inode, fcb->type, &fcb->type, fcb);
         return STATUS_INVALID_DEVICE_REQUEST;
     }
 
@@ -4197,7 +4198,7 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
     if (no_cache && !paging_io && FileObject->SectionObjectPointer->DataSectionObject) {
         IO_STATUS_BLOCK iosb;
 
-        ExAcquireResourceExclusiveLite(fcb->Header.PagingIoResource, TRUE);
+        ExAcquireResourceExclusiveLite(fcb->Header.PagingIoResource, true);
 
         CcFlushCache(FileObject->SectionObjectPointer, &offset, *length, &iosb);
 
@@ -4207,9 +4208,9 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
             return iosb.Status;
         }
 
-        paging_lock = TRUE;
+        paging_lock = true;
 
-        CcPurgeCacheSection(FileObject->SectionObjectPointer, &offset, *length, FALSE);
+        CcPurgeCacheSection(FileObject->SectionObjectPointer, &offset, *length, false);
     }
 
     if (paging_io) {
@@ -4217,7 +4218,7 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
             Status = STATUS_PENDING;
             goto end;
         } else
-            paging_lock = TRUE;
+            paging_lock = true;
     }
 
     pagefile = fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE && paging_io;
@@ -4227,7 +4228,7 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
             Status = STATUS_PENDING;
             goto end;
         } else
-            tree_lock = TRUE;
+            acquired_tree_lock = true;
     }
 
     if (no_cache) {
@@ -4236,13 +4237,13 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
                 Status = STATUS_PENDING;
                 goto end;
             } else
-                fcb_lock = TRUE;
+                acquired_fcb_lock = true;
         } else if (!ExIsResourceAcquiredExclusiveLite(fcb->Header.Resource)) {
             if (!ExAcquireResourceExclusiveLite(fcb->Header.Resource, wait)) {
                 Status = STATUS_PENDING;
                 goto end;
             } else
-                fcb_lock = TRUE;
+                acquired_fcb_lock = true;
         }
     }
 
@@ -4251,14 +4252,14 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
     if (fcb->deleted)
         newlength = 0;
 
-    TRACE("newlength = %llx\n", newlength);
+    TRACE("newlength = %I64x\n", newlength);
 
     if (off64 + *length > newlength) {
         if (paging_io) {
             if (off64 >= newlength) {
-                TRACE("paging IO tried to write beyond end of file (file size = %llx, offset = %llx, length = %x)\n", newlength, off64, *length);
+                TRACE("paging IO tried to write beyond end of file (file size = %I64x, offset = %I64x, length = %x)\n", newlength, off64, *length);
                 TRACE("filename %S\n", file_desc(FileObject));
-                TRACE("FileObject: AllocationSize = %llx, FileSize = %llx, ValidDataLength = %llx\n",
+                TRACE("FileObject: AllocationSize = %I64x, FileSize = %I64x, ValidDataLength = %I64x\n",
                     fcb->Header.AllocationSize.QuadPart, fcb->Header.FileSize.QuadPart, fcb->Header.ValidDataLength.QuadPart);
                 Status = STATUS_SUCCESS;
                 goto end;
@@ -4267,22 +4268,22 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
             *length = (ULONG)(newlength - off64);
         } else {
             newlength = off64 + *length;
-            changed_length = TRUE;
+            changed_length = true;
 
-            TRACE("extending length to %llx\n", newlength);
+            TRACE("extending length to %I64x\n", newlength);
         }
     }
 
     if (fcb->ads)
-        make_inline = FALSE;
+        make_inline = false;
     else if (fcb->type == BTRFS_TYPE_SYMLINK)
         make_inline = newlength <= (Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node) - offsetof(EXTENT_DATA, data[0]));
     else
         make_inline = newlength <= fcb->Vcb->options.max_inline;
 
     if (changed_length) {
-        if (newlength > (UINT64)fcb->Header.AllocationSize.QuadPart) {
-            if (!tree_lock) {
+        if (newlength > (uint64_t)fcb->Header.AllocationSize.QuadPart) {
+            if (!acquired_tree_lock) {
                 // We need to acquire the tree lock if we don't have it already -
                 // we can't give an inline file proper extents at the same time as we're
                 // doing a flush.
@@ -4290,10 +4291,10 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
                     Status = STATUS_PENDING;
                     goto end;
                 } else
-                    tree_lock = TRUE;
+                    acquired_tree_lock = true;
             }
 
-            Status = extend_file(fcb, fileref, newlength, FALSE, Irp, rollback);
+            Status = extend_file(fcb, fileref, newlength, false, Irp, rollback);
             if (!NT_SUCCESS(Status)) {
                 ERR("extend_file returned %08x\n", Status);
                 goto end;
@@ -4304,9 +4305,9 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
         fcb->Header.FileSize.QuadPart = newlength;
         fcb->Header.ValidDataLength.QuadPart = newlength;
 
-        TRACE("AllocationSize = %llx\n", fcb->Header.AllocationSize.QuadPart);
-        TRACE("FileSize = %llx\n", fcb->Header.FileSize.QuadPart);
-        TRACE("ValidDataLength = %llx\n", fcb->Header.ValidDataLength.QuadPart);
+        TRACE("AllocationSize = %I64x\n", fcb->Header.AllocationSize.QuadPart);
+        TRACE("FileSize = %I64x\n", fcb->Header.FileSize.QuadPart);
+        TRACE("ValidDataLength = %I64x\n", fcb->Header.ValidDataLength.QuadPart);
     }
 
     if (!no_cache) {
@@ -4333,14 +4334,14 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
                 goto end;
             } else {
                 if (fCcCopyWriteEx) {
-                    TRACE("CcCopyWriteEx(%p, %llx, %x, %u, %p, %p)\n", FileObject, off64, *length, wait, buf, Irp->Tail.Overlay.Thread);
+                    TRACE("CcCopyWriteEx(%p, %I64x, %x, %u, %p, %p)\n", FileObject, off64, *length, wait, buf, Irp->Tail.Overlay.Thread);
                     if (!fCcCopyWriteEx(FileObject, &offset, *length, wait, buf, Irp->Tail.Overlay.Thread)) {
                         Status = STATUS_PENDING;
                         goto end;
                     }
                     TRACE("CcCopyWriteEx finished\n");
                 } else {
-                    TRACE("CcCopyWrite(%p, %llx, %x, %u, %p)\n", FileObject, off64, *length, wait, buf);
+                    TRACE("CcCopyWrite(%p, %I64x, %x, %u, %p)\n", FileObject, off64, *length, wait, buf);
                     if (!CcCopyWrite(FileObject, &offset, *length, wait, buf)) {
                         Status = STATUS_PENDING;
                         goto end;
@@ -4365,7 +4366,7 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
             char* data2;
 
             if (newlength > fcb->adsmaxlen) {
-                ERR("error - xattr too long (%llu > %u)\n", newlength, fcb->adsmaxlen);
+                ERR("error - xattr too long (%I64u > %u)\n", newlength, fcb->adsmaxlen);
                 Status = STATUS_DISK_FULL;
                 goto end;
             }
@@ -4404,19 +4405,20 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
         if (fileref)
             mark_fileref_dirty(fileref);
     } else {
-        BOOL compress = write_fcb_compressed(fcb), no_buf = FALSE;
+        bool compress = write_fcb_compressed(fcb), no_buf = false;
+        uint8_t* data;
 
         if (make_inline) {
             start_data = 0;
             end_data = sector_align(newlength, fcb->Vcb->superblock.sector_size);
             bufhead = sizeof(EXTENT_DATA) - 1;
         } else if (compress) {
-            start_data = off64 & ~(UINT64)(COMPRESSED_EXTENT_SIZE - 1);
+            start_data = off64 & ~(uint64_t)(COMPRESSED_EXTENT_SIZE - 1);
             end_data = min(sector_align(off64 + *length, COMPRESSED_EXTENT_SIZE),
                            sector_align(newlength, fcb->Vcb->superblock.sector_size));
             bufhead = 0;
         } else {
-            start_data = off64 & ~(UINT64)(fcb->Vcb->superblock.sector_size - 1);
+            start_data = off64 & ~(uint64_t)(fcb->Vcb->superblock.sector_size - 1);
             end_data = sector_align(off64 + *length, fcb->Vcb->superblock.sector_size);
             bufhead = 0;
         }
@@ -4425,11 +4427,11 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
             end_data = max(end_data, sector_align(fcb->inode_item.st_size, Vcb->superblock.sector_size));
 
         fcb->Header.ValidDataLength.QuadPart = newlength;
-        TRACE("fcb %p FileSize = %llx\n", fcb, fcb->Header.FileSize.QuadPart);
+        TRACE("fcb %p FileSize = %I64x\n", fcb, fcb->Header.FileSize.QuadPart);
 
         if (!make_inline && !compress && off64 == start_data && off64 + *length == end_data) {
             data = buf;
-            no_buf = TRUE;
+            no_buf = true;
         } else {
             data = ExAllocatePoolWithTag(PagedPool, (ULONG)(end_data - start_data + bufhead), ALLOC_TAG);
             if (!data) {
@@ -4440,8 +4442,8 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
 
             RtlZeroMemory(data + bufhead, (ULONG)(end_data - start_data));
 
-            TRACE("start_data = %llx\n", start_data);
-            TRACE("end_data = %llx\n", end_data);
+            TRACE("start_data = %I64x\n", start_data);
+            TRACE("end_data = %I64x\n", end_data);
 
             if (off64 > start_data || off64 + *length < end_data) {
                 if (changed_length) {
@@ -4478,7 +4480,7 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
             ed2->encoding = BTRFS_ENCODING_NONE;
             ed2->type = EXTENT_TYPE_INLINE;
 
-            Status = add_extent_to_fcb(fcb, 0, ed2, (UINT16)(offsetof(EXTENT_DATA, data[0]) + newlength), FALSE, NULL, rollback);
+            Status = add_extent_to_fcb(fcb, 0, ed2, (uint16_t)(offsetof(EXTENT_DATA, data[0]) + newlength), false, NULL, rollback);
             if (!NT_SUCCESS(Status)) {
                 ERR("add_extent_to_fcb returned %08x\n", Status);
                 ExFreePool(data);
@@ -4494,11 +4496,9 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
                 ExFreePool(data);
                 goto end;
             }
-
-            ExFreePool(data);
         } else {
             if (write_irp && Irp->MdlAddress && no_buf) {
-               BOOL locked = Irp->MdlAddress->MdlFlags & (MDL_PAGES_LOCKED | MDL_PARTIAL);
+                bool locked = Irp->MdlAddress->MdlFlags & (MDL_PAGES_LOCKED | MDL_PARTIAL);
 
                 if (!locked) {
                     Status = STATUS_SUCCESS;
@@ -4516,7 +4516,7 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
                 }
 
                 _SEH2_TRY {
-                    Status = do_write_file(fcb, start_data, end_data, data, Irp, TRUE, 0, rollback);
+                    Status = do_write_file(fcb, start_data, end_data, data, Irp, true, 0, rollback);
                 } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
                     Status = _SEH2_GetExceptionCode();
                 } _SEH2_END;
@@ -4525,7 +4525,7 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
                     MmUnlockPages(Irp->MdlAddress);
             } else {
                 _SEH2_TRY {
-                    Status = do_write_file(fcb, start_data, end_data, data, Irp, FALSE, 0, rollback);
+                    Status = do_write_file(fcb, start_data, end_data, data, Irp, false, 0, rollback);
                 } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
                     Status = _SEH2_GetExceptionCode();
                 } _SEH2_END;
@@ -4536,10 +4536,10 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
                 if (!no_buf) ExFreePool(data);
                 goto end;
             }
-
-            if (!no_buf)
-                ExFreePool(data);
         }
+
+        if (!no_buf)
+            ExFreePool(data);
     }
 
     KeQuerySystemTime(&time);
@@ -4565,14 +4565,14 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
 
         if (!fcb->ads) {
             if (changed_length) {
-                TRACE("setting st_size to %llx\n", newlength);
+                TRACE("setting st_size to %I64x\n", newlength);
                 origii->st_size = newlength;
                 filter |= FILE_NOTIFY_CHANGE_SIZE;
             }
 
-            fcb->inode_item_changed = TRUE;
+            fcb->inode_item_changed = true;
         } else {
-            fileref->parent->fcb->inode_item_changed = TRUE;
+            fileref->parent->fcb->inode_item_changed = true;
 
             if (changed_length)
                 filter |= FILE_NOTIFY_CHANGE_STREAM_SIZE;
@@ -4614,15 +4614,15 @@ NTSTATUS write_file2(device_extension* Vcb, PIRP Irp, LARGE_INTEGER offset, void
 
 end:
     if (NT_SUCCESS(Status) && FileObject->Flags & FO_SYNCHRONOUS_IO && !paging_io) {
-        TRACE("CurrentByteOffset was: %llx\n", FileObject->CurrentByteOffset.QuadPart);
+        TRACE("CurrentByteOffset was: %I64x\n", FileObject->CurrentByteOffset.QuadPart);
         FileObject->CurrentByteOffset.QuadPart = offset.QuadPart + (NT_SUCCESS(Status) ? *length : 0);
-        TRACE("CurrentByteOffset now: %llx\n", FileObject->CurrentByteOffset.QuadPart);
+        TRACE("CurrentByteOffset now: %I64x\n", FileObject->CurrentByteOffset.QuadPart);
     }
 
-    if (fcb_lock)
+    if (acquired_fcb_lock)
         ExReleaseResourceLite(fcb->Header.Resource);
 
-    if (tree_lock)
+    if (acquired_tree_lock)
         ExReleaseResourceLite(&Vcb->tree_lock);
 
     if (paging_lock)
@@ -4631,7 +4631,7 @@ end:
     return Status;
 }
 
-NTSTATUS write_file(device_extension* Vcb, PIRP Irp, BOOLEAN wait, BOOLEAN deferred_write) {
+NTSTATUS write_file(device_extension* Vcb, PIRP Irp, bool wait, bool deferred_write) {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     void* buf;
     NTSTATUS Status;
@@ -4646,7 +4646,7 @@ NTSTATUS write_file(device_extension* Vcb, PIRP Irp, BOOLEAN wait, BOOLEAN defer
 
     Irp->IoStatus.Information = 0;
 
-    TRACE("offset = %llx\n", offset.QuadPart);
+    TRACE("offset = %I64x\n", offset.QuadPart);
     TRACE("length = %x\n", IrpSp->Parameters.Write.Length);
 
     if (!Irp->AssociatedIrp.SystemBuffer) {
@@ -4669,7 +4669,7 @@ NTSTATUS write_file(device_extension* Vcb, PIRP Irp, BOOLEAN wait, BOOLEAN defer
     }
 
     Status = write_file2(Vcb, Irp, offset, buf, &IrpSp->Parameters.Write.Length, Irp->Flags & IRP_PAGING_IO, Irp->Flags & IRP_NOCACHE,
-                         wait, deferred_write, TRUE, &rollback);
+                         wait, deferred_write, true, &rollback);
 
     if (Status == STATUS_PENDING)
         goto exit;
@@ -4707,15 +4707,15 @@ exit:
 
 _Dispatch_type_(IRP_MJ_WRITE)
 _Function_class_(DRIVER_DISPATCH)
-NTSTATUS NTAPI drv_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
+NTSTATUS __stdcall drv_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
     NTSTATUS Status;
-    BOOL top_level;
+    bool top_level;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     device_extension* Vcb = DeviceObject->DeviceExtension;
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     fcb* fcb = FileObject ? FileObject->FsContext : NULL;
     ccb* ccb = FileObject ? FileObject->FsContext2 : NULL;
-    BOOLEAN wait = FileObject ? IoIsOperationSynchronous(Irp) : TRUE;
+    bool wait = FileObject ? IoIsOperationSynchronous(Irp) : true;
 
     FsRtlEnterFileSystem();
 
@@ -4782,9 +4782,9 @@ NTSTATUS NTAPI drv_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
             // Don't offload jobs when doing paging IO - otherwise this can lead to
             // deadlocks in CcCopyWrite.
             if (Irp->Flags & IRP_PAGING_IO)
-                wait = TRUE;
+                wait = true;
 
-            Status = write_file(Vcb, Irp, wait, FALSE);
+            Status = write_file(Vcb, Irp, wait, false);
         }
     } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
         Status = _SEH2_GetExceptionCode();
@@ -4801,7 +4801,7 @@ end:
         IoMarkIrpPending(Irp);
 
         if (!add_thread_job(Vcb, Irp))
-            do_write_job(Vcb, Irp);
+            Status = do_write_job(Vcb, Irp);
     }
 
 exit:
diff --git a/drivers/filesystems/btrfs/zstd/fse_compress.c b/drivers/filesystems/btrfs/zstd/fse_compress.c
index e078eec1cbf..c84f1d87ec9 100644
--- a/drivers/filesystems/btrfs/zstd/fse_compress.c
+++ b/drivers/filesystems/btrfs/zstd/fse_compress.c
@@ -194,8 +194,17 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
 
 size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
 {
-    FSE_FUNCTION_TYPE tableSymbol[FSE_MAX_TABLESIZE];   /* memset() is not necessary, even if static analyzer complain about it */
-    return FSE_buildCTable_wksp(ct, normalizedCounter, maxSymbolValue, tableLog, tableSymbol, sizeof(tableSymbol));
+    FSE_FUNCTION_TYPE* tableSymbol = ExAllocatePoolWithTag(NonPagedPool, sizeof(FSE_FUNCTION_TYPE) * FSE_MAX_TABLESIZE, FSEC_ALLOC_TAG);
+    size_t ret;
+
+    if (!tableSymbol)
+        return 0;
+
+    ret = FSE_buildCTable_wksp(ct, normalizedCounter, maxSymbolValue, tableLog, tableSymbol, sizeof(FSE_FUNCTION_TYPE) * FSE_MAX_TABLESIZE);
+
+    ExFreePool(tableSymbol);
+
+    return ret;
 }
 
 
@@ -709,10 +718,24 @@ typedef struct {
 
 size_t FSE_compress2 (void* dst, size_t dstCapacity, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog)
 {
-    fseWkspMax_t scratchBuffer;
-    DEBUG_STATIC_ASSERT(sizeof(scratchBuffer) >= FSE_WKSP_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE));   /* compilation failures here means scratchBuffer is not large enough */
-    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
-    return FSE_compress_wksp(dst, dstCapacity, src, srcSize, maxSymbolValue, tableLog, &scratchBuffer, sizeof(scratchBuffer));
+    fseWkspMax_t* scratchBuffer;
+    size_t ret;
+
+    DEBUG_STATIC_ASSERT(sizeof(fseWkspMax_t) >= FSE_WKSP_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE));   /* compilation failures here means scratchBuffer is not large enough */
+
+    if (tableLog > FSE_MAX_TABLELOG)
+        return ERROR(tableLog_tooLarge);
+
+    scratchBuffer = ExAllocatePoolWithTag(NonPagedPool, sizeof(fseWkspMax_t), FSEC_ALLOC_TAG);
+
+    if (!scratchBuffer)
+        return 0;
+
+    ret = FSE_compress_wksp(dst, dstCapacity, src, srcSize, maxSymbolValue, tableLog, scratchBuffer, sizeof(fseWkspMax_t));
+
+    ExFreePool(scratchBuffer);
+
+    return ret;
 }
 
 size_t FSE_compress (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
diff --git a/drivers/filesystems/btrfs/zstd/hist.c b/drivers/filesystems/btrfs/zstd/hist.c
index 16524756b8d..714a27e8d07 100644
--- a/drivers/filesystems/btrfs/zstd/hist.c
+++ b/drivers/filesystems/btrfs/zstd/hist.c
@@ -38,7 +38,10 @@
 #include "debug.h"           /* assert, DEBUGLOG */
 #include "error_private.h"   /* ERROR */
 #include "hist.h"
+#include <ntifs.h>
+#include <ntddk.h>
 
+#define HIST_ALLOC_TAG 0x54534948 // "HIST"
 
 /* --- Error management --- */
 unsigned HIST_isError(size_t code) { return ERR_isError(code); }
@@ -171,8 +174,17 @@ size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
 size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
                      const void* source, size_t sourceSize)
 {
-    unsigned tmpCounters[HIST_WKSP_SIZE_U32];
-    return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters);
+    unsigned* tmpCounters = ExAllocatePoolWithTag(NonPagedPool, sizeof(unsigned) * HIST_WKSP_SIZE_U32, HIST_ALLOC_TAG);
+    size_t ret;
+
+    if (!tmpCounters)
+        return 0;
+
+    ret = HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters);
+
+    ExFreePool(tmpCounters);
+
+    return ret;
 }
 
 /* HIST_count_wksp() :
diff --git a/drivers/filesystems/btrfs/zstd/huf.h b/drivers/filesystems/btrfs/zstd/huf.h
index de946411106..dc84f7ab114 100644
--- a/drivers/filesystems/btrfs/zstd/huf.h
+++ b/drivers/filesystems/btrfs/zstd/huf.h
@@ -163,10 +163,6 @@ HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity,
 /* static allocation of HUF's DTable */
 typedef U32 HUF_DTable;
 #define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog)))
-#define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \
-        HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) }
-#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
-        HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }
 
 
 /* ****************************************
diff --git a/drivers/filesystems/btrfs/zstd/huf_compress.c b/drivers/filesystems/btrfs/zstd/huf_compress.c
index 4c40572f228..1510fda2db9 100644
--- a/drivers/filesystems/btrfs/zstd/huf_compress.c
+++ b/drivers/filesystems/btrfs/zstd/huf_compress.c
@@ -53,6 +53,10 @@
 #define HUF_STATIC_LINKING_ONLY
 #include "huf.h"
 #include "error_private.h"
+#include <ntifs.h>
+#include <ntddk.h>
+
+#define HUFC_ALLOC_TAG 0x63465548 // "HUFc"
 
 
 /* **************************************************************
@@ -423,8 +427,17 @@ size_t HUF_buildCTable_wksp (HUF_CElt* tree, const U32* count, U32 maxSymbolValu
  */
 size_t HUF_buildCTable (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits)
 {
-    huffNodeTable nodeTable;
-    return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(nodeTable));
+    huffNodeTable* nodeTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(huffNodeTable), HUFC_ALLOC_TAG);
+    size_t ret;
+
+    if (!nodeTable)
+        return 0;
+
+    ret = HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(huffNodeTable));
+
+    ExFreePool(nodeTable);
+
+    return ret;
 }
 
 static size_t HUF_estimateCompressedSize(HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
@@ -749,8 +762,17 @@ size_t HUF_compress1X (void* dst, size_t dstSize,
                  const void* src, size_t srcSize,
                  unsigned maxSymbolValue, unsigned huffLog)
 {
-    unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
-    return HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
+    unsigned* workSpace = ExAllocatePoolWithTag(NonPagedPool, sizeof(unsigned) * HUF_WORKSPACE_SIZE_U32, HUFC_ALLOC_TAG);
+    size_t ret;
+
+    if (!workSpace)
+        return 0;
+
+    ret = HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(unsigned) * HUF_WORKSPACE_SIZE_U32);
+
+    ExFreePool(workSpace);
+
+    return ret;
 }
 
 /* HUF_compress4X_repeat():
@@ -786,8 +808,17 @@ size_t HUF_compress2 (void* dst, size_t dstSize,
                 const void* src, size_t srcSize,
                 unsigned maxSymbolValue, unsigned huffLog)
 {
-    unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
-    return HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
+    unsigned* workSpace = ExAllocatePoolWithTag(NonPagedPool, sizeof(unsigned) * HUF_WORKSPACE_SIZE_U32, HUFC_ALLOC_TAG);
+    size_t ret;
+
+    if (!workSpace)
+        return 0;
+
+    ret = HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(unsigned) * HUF_WORKSPACE_SIZE_U32);
+
+    ExFreePool(workSpace);
+
+    return ret;
 }
 
 size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize)
diff --git a/drivers/filesystems/btrfs/zstd/huf_decompress.c b/drivers/filesystems/btrfs/zstd/huf_decompress.c
index 83ecaff01e8..51bb417f179 100644
--- a/drivers/filesystems/btrfs/zstd/huf_decompress.c
+++ b/drivers/filesystems/btrfs/zstd/huf_decompress.c
@@ -42,6 +42,10 @@
 #define HUF_STATIC_LINKING_ONLY
 #include "huf.h"
 #include "error_private.h"
+#include <ntifs.h>
+#include <ntddk.h>
+
+#define HUFD_ALLOC_TAG 0x64465548 // "HUFd"
 
 
 /* **************************************************************
@@ -388,8 +392,21 @@ size_t HUF_decompress1X1_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize,
 
 size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
 {
-    HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
-    return HUF_decompress1X1_DCtx (DTable, dst, dstSize, cSrc, cSrcSize);
+    HUF_DTable* DTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX-1), HUFD_ALLOC_TAG);
+    size_t ret;
+
+    if (!DTable)
+        return 0;
+
+    RtlZeroMemory(DTable, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX-1));
+
+    DTable[0] = (U32)(HUF_TABLELOG_MAX-1) * 0x01000001;
+
+    ret = HUF_decompress1X1_DCtx (DTable, dst, dstSize, cSrc, cSrcSize);
+
+    ExFreePool(DTable);
+
+    return ret;
 }
 
 size_t HUF_decompress4X1_usingDTable(
@@ -433,8 +450,21 @@ size_t HUF_decompress4X1_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, cons
 }
 size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
 {
-    HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
-    return HUF_decompress4X1_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+    HUF_DTable* DTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX-1), HUFD_ALLOC_TAG);
+    size_t ret;
+
+    if (!DTable)
+        return 0;
+
+    RtlZeroMemory(DTable, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX-1));
+
+    DTable[0] = (U32)(HUF_TABLELOG_MAX-1) * 0x01000001;
+
+    ret = HUF_decompress4X1_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+
+    ExFreePool(DTable);
+
+    return ret;
 }
 
 
@@ -860,8 +890,21 @@ size_t HUF_decompress1X2_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize,
 
 size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
 {
-    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
-    return HUF_decompress1X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+    HUF_DTable* DTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX), HUFD_ALLOC_TAG);
+    size_t ret;
+
+    if (!DTable)
+        return 0;
+
+    RtlZeroMemory(DTable, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX));
+
+    DTable[0] = (U32)(HUF_TABLELOG_MAX) * 0x01000001;
+
+    ret = HUF_decompress1X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+
+    ExFreePool(DTable);
+
+    return ret;
 }
 
 size_t HUF_decompress4X2_usingDTable(
@@ -907,8 +950,21 @@ size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize,
 
 size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
 {
-    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
-    return HUF_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+    HUF_DTable* DTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX), HUFD_ALLOC_TAG);
+    size_t ret;
+
+    if (!DTable)
+        return 0;
+
+    RtlZeroMemory(DTable, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX));
+
+    DTable[0] = (U32)(HUF_TABLELOG_MAX) * 0x01000001;
+
+    ret = HUF_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
+
+    ExFreePool(DTable);
+
+    return ret;
 }
 
 
diff --git a/media/doc/README.FSD b/media/doc/README.FSD
index d86c5bd5861..c9e05141216 100644
--- a/media/doc/README.FSD
+++ b/media/doc/README.FSD
@@ -3,7 +3,7 @@
 
 The following FSD are shared with: https://github.com/maharmstone/btrfs.
 
-reactos/drivers/filesystems/btrfs           # Synced to 1.3
+reactos/drivers/filesystems/btrfs           # Synced to 1.4
 reactos/dll/shellext/shellbtrfs             # Synced to 1.1
 reactos/sdk/lib/fslib/btrfslib              # Synced to 1.3