[BTRFS] Upgrade to 1.4
authorPierre Schweitzer <pierre@reactos.org>
Sun, 1 Sep 2019 12:53:20 +0000 (14:53 +0200)
committerPierre Schweitzer <pierre@reactos.org>
Mon, 2 Sep 2019 06:19:48 +0000 (08:19 +0200)
CORE-16354

43 files changed:
dll/shellext/shellbtrfs/contextmenu.cpp
dll/shellext/shellbtrfs/propsheet.cpp
drivers/filesystems/btrfs/CMakeLists.txt
drivers/filesystems/btrfs/balance.c
drivers/filesystems/btrfs/boot.c [new file with mode: 0755]
drivers/filesystems/btrfs/btrfs.c
drivers/filesystems/btrfs/btrfs.h
drivers/filesystems/btrfs/btrfs.rc
drivers/filesystems/btrfs/btrfs_drv.h
drivers/filesystems/btrfs/btrfsioctl.h
drivers/filesystems/btrfs/cache.c
drivers/filesystems/btrfs/calcthread.c
drivers/filesystems/btrfs/compress.c
drivers/filesystems/btrfs/crc32c.c
drivers/filesystems/btrfs/create.c
drivers/filesystems/btrfs/devctrl.c
drivers/filesystems/btrfs/dirctrl.c
drivers/filesystems/btrfs/extent-tree.c
drivers/filesystems/btrfs/fastio.c
drivers/filesystems/btrfs/fileinfo.c
drivers/filesystems/btrfs/flushthread.c
drivers/filesystems/btrfs/free-space.c
drivers/filesystems/btrfs/fsctl.c
drivers/filesystems/btrfs/fsrtl.c [new file with mode: 0644]
drivers/filesystems/btrfs/galois.c
drivers/filesystems/btrfs/pnp.c
drivers/filesystems/btrfs/read.c
drivers/filesystems/btrfs/registry.c
drivers/filesystems/btrfs/reparse.c
drivers/filesystems/btrfs/scrub.c
drivers/filesystems/btrfs/search.c
drivers/filesystems/btrfs/security.c
drivers/filesystems/btrfs/send.c
drivers/filesystems/btrfs/treefuncs.c
drivers/filesystems/btrfs/volume.c
drivers/filesystems/btrfs/worker-thread.c
drivers/filesystems/btrfs/write.c
drivers/filesystems/btrfs/zstd/fse_compress.c
drivers/filesystems/btrfs/zstd/hist.c
drivers/filesystems/btrfs/zstd/huf.h
drivers/filesystems/btrfs/zstd/huf_compress.c
drivers/filesystems/btrfs/zstd/huf_decompress.c
media/doc/README.FSD

index 6e51a0f..8fcdf2c 100644 (file)
@@ -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);
 
index 4c3478f..153d648 100644 (file)
@@ -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);
index cd4c76e..14e7842 100644 (file)
@@ -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)
index 83546f0..b779412 100644 (file)
 #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 (executable)
index 0000000..f73fc38
--- /dev/null
@@ -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);
+}
index c480d9f..61f3dc6 100644 (file)
 #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;
 }
index d0d2c93..f55ef82 100644 (file)
@@ -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
index da8380e..c899d59 100644 (file)
@@ -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"
index 9439bd4..d839736 100644 (file)
@@ -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
 
 #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;