https://git.reactos.org/?p=reactos.git;a=commitdiff;h=eb7fbc253fcb0d2bc53441...
commit eb7fbc253fcb0d2bc534412b4965bf2f736eac05 Author: Pierre Schweitzer pierre@reactos.org AuthorDate: Sun Dec 16 12:03:16 2018 +0100 Commit: Pierre Schweitzer pierre@reactos.org CommitDate: Sun Dec 16 12:06:46 2018 +0100
[BTRFS] Upgrade to 1.1
CORE-15452 --- drivers/filesystems/btrfs/CMakeLists.txt | 16 + drivers/filesystems/btrfs/balance.c | 50 +- drivers/filesystems/btrfs/btrfs.c | 188 +- drivers/filesystems/btrfs/btrfs.h | 3 +- drivers/filesystems/btrfs/btrfs.rc | 8 +- drivers/filesystems/btrfs/btrfs_drv.h | 47 +- drivers/filesystems/btrfs/btrfsioctl.h | 20 + drivers/filesystems/btrfs/compress.c | 268 +- drivers/filesystems/btrfs/create.c | 420 +- drivers/filesystems/btrfs/dirctrl.c | 63 +- drivers/filesystems/btrfs/fastio.c | 21 +- drivers/filesystems/btrfs/fileinfo.c | 214 +- drivers/filesystems/btrfs/flushthread.c | 175 +- drivers/filesystems/btrfs/free-space.c | 26 +- drivers/filesystems/btrfs/fsctl.c | 112 +- drivers/filesystems/btrfs/pnp.c | 18 +- drivers/filesystems/btrfs/read.c | 49 +- drivers/filesystems/btrfs/registry.c | 51 +- drivers/filesystems/btrfs/reparse.c | 190 +- drivers/filesystems/btrfs/scrub.c | 4 +- drivers/filesystems/btrfs/search.c | 10 +- drivers/filesystems/btrfs/send.c | 50 +- drivers/filesystems/btrfs/treefuncs.c | 12 +- drivers/filesystems/btrfs/volume.c | 12 +- drivers/filesystems/btrfs/write.c | 67 +- drivers/filesystems/btrfs/zstd/bitstream.h | 455 +++ drivers/filesystems/btrfs/zstd/compiler.h | 133 + drivers/filesystems/btrfs/zstd/cpu.h | 215 ++ drivers/filesystems/btrfs/zstd/debug.h | 123 + drivers/filesystems/btrfs/zstd/entropy_common.c | 236 ++ drivers/filesystems/btrfs/zstd/error_private.c | 48 + drivers/filesystems/btrfs/zstd/error_private.h | 76 + drivers/filesystems/btrfs/zstd/fse.h | 708 ++++ drivers/filesystems/btrfs/zstd/fse_compress.c | 724 ++++ drivers/filesystems/btrfs/zstd/fse_decompress.c | 313 ++ drivers/filesystems/btrfs/zstd/hist.c | 195 + drivers/filesystems/btrfs/zstd/hist.h | 92 + drivers/filesystems/btrfs/zstd/huf.h | 334 ++ drivers/filesystems/btrfs/zstd/huf_compress.c | 796 ++++ drivers/filesystems/btrfs/zstd/huf_decompress.c | 1096 ++++++ drivers/filesystems/btrfs/zstd/mem.h | 376 ++ drivers/filesystems/btrfs/zstd/xxhash.c | 887 +++++ drivers/filesystems/btrfs/zstd/xxhash.h | 305 ++ drivers/filesystems/btrfs/zstd/zstd.h | 1526 ++++++++ drivers/filesystems/btrfs/zstd/zstd_common.c | 72 + drivers/filesystems/btrfs/zstd/zstd_compress.c | 4040 ++++++++++++++++++++ .../btrfs/zstd/zstd_compress_internal.h | 798 ++++ drivers/filesystems/btrfs/zstd/zstd_decompress.c | 3108 +++++++++++++++ drivers/filesystems/btrfs/zstd/zstd_double_fast.c | 499 +++ drivers/filesystems/btrfs/zstd/zstd_double_fast.h | 38 + drivers/filesystems/btrfs/zstd/zstd_errors.h | 92 + drivers/filesystems/btrfs/zstd/zstd_fast.c | 391 ++ drivers/filesystems/btrfs/zstd/zstd_fast.h | 37 + drivers/filesystems/btrfs/zstd/zstd_internal.h | 257 ++ drivers/filesystems/btrfs/zstd/zstd_lazy.c | 1099 ++++++ drivers/filesystems/btrfs/zstd/zstd_lazy.h | 67 + drivers/filesystems/btrfs/zstd/zstd_ldm.c | 646 ++++ drivers/filesystems/btrfs/zstd/zstd_ldm.h | 109 + drivers/filesystems/btrfs/zstd/zstd_opt.c | 1132 ++++++ drivers/filesystems/btrfs/zstd/zstd_opt.h | 48 + media/doc/README.FSD | 2 +- 61 files changed, 22588 insertions(+), 579 deletions(-)
diff --git a/drivers/filesystems/btrfs/CMakeLists.txt b/drivers/filesystems/btrfs/CMakeLists.txt index 65e61d255a..59fe9565e6 100644 --- a/drivers/filesystems/btrfs/CMakeLists.txt +++ b/drivers/filesystems/btrfs/CMakeLists.txt @@ -33,6 +33,22 @@ list(APPEND SOURCE volume.c worker-thread.c write.c + zstd/entropy_common.c + zstd/fse_compress.c + zstd/hist.c + zstd/huf_decompress.c + zstd/zstd_common.c + zstd/zstd_decompress.c + zstd/zstd_fast.c + zstd/zstd_ldm.c + zstd/error_private.c + zstd/fse_decompress.c + zstd/huf_compress.c + zstd/xxhash.c + zstd/zstd_compress.c + zstd/zstd_double_fast.c + zstd/zstd_lazy.c + zstd/zstd_opt.c btrfs_drv.h)
add_library(btrfs SHARED ${SOURCE} btrfs.rc) diff --git a/drivers/filesystems/btrfs/balance.c b/drivers/filesystems/btrfs/balance.c index 3e36489c31..fe641f4f41 100644 --- a/drivers/filesystems/btrfs/balance.c +++ b/drivers/filesystems/btrfs/balance.c @@ -107,13 +107,13 @@ static NTSTATUS add_metadata_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_l c = get_chunk_from_address(Vcb, tp->item->key.obj_id);
if (c) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
c->used -= Vcb->superblock.node_size;
space_list_add(c, tp->item->key.obj_id, Vcb->superblock.node_size, rollback);
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); }
ei = (EXTENT_ITEM*)tp->item->data; @@ -747,7 +747,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree flags = Vcb->metadata_flags;
if (newchunk) { - ExAcquireResourceExclusiveLite(&newchunk->lock, TRUE); + acquire_chunk_lock(newchunk, Vcb);
if (newchunk->chunk_item->type == flags && find_metadata_address_in_chunk(Vcb, newchunk, &mr->new_address)) { newchunk->used += Vcb->superblock.node_size; @@ -755,7 +755,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree done = TRUE; }
- ExReleaseResourceLite(&newchunk->lock); + release_chunk_lock(newchunk, Vcb); }
if (!done) { @@ -766,20 +766,20 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree chunk* c2 = CONTAINING_RECORD(le2, chunk, list_entry);
if (!c2->readonly && !c2->reloc && c2 != newchunk && c2->chunk_item->type == flags) { - ExAcquireResourceExclusiveLite(&c2->lock, TRUE); + acquire_chunk_lock(c2, Vcb);
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); - ExReleaseResourceLite(&c2->lock); + release_chunk_lock(c2, Vcb); newchunk = c2; done = TRUE; break; } }
- ExReleaseResourceLite(&c2->lock); + release_chunk_lock(c2, Vcb); }
le2 = le2->Flink; @@ -795,12 +795,12 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree goto end; }
- ExAcquireResourceExclusiveLite(&newchunk->lock, TRUE); + acquire_chunk_lock(newchunk, Vcb);
newchunk->balance_num = Vcb->balance.balance_num;
if (!find_metadata_address_in_chunk(Vcb, newchunk, &mr->new_address)) { - ExReleaseResourceLite(&newchunk->lock); + release_chunk_lock(newchunk, Vcb); ExReleaseResourceLite(&Vcb->chunk_lock); ERR("could not find address in new chunk\n"); Status = STATUS_DISK_FULL; @@ -810,7 +810,7 @@ static NTSTATUS write_metadata_items(_Requires_exclusive_lock_held_(_Curr_->tree space_list_subtract(newchunk, FALSE, mr->new_address, Vcb->superblock.node_size, rollback); }
- ExReleaseResourceLite(&newchunk->lock); + release_chunk_lock(newchunk, Vcb); }
ExReleaseResourceLite(&Vcb->chunk_lock); @@ -1340,13 +1340,13 @@ static NTSTATUS add_data_reloc(_Requires_exclusive_lock_held_(_Curr_->tree_lock) c = get_chunk_from_address(Vcb, tp->item->key.obj_id);
if (c) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
c->used -= tp->item->key.offset;
space_list_add(c, tp->item->key.obj_id, tp->item->key.offset, rollback);
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); }
ei = (EXTENT_ITEM*)tp->item->data; @@ -1756,7 +1756,7 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change ULONG runlength, index, lastoff;
if (newchunk) { - ExAcquireResourceExclusiveLite(&newchunk->lock, TRUE); + acquire_chunk_lock(newchunk, Vcb);
if (find_data_address_in_chunk(Vcb, newchunk, dr->size, &dr->new_address)) { newchunk->used += dr->size; @@ -1764,7 +1764,7 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change done = TRUE; }
- ExReleaseResourceLite(&newchunk->lock); + release_chunk_lock(newchunk, Vcb); }
if (!done) { @@ -1775,20 +1775,20 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change chunk* c2 = CONTAINING_RECORD(le2, chunk, list_entry);
if (!c2->readonly && !c2->reloc && c2 != newchunk && c2->chunk_item->type == Vcb->data_flags) { - ExAcquireResourceExclusiveLite(&c2->lock, TRUE); + acquire_chunk_lock(c2, Vcb);
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); - ExReleaseResourceLite(&c2->lock); + release_chunk_lock(c2, Vcb); newchunk = c2; done = TRUE; break; } }
- ExReleaseResourceLite(&c2->lock); + release_chunk_lock(c2, Vcb); }
le2 = le2->Flink; @@ -1804,12 +1804,12 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change goto end; }
- ExAcquireResourceExclusiveLite(&newchunk->lock, TRUE); + acquire_chunk_lock(newchunk, Vcb);
newchunk->balance_num = Vcb->balance.balance_num;
if (!find_data_address_in_chunk(Vcb, newchunk, dr->size, &dr->new_address)) { - ExReleaseResourceLite(&newchunk->lock); + release_chunk_lock(newchunk, Vcb); ExReleaseResourceLite(&Vcb->chunk_lock); ERR("could not find address in new chunk\n"); Status = STATUS_DISK_FULL; @@ -1819,7 +1819,7 @@ static NTSTATUS balance_data_chunk(device_extension* Vcb, chunk* c, BOOL* change space_list_subtract(newchunk, FALSE, dr->new_address, dr->size, &rollback); }
- ExReleaseResourceLite(&newchunk->lock); + release_chunk_lock(newchunk, Vcb); }
ExReleaseResourceLite(&Vcb->chunk_lock); @@ -2957,6 +2957,8 @@ static NTSTATUS try_consolidation(device_extension* Vcb, UINT64 flags, chunk** n ERR("do_write returned %08x\n", Status); return Status; } + + free_trees(Vcb); }
ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, TRUE); @@ -3108,7 +3110,7 @@ void NTAPI balance_thread(void* context) { chunk* c = CONTAINING_RECORD(le, chunk, list_entry); UINT8 sort;
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if (c->chunk_item->type & BLOCK_FLAG_DATA) sort = BALANCE_OPTS_DATA; @@ -3118,7 +3120,7 @@ void NTAPI balance_thread(void* context) { sort = BALANCE_OPTS_SYSTEM; else { ERR("unexpected chunk type %llx\n", c->chunk_item->type); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); break; }
@@ -3142,13 +3144,13 @@ void NTAPI balance_thread(void* context) { if (!NT_SUCCESS(Status)) { ERR("load_cache_chunk returned %08x\n", Status); Vcb->balance.status = Status; - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); ExReleaseResourceLite(&Vcb->chunk_lock); goto end; } }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
le = le->Flink; } diff --git a/drivers/filesystems/btrfs/btrfs.c b/drivers/filesystems/btrfs/btrfs.c index bdc2988145..2582ee0b3f 100644 --- a/drivers/filesystems/btrfs/btrfs.c +++ b/drivers/filesystems/btrfs/btrfs.c @@ -48,11 +48,12 @@
#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) + BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF | BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA | BTRFS_INCOMPAT_FLAGS_NO_HOLES | \ + BTRFS_INCOMPAT_FLAGS_COMPRESS_ZSTD) #define COMPAT_RO_SUPPORTED (BTRFS_COMPAT_RO_FLAGS_FREE_SPACE_CACHE | BTRFS_COMPAT_RO_FLAGS_FREE_SPACE_CACHE_VALID)
-static WCHAR device_name[] = {'\','B','t','r','f','s',0}; -static WCHAR dosdevice_name[] = {'\','D','o','s','D','e','v','i','c','e','s','\','B','t','r','f','s',0}; +static const WCHAR device_name[] = {'\','B','t','r','f','s',0}; +static const WCHAR dosdevice_name[] = {'\','D','o','s','D','e','v','i','c','e','s','\','B','t','r','f','s',0};
DEFINE_GUID(BtrfsBusInterface, 0x4d414874, 0x6865, 0x6761, 0x6d, 0x65, 0x83, 0x69, 0x17, 0x9a, 0x7d, 0x1d);
@@ -70,6 +71,7 @@ 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; @@ -268,7 +270,7 @@ static void DriverUnload(_In_ PDRIVER_OBJECT DriverObject) { #endif UNICODE_STRING dosdevice_nameW;
- ERR("DriverUnload\n"); + TRACE("(%p)\n");
free_cache();
@@ -295,8 +297,8 @@ static void DriverUnload(_In_ PDRIVER_OBJECT DriverObject) { IoUnregisterPlugPlayNotificationEx(notification_entry); #endif
- dosdevice_nameW.Buffer = dosdevice_name; - dosdevice_nameW.Length = dosdevice_nameW.MaximumLength = (USHORT)wcslen(dosdevice_name) * sizeof(WCHAR); + dosdevice_nameW.Buffer = (WCHAR*)dosdevice_name; + dosdevice_nameW.Length = dosdevice_nameW.MaximumLength = sizeof(dosdevice_name) - sizeof(WCHAR);
IoDeleteSymbolicLink(&dosdevice_nameW); IoDeleteDevice(DriverObject->DeviceObject); @@ -621,22 +623,32 @@ static BOOL lie_about_fs_type() { PPEB peb; LIST_ENTRY* le; ULONG retlen; +#ifdef _AMD64_ + ULONG_PTR wow64info; +#endif
- static WCHAR mpr[] = L"MPR.DLL"; - static WCHAR cmd[] = L"CMD.EXE"; - static WCHAR fsutil[] = L"FSUTIL.EXE"; + static const WCHAR mpr[] = L"MPR.DLL"; + static const WCHAR cmd[] = L"CMD.EXE"; + static const WCHAR fsutil[] = L"FSUTIL.EXE"; UNICODE_STRING mprus, cmdus, fsutilus;
- mprus.Buffer = mpr; - mprus.Length = mprus.MaximumLength = (USHORT)(wcslen(mpr) * sizeof(WCHAR)); - cmdus.Buffer = cmd; - cmdus.Length = cmdus.MaximumLength = (USHORT)(wcslen(cmd) * sizeof(WCHAR)); - fsutilus.Buffer = fsutil; - fsutilus.Length = fsutilus.MaximumLength = (USHORT)(wcslen(fsutil) * sizeof(WCHAR)); + mprus.Buffer = (WCHAR*)mpr; + mprus.Length = mprus.MaximumLength = sizeof(mpr) - sizeof(WCHAR); + cmdus.Buffer = (WCHAR*)cmd; + cmdus.Length = cmdus.MaximumLength = sizeof(cmd) - sizeof(WCHAR); + fsutilus.Buffer = (WCHAR*)fsutil; + fsutilus.Length = fsutilus.MaximumLength = sizeof(fsutil) - sizeof(WCHAR);
if (!PsGetCurrentProcess()) return FALSE;
+#ifdef _AMD64_ + Status = ZwQueryInformationProcess(NtCurrentProcess(), ProcessWow64Information, &wow64info, sizeof(wow64info), NULL); + + if (NT_SUCCESS(Status) && wow64info != 0) + return TRUE; +#endif + Status = ZwQueryInformationProcess(NtCurrentProcess(), ProcessBasicInformation, &pbi, sizeof(pbi), &retlen);
if (!NT_SUCCESS(Status)) { @@ -750,13 +762,24 @@ static NTSTATUS drv_query_volume_information(_In_ PDEVICE_OBJECT DeviceObject, _ FILE_FS_ATTRIBUTE_INFORMATION* data = Irp->AssociatedIrp.SystemBuffer; BOOL overflow = FALSE; #ifndef __REACTOS__ - WCHAR* fs_name = (Irp->RequestorMode == UserMode && lie_about_fs_type()) ? L"NTFS" : L"Btrfs"; - ULONG fs_name_len = (ULONG)wcslen(fs_name) * sizeof(WCHAR); + static const WCHAR ntfs[] = L"NTFS"; +#endif + static const WCHAR btrfs[] = L"Btrfs"; + const WCHAR* fs_name; + ULONG fs_name_len, orig_fs_name_len; + +#ifndef __REACTOS__ + if (Irp->RequestorMode == UserMode && lie_about_fs_type()) { + fs_name = ntfs; + orig_fs_name_len = fs_name_len = sizeof(ntfs) - sizeof(WCHAR); + } else { + fs_name = btrfs; + orig_fs_name_len = fs_name_len = sizeof(btrfs) - sizeof(WCHAR); + } #else - WCHAR* fs_name = L"Btrfs"; - ULONG fs_name_len = 5 * sizeof(WCHAR); + fs_name = btrfs; + orig_fs_name_len = fs_name_len = sizeof(btrfs) - sizeof(WCHAR); #endif - ULONG orig_fs_name_len = fs_name_len;
TRACE("FileFsAttributeInformation\n");
@@ -1705,7 +1728,7 @@ static NTSTATUS close_file(_In_ PFILE_OBJECT FileObject, _In_ PIRP Irp) { CcUninitializeCacheMap(FileObject, NULL, NULL);
if (open_files == 0 && fcb->Vcb->removing) { - uninit(fcb->Vcb, FALSE); + uninit(fcb->Vcb); return STATUS_SUCCESS; }
@@ -1726,8 +1749,9 @@ static NTSTATUS close_file(_In_ PFILE_OBJECT FileObject, _In_ PIRP Irp) { return STATUS_SUCCESS; }
-void uninit(_In_ device_extension* Vcb, _In_ BOOL flush) { +void uninit(_In_ device_extension* Vcb) { UINT64 i; + KIRQL irql; NTSTATUS Status; LIST_ENTRY* le; LARGE_INTEGER time; @@ -1738,6 +1762,11 @@ void uninit(_In_ device_extension* Vcb, _In_ BOOL flush) { ExReleaseResourceLite(&Vcb->tree_lock); }
+ IoAcquireVpbSpinLock(&irql); + Vcb->Vpb->Flags &= ~VPB_MOUNTED; + Vcb->Vpb->Flags |= VPB_DIRECT_WRITES_ALLOWED; + IoReleaseVpbSpinLock(irql); + RemoveEntryList(&Vcb->list_entry);
if (Vcb->balance.thread) { @@ -1787,20 +1816,6 @@ void uninit(_In_ device_extension* Vcb, _In_ BOOL flush) { if (!NT_SUCCESS(Status) && Status != STATUS_TOO_LATE) WARN("registry_mark_volume_unmounted returned %08x\n", Status);
- if (flush) { - ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE); - - if (Vcb->need_write && !Vcb->readonly) { - Status = do_write(Vcb, NULL); - if (!NT_SUCCESS(Status)) - ERR("do_write returned %08x\n", Status); - } - - free_trees(Vcb); - - ExReleaseResourceLite(&Vcb->tree_lock); - } - for (i = 0; i < Vcb->calcthreads.num_threads; i++) { Vcb->calcthreads.threads[i].quit = TRUE; } @@ -3599,7 +3614,7 @@ _Ret_maybenull_ static root* find_default_subvol(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_opt_ PIRP Irp) { LIST_ENTRY* le;
- static char fn[] = "default"; + static const char fn[] = "default"; static UINT32 crc32 = 0x8dbfc2d2;
if (Vcb->options.subvol_id != 0) { @@ -3764,8 +3779,8 @@ static BOOL is_btrfs_volume(_In_ PDEVICE_OBJECT DeviceObject) { return FALSE; }
- if (mdn2->NameLength > wcslen(BTRFS_VOLUME_PREFIX) * sizeof(WCHAR) && - RtlCompareMemory(mdn2->Name, BTRFS_VOLUME_PREFIX, wcslen(BTRFS_VOLUME_PREFIX) * sizeof(WCHAR)) == wcslen(BTRFS_VOLUME_PREFIX) * sizeof(WCHAR)) { + 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; } @@ -4773,7 +4788,7 @@ static NTSTATUS verify_volume(_In_ PDEVICE_OBJECT devobj) { ExReleaseResourceLite(&Vcb->tree_lock);
if (remove) { - uninit(Vcb, FALSE); + uninit(Vcb); return Status; }
@@ -4924,9 +4939,7 @@ static NTSTATUS drv_shutdown(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) { NTSTATUS Status; BOOL top_level; device_extension* Vcb = DeviceObject->DeviceExtension; -#ifdef __REACTOS__ - LIST_ENTRY *Vcble, *le; -#endif + LIST_ENTRY* le;
FsRtlEnterFileSystem();
@@ -4944,79 +4957,34 @@ static NTSTATUS drv_shutdown(_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp) { shutting_down = TRUE; KeSetEvent(&mountmgr_thread_event, 0, FALSE);
-#ifndef __REACTOS__ - while (!IsListEmpty(&VcbList)) { - Vcb = CONTAINING_RECORD(VcbList.Flink, device_extension, list_entry); + le = VcbList.Flink; + while (le != &VcbList) { + BOOL open_files; + LIST_ENTRY* le2 = le->Flink;
- TRACE("shutting down Vcb %p\n", Vcb); - - uninit(Vcb, TRUE); - } -#else - Vcble = VcbList.Flink; - while (Vcble != &VcbList) { - Vcb = CONTAINING_RECORD(Vcble, device_extension, list_entry); + Vcb = CONTAINING_RECORD(le, device_extension, list_entry);
TRACE("shutting down Vcb %p\n", Vcb);
- 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); - } - - 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); - } - - if (Vcb->running_sends != 0) { - BOOL send_cancelled = FALSE; - - 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->ccb = NULL; - KeSetEvent(&send->cleared_event, 0, FALSE); - } - - le = le->Flink; - } - - ExReleaseResourceLite(&Vcb->send_load_lock); - - if (send_cancelled) { - while (Vcb->running_sends != 0) { - ExAcquireResourceExclusiveLite(&Vcb->send_load_lock, TRUE); - ExReleaseResourceLite(&Vcb->send_load_lock); - } - } - } - ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE); + Vcb->removing = TRUE; + open_files = Vcb->open_files > 0;
if (Vcb->need_write && !Vcb->readonly) { Status = do_write(Vcb, Irp); - if (!NT_SUCCESS(Status)) ERR("do_write returned %08x\n", Status); }
- Vcb->removing = TRUE; + free_trees(Vcb);
ExReleaseResourceLite(&Vcb->tree_lock); - Vcble = Vcble->Flink; + + if (!open_files) + uninit(Vcb); + + le = le2; } -#endif
#ifdef _DEBUG if (comfo) { @@ -5333,7 +5301,7 @@ static void init_logging() { FILE_STANDARD_INFORMATION fsi; FILE_POSITION_INFORMATION fpi;
- static char delim[] = "\n---\n"; + static const char delim[] = "\n---\n";
// move to end of file
@@ -5353,7 +5321,7 @@ static void init_logging() { goto end; }
- Status = ZwWriteFile(log_handle, NULL, NULL, NULL, &iosb, delim, (ULONG)strlen(delim), NULL, NULL); + Status = ZwWriteFile(log_handle, NULL, NULL, NULL, &iosb, (void*)delim, sizeof(delim) - 1, NULL, NULL);
if (!NT_SUCCESS(Status)) { ERR("ZwWriteFile returned %08x\n", Status); @@ -5453,7 +5421,7 @@ NTSTATUS AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObj
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
- volname.Length = volname.MaximumLength = (USHORT)((wcslen(BTRFS_VOLUME_PREFIX) + 36 + 1) * sizeof(WCHAR)); + 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?
if (!volname.Buffer) { @@ -5462,9 +5430,9 @@ NTSTATUS AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObj goto end2; }
- RtlCopyMemory(volname.Buffer, BTRFS_VOLUME_PREFIX, wcslen(BTRFS_VOLUME_PREFIX) * sizeof(WCHAR)); + RtlCopyMemory(volname.Buffer, BTRFS_VOLUME_PREFIX, sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR));
- j = (ULONG)wcslen(BTRFS_VOLUME_PREFIX); + j = (sizeof(BTRFS_VOLUME_PREFIX) / sizeof(WCHAR)) - 1; for (i = 0; i < 16; i++) { volname.Buffer[j] = hex_digit(pdode->uuid.uuid[i] >> 4); j++; volname.Buffer[j] = hex_digit(pdode->uuid.uuid[i] & 0xf); j++; @@ -5670,10 +5638,10 @@ NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING Regi
init_fast_io_dispatch(&DriverObject->FastIoDispatch);
- device_nameW.Buffer = device_name; - device_nameW.Length = device_nameW.MaximumLength = (USHORT)wcslen(device_name) * sizeof(WCHAR); - dosdevice_nameW.Buffer = dosdevice_name; - dosdevice_nameW.Length = dosdevice_nameW.MaximumLength = (USHORT)wcslen(dosdevice_name) * sizeof(WCHAR); + device_nameW.Buffer = (WCHAR*)device_name; + device_nameW.Length = device_nameW.MaximumLength = sizeof(device_name) - sizeof(WCHAR); + dosdevice_nameW.Buffer = (WCHAR*)dosdevice_name; + 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); diff --git a/drivers/filesystems/btrfs/btrfs.h b/drivers/filesystems/btrfs/btrfs.h index 27e9b63f51..eede405985 100644 --- a/drivers/filesystems/btrfs/btrfs.h +++ b/drivers/filesystems/btrfs/btrfs.h @@ -58,6 +58,7 @@ static const UINT64 superblock_addrs[] = { 0x10000, 0x4000000, 0x4000000000, 0x4 #define BTRFS_COMPRESSION_NONE 0 #define BTRFS_COMPRESSION_ZLIB 1 #define BTRFS_COMPRESSION_LZO 2 +#define BTRFS_COMPRESSION_ZSTD 3
#define BTRFS_ENCRYPTION_NONE 0
@@ -103,7 +104,7 @@ static const UINT64 superblock_addrs[] = { 0x10000, 0x4000000, 0x4000000000, 0x4 #define BTRFS_INCOMPAT_FLAGS_DEFAULT_SUBVOL 0x0002 #define BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS 0x0004 #define BTRFS_INCOMPAT_FLAGS_COMPRESS_LZO 0x0008 -#define BTRFS_INCOMPAT_FLAGS_COMPRESS_LZOV2 0x0010 +#define BTRFS_INCOMPAT_FLAGS_COMPRESS_ZSTD 0x0010 #define BTRFS_INCOMPAT_FLAGS_BIG_METADATA 0x0020 #define BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF 0x0040 #define BTRFS_INCOMPAT_FLAGS_RAID56 0x0080 diff --git a/drivers/filesystems/btrfs/btrfs.rc b/drivers/filesystems/btrfs/btrfs.rc index 50f7463328..957792add5 100644 --- a/drivers/filesystems/btrfs/btrfs.rc +++ b/drivers/filesystems/btrfs/btrfs.rc @@ -53,8 +53,8 @@ END //
VS_VERSION_INFO VERSIONINFO - FILEVERSION 1,0,2,0 - PRODUCTVERSION 1,0,2,0 + FILEVERSION 1,1,0,0 + PRODUCTVERSION 1,1,0,0 FILEFLAGSMASK 0x17L #ifdef _DEBUG FILEFLAGS 0x1L @@ -70,12 +70,12 @@ BEGIN BLOCK "080904b0" BEGIN VALUE "FileDescription", "WinBtrfs" - VALUE "FileVersion", "1.0.2" + VALUE "FileVersion", "1.1" VALUE "InternalName", "btrfs" VALUE "LegalCopyright", "Copyright (c) Mark Harmstone 2016-18" VALUE "OriginalFilename", "btrfs.sys" VALUE "ProductName", "WinBtrfs" - VALUE "ProductVersion", "1.0.2" + VALUE "ProductVersion", "1.1" END END BLOCK "VarFileInfo" diff --git a/drivers/filesystems/btrfs/btrfs_drv.h b/drivers/filesystems/btrfs/btrfs_drv.h index 857555f755..e6ea5891f3 100644 --- a/drivers/filesystems/btrfs/btrfs_drv.h +++ b/drivers/filesystems/btrfs/btrfs_drv.h @@ -74,6 +74,7 @@ // #define DEBUG_LONG_MESSAGES // #define DEBUG_FLUSH_TIMES // #define DEBUG_STATS +// #define DEBUG_CHUNK_LOCKS #define DEBUG_PARANOID #endif
@@ -110,6 +111,11 @@
#define IO_REPARSE_TAG_LXSS_SYMLINK 0xa000001d // undocumented?
+#define IO_REPARSE_TAG_LXSS_SOCKET 0x80000023 +#define IO_REPARSE_TAG_LXSS_FIFO 0x80000024 +#define IO_REPARSE_TAG_LXSS_CHARDEV 0x80000025 +#define IO_REPARSE_TAG_LXSS_BLOCKDEV 0x80000026 + #define BTRFS_VOLUME_PREFIX L"\Device\Btrfs{"
#ifdef _MSC_VER @@ -234,7 +240,8 @@ typedef struct { enum prop_compression_type { PropCompression_None, PropCompression_Zlib, - PropCompression_LZO + PropCompression_LZO, + PropCompression_ZSTD };
typedef struct { @@ -606,6 +613,7 @@ typedef struct { UINT8 compress_type; BOOL readonly; UINT32 zlib_level; + UINT32 zstd_level; UINT32 flush_interval; UINT32 max_inline; UINT64 subvol_id; @@ -716,6 +724,9 @@ typedef struct _device_extension { LIST_ENTRY devices; #ifdef DEBUG_STATS debug_stats stats; +#endif +#ifdef DEBUG_CHUNK_LOCKS + LONG chunk_locks_held; #endif UINT64 devices_loaded; superblock superblock; @@ -955,10 +966,10 @@ static __inline UINT64 unix_time_to_win(BTRFS_TIME* t) { }
static __inline void win_time_to_unix(LARGE_INTEGER t, BTRFS_TIME* out) { - ULONGLONG l = t.QuadPart - 116444736000000000; + ULONGLONG l = (ULONGLONG)t.QuadPart - 116444736000000000;
out->seconds = l / 10000000; - out->nanoseconds = (l % 10000000) * 100; + out->nanoseconds = (UINT32)((l % 10000000) * 100); }
_Post_satisfies_(*stripe>=0&&*stripe<num_stripes) @@ -1083,13 +1094,21 @@ void protect_superblocks(_Inout_ chunk* c); BOOL is_top_level(_In_ PIRP Irp); NTSTATUS create_root(_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ UINT64 id, _Out_ root** rootptr, _In_ BOOL no_tree, _In_ UINT64 offset, _In_opt_ PIRP Irp); -void uninit(_In_ device_extension* Vcb, _In_ BOOL flush); +void uninit(_In_ device_extension* Vcb); NTSTATUS dev_ioctl(_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG ControlCode, _In_reads_bytes_opt_(InputBufferSize) PVOID InputBuffer, _In_ ULONG InputBufferSize, _Out_writes_bytes_opt_(OutputBufferSize) PVOID OutputBuffer, _In_ ULONG OutputBufferSize, _In_ BOOLEAN Override, _Out_opt_ IO_STATUS_BLOCK* iosb); BOOL is_file_name_valid(_In_ PUNICODE_STRING us, _In_ BOOL posix); void send_notification_fileref(_In_ file_ref* fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream); void send_notification_fcb(_In_ file_ref* fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream);
+#ifdef DEBUG_CHUNK_LOCKS +#define acquire_chunk_lock(c, Vcb) { ExAcquireResourceExclusiveLite(&c->lock, TRUE); InterlockedIncrement(&Vcb->chunk_locks_held); } +#define release_chunk_lock(c, Vcb) { InterlockedDecrement(&Vcb->chunk_locks_held); ExReleaseResourceLite(&c->lock); } +#else +#define acquire_chunk_lock(c, Vcb) ExAcquireResourceExclusiveLite(&(c)->lock, TRUE) +#define release_chunk_lock(c, Vcb) ExReleaseResourceLite(&(c)->lock) +#endif + _Ret_z_ WCHAR* file_desc(_In_ PFILE_OBJECT FileObject); WCHAR* file_desc_fileref(_In_ file_ref* fileref); @@ -1123,6 +1142,7 @@ extern UINT32 mount_compress; extern UINT32 mount_compress_force; extern UINT32 mount_compress_type; extern UINT32 mount_zlib_level; +extern UINT32 mount_zstd_level; extern UINT32 mount_flush_interval; extern UINT32 mount_max_inline; extern UINT32 mount_skip_balance; @@ -1208,6 +1228,18 @@ typedef struct { LIST_ENTRY list_entry; } rollback_item;
+typedef struct { + ANSI_STRING name; + ANSI_STRING value; + UCHAR flags; + LIST_ENTRY list_entry; +} ea_item; + +static const char lxuid[] = "$LXUID"; +static const char lxgid[] = "$LXGID"; +static const char lxmod[] = "$LXMOD"; +static const char lxdev[] = "$LXDEV"; + // in treefuncs.c NTSTATUS find_item(_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension* Vcb, _In_ root* r, _Out_ traverse_ptr* tp, _In_ const KEY* searchkey, _In_ BOOL ignore, _In_opt_ PIRP Irp); @@ -1307,6 +1339,7 @@ _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI drv_directory_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
ULONG get_reparse_tag(device_extension* Vcb, root* subvol, UINT64 inode, UINT8 type, ULONG atts, BOOL lxss, PIRP Irp); +ULONG get_reparse_tag_fcb(fcb* fcb);
// in security.c
@@ -1353,6 +1386,7 @@ void remove_dir_child_from_hash_lists(fcb* fcb, dir_child* dc);
// in reparse.c NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject, void* buffer, DWORD buflen, ULONG_PTR* retlen); +NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, ccb* ccb, file_ref* fileref, PIRP Irp, LIST_ENTRY* rollback); NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp); NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp);
@@ -1479,6 +1513,7 @@ void watch_registry(HANDLE regh); // in compress.c NTSTATUS zlib_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen); NTSTATUS lzo_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen, UINT32 inpageoff); +NTSTATUS zstd_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen); NTSTATUS write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback);
// in galois.c @@ -1720,6 +1755,10 @@ static __inline void do_xor(UINT8* buf1, UINT8* buf2, UINT32 len) { #define S_ISVTX 0001000 #endif
+// based on functions in sys/sysmacros.h +#define major(rdev) ((((rdev) >> 8) & 0xFFF) | ((UINT32)((rdev) >> 32) & ~0xFFF)) +#define minor(rdev) (((rdev) & 0xFF) | ((UINT32)((rdev) >> 12) & ~0xFF)) + static __inline UINT64 fcb_alloc_size(fcb* fcb) { if (S_ISDIR(fcb->inode_item.st_mode)) return 0; diff --git a/drivers/filesystems/btrfs/btrfsioctl.h b/drivers/filesystems/btrfs/btrfsioctl.h index 9c57c9cb60..a7f53b3317 100644 --- a/drivers/filesystems/btrfs/btrfsioctl.h +++ b/drivers/filesystems/btrfs/btrfsioctl.h @@ -63,6 +63,7 @@ typedef struct { #define BTRFS_COMPRESSION_ANY 0 #define BTRFS_COMPRESSION_ZLIB 1 #define BTRFS_COMPRESSION_LZO 2 +#define BTRFS_COMPRESSION_ZSTD 3
typedef struct { UINT64 subvol; @@ -79,6 +80,25 @@ typedef struct { UINT8 compression_type; } btrfs_inode_info;
+typedef struct { + UINT64 subvol; + UINT64 inode; + BOOL top; + UINT8 type; + UINT32 st_uid; + UINT32 st_gid; + UINT32 st_mode; + UINT64 st_rdev; + UINT64 flags; + UINT32 inline_length; + UINT64 disk_size_uncompressed; + UINT64 disk_size_zlib; + UINT64 disk_size_lzo; + UINT8 compression_type; + UINT64 disk_size_zstd; + UINT64 sparse_size; +} btrfs_inode_info2; + typedef struct { UINT64 flags; BOOL flags_changed; diff --git a/drivers/filesystems/btrfs/compress.c b/drivers/filesystems/btrfs/compress.c index 0a8a1f7269..598171b678 100644 --- a/drivers/filesystems/btrfs/compress.c +++ b/drivers/filesystems/btrfs/compress.c @@ -39,6 +39,10 @@ #include <zlib.h> #endif
+#define ZSTD_STATIC_LINKING_ONLY + +#include "zstd/zstd.h" + #define LINUX_PAGE_SIZE 4096
typedef struct { @@ -82,6 +86,16 @@ typedef struct {
#define LZO_BYTE(x) ((unsigned char) (x))
+#define ZSTD_ALLOC_TAG 0x6474737a // "zstd" + +// needs to be the same as Linux (fs/btrfs/zstd.c) +#define ZSTD_BTRFS_MAX_WINDOWLOG 17 + +static void* zstd_malloc(void* opaque, size_t size); +static void zstd_free(void* opaque, void* address); + +ZSTD_customMem zstd_mem = { .customAlloc = zstd_malloc, .customFree = zstd_free, .opaque = NULL }; + static UINT8 lzo_nextbyte(lzo_stream* stream) { UINT8 c;
@@ -449,7 +463,7 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en c = CONTAINING_RECORD(le, chunk, list_entry);
if (!c->readonly && !c->reloc) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) { if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) { @@ -462,7 +476,7 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en } }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, fcb->Vcb); }
le = le->Flink; @@ -486,7 +500,7 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en }
if (c) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) { if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) { @@ -497,7 +511,7 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en } }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, fcb->Vcb); }
WARN("couldn't find any data chunks with %llx bytes free\n", comp_length); @@ -847,7 +861,7 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end c = CONTAINING_RECORD(le, chunk, list_entry);
if (!c->readonly && !c->reloc) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) { if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) { @@ -860,7 +874,7 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end } }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, fcb->Vcb); }
le = le->Flink; @@ -884,7 +898,7 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end }
if (c) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) { if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) { @@ -895,7 +909,173 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end } }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, fcb->Vcb); + } + + WARN("couldn't find any data chunks with %llx bytes free\n", comp_length); + + if (compression != BTRFS_COMPRESSION_NONE) + ExFreePool(comp_data); + + return STATUS_DISK_FULL; +} + +static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback) { + NTSTATUS Status; + UINT8 compression; + UINT32 comp_length; + UINT8* comp_data; + UINT32 out_left; + LIST_ENTRY* le; + chunk* c; + ZSTD_CStream* stream; + size_t init_res, written; + ZSTD_inBuffer input; + ZSTD_outBuffer output; + ZSTD_parameters params; + + comp_data = ExAllocatePoolWithTag(PagedPool, (UINT32)(end_data - start_data), ALLOC_TAG); + if (!comp_data) { + ERR("out of memory\n"); + return STATUS_INSUFFICIENT_RESOURCES; + } + + Status = excise_extents(fcb->Vcb, fcb, start_data, end_data, Irp, rollback); + if (!NT_SUCCESS(Status)) { + ERR("excise_extents returned %08x\n", Status); + ExFreePool(comp_data); + return Status; + } + + stream = ZSTD_createCStream_advanced(zstd_mem); + + if (!stream) { + ERR("ZSTD_createCStream failed.\n"); + ExFreePool(comp_data); + return STATUS_INTERNAL_ERROR; + } + + params = ZSTD_getParams(fcb->Vcb->options.zstd_level, (UINT32)(end_data - start_data), 0); + + if (params.cParams.windowLog > ZSTD_BTRFS_MAX_WINDOWLOG) + params.cParams.windowLog = ZSTD_BTRFS_MAX_WINDOWLOG; + + init_res = ZSTD_initCStream_advanced(stream, NULL, 0, params, (UINT32)(end_data - start_data)); + + if (ZSTD_isError(init_res)) { + ERR("ZSTD_initCStream_advanced failed: %s\n", ZSTD_getErrorName(init_res)); + ZSTD_freeCStream(stream); + ExFreePool(comp_data); + return STATUS_INTERNAL_ERROR; + } + + input.src = data; + input.size = (UINT32)(end_data - start_data); + input.pos = 0; + + output.dst = comp_data; + output.size = (UINT32)(end_data - start_data); + output.pos = 0; + + while (input.pos < input.size && output.pos < output.size) { + written = ZSTD_compressStream(stream, &output, &input); + + if (ZSTD_isError(written)) { + ERR("ZSTD_compressStream failed: %s\n", ZSTD_getErrorName(written)); + ZSTD_freeCStream(stream); + ExFreePool(comp_data); + return STATUS_INTERNAL_ERROR; + } + } + + written = ZSTD_endStream(stream, &output); + if (ZSTD_isError(written)) { + ERR("ZSTD_endStream failed: %s\n", ZSTD_getErrorName(written)); + ZSTD_freeCStream(stream); + ExFreePool(comp_data); + return STATUS_INTERNAL_ERROR; + } + + ZSTD_freeCStream(stream); + + out_left = output.size - output.pos; + + if (out_left < fcb->Vcb->superblock.sector_size) { // compressed extent would be larger than or same size as uncompressed extent + ExFreePool(comp_data); + + comp_length = (UINT32)(end_data - start_data); + comp_data = data; + compression = BTRFS_COMPRESSION_NONE; + + *compressed = FALSE; + } else { + UINT32 cl; + + compression = BTRFS_COMPRESSION_ZSTD; + cl = (UINT32)(end_data - start_data - out_left); + comp_length = (UINT32)sector_align(cl, fcb->Vcb->superblock.sector_size); + + RtlZeroMemory(comp_data + cl, comp_length - cl); + + *compressed = TRUE; + } + + ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, TRUE); + + le = fcb->Vcb->chunks.Flink; + while (le != &fcb->Vcb->chunks) { + c = CONTAINING_RECORD(le, chunk, list_entry); + + if (!c->readonly && !c->reloc) { + acquire_chunk_lock(c, fcb->Vcb); + + if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) { + if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) { + ExReleaseResourceLite(&fcb->Vcb->chunk_lock); + + if (compression != BTRFS_COMPRESSION_NONE) + ExFreePool(comp_data); + + return STATUS_SUCCESS; + } + } + + release_chunk_lock(c, fcb->Vcb); + } + + le = le->Flink; + } + + ExReleaseResourceLite(&fcb->Vcb->chunk_lock); + + ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, TRUE); + + Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, FALSE); + + ExReleaseResourceLite(&fcb->Vcb->chunk_lock); + + if (!NT_SUCCESS(Status)) { + ERR("alloc_chunk returned %08x\n", Status); + + if (compression != BTRFS_COMPRESSION_NONE) + ExFreePool(comp_data); + + return Status; + } + + if (c) { + acquire_chunk_lock(c, fcb->Vcb); + + if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) { + if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) { + if (compression != BTRFS_COMPRESSION_NONE) + ExFreePool(comp_data); + + return STATUS_SUCCESS; + } + } + + release_chunk_lock(c, fcb->Vcb); }
WARN("couldn't find any data chunks with %llx bytes free\n", comp_length); @@ -912,18 +1092,82 @@ NTSTATUS write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void if (fcb->Vcb->options.compress_type != 0 && fcb->prop_compression == PropCompression_None) type = fcb->Vcb->options.compress_type; else { - if (!(fcb->Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_COMPRESS_LZO) && fcb->prop_compression == PropCompression_LZO) { - fcb->Vcb->superblock.incompat_flags |= BTRFS_INCOMPAT_FLAGS_COMPRESS_LZO; + if (!(fcb->Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_COMPRESS_ZSTD) && fcb->prop_compression == PropCompression_ZSTD) + type = BTRFS_COMPRESSION_ZSTD; + else if (fcb->Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_COMPRESS_ZSTD && fcb->prop_compression != PropCompression_Zlib && fcb->prop_compression != PropCompression_LZO) + type = BTRFS_COMPRESSION_ZSTD; + else if (!(fcb->Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_COMPRESS_LZO) && fcb->prop_compression == PropCompression_LZO) type = BTRFS_COMPRESSION_LZO; - } else if (fcb->Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_COMPRESS_LZO && fcb->prop_compression != PropCompression_Zlib) + else if (fcb->Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_COMPRESS_LZO && fcb->prop_compression != PropCompression_Zlib) type = BTRFS_COMPRESSION_LZO; else type = BTRFS_COMPRESSION_ZLIB; }
- if (type == BTRFS_COMPRESSION_LZO) { + if (type == BTRFS_COMPRESSION_ZSTD) { + fcb->Vcb->superblock.incompat_flags |= BTRFS_INCOMPAT_FLAGS_COMPRESS_ZSTD; + return zstd_write_compressed_bit(fcb, start_data, end_data, data, compressed, Irp, rollback); + } else if (type == BTRFS_COMPRESSION_LZO) { fcb->Vcb->superblock.incompat_flags |= BTRFS_INCOMPAT_FLAGS_COMPRESS_LZO; return lzo_write_compressed_bit(fcb, start_data, end_data, data, compressed, Irp, rollback); } else return zlib_write_compressed_bit(fcb, start_data, end_data, data, compressed, Irp, rollback); } + +static void* zstd_malloc(void* opaque, size_t size) { + UNUSED(opaque); + + return ExAllocatePoolWithTag(PagedPool, size, ZSTD_ALLOC_TAG); +} + +static void zstd_free(void* opaque, void* address) { + UNUSED(opaque); + + ExFreePool(address); +} + +NTSTATUS zstd_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen) { + NTSTATUS Status; + ZSTD_DStream* stream; + size_t init_res, read; + ZSTD_inBuffer input; + ZSTD_outBuffer output; + + stream = ZSTD_createDStream_advanced(zstd_mem); + + if (!stream) { + ERR("ZSTD_createDStream failed.\n"); + return STATUS_INTERNAL_ERROR; + } + + init_res = ZSTD_initDStream(stream); + + if (ZSTD_isError(init_res)) { + ERR("ZSTD_initDStream failed: %s\n", ZSTD_getErrorName(init_res)); + Status = STATUS_INTERNAL_ERROR; + goto end; + } + + input.src = inbuf; + input.size = inlen; + input.pos = 0; + + output.dst = outbuf; + output.size = outlen; + output.pos = 0; + + read = ZSTD_decompressStream(stream, &output, &input); + + if (ZSTD_isError(read)) { + ERR("ZSTD_decompressStream failed: %s\n", ZSTD_getErrorName(read)); + Status = STATUS_INTERNAL_ERROR; + goto end; + } + + Status = STATUS_SUCCESS; + +end: + ZSTD_freeDStream(stream); + + return Status; +} diff --git a/drivers/filesystems/btrfs/create.c b/drivers/filesystems/btrfs/create.c index 4c4c5dd984..1b4417e802 100644 --- a/drivers/filesystems/btrfs/create.c +++ b/drivers/filesystems/btrfs/create.c @@ -23,7 +23,24 @@
extern PDEVICE_OBJECT master_devobj;
-static WCHAR datastring[] = L"::$DATA"; +static const WCHAR datastring[] = L"::$DATA"; + +// Windows 10 +#define ATOMIC_CREATE_ECP_IN_FLAG_REPARSE_POINT_SPECIFIED 0x0002 +#define ATOMIC_CREATE_ECP_IN_FLAG_BEST_EFFORT 0x0100 +#define ATOMIC_CREATE_ECP_OUT_FLAG_REPARSE_POINT_SET 0x0002 + +typedef struct _ATOMIC_CREATE_ECP_CONTEXT { + USHORT Size; + USHORT InFlags; + USHORT OutFlags; + USHORT ReparseBufferLength; + PREPARSE_DATA_BUFFER ReparseBuffer; + LONGLONG FileSize; + LONGLONG ValidDataLength; +} ATOMIC_CREATE_ECP_CONTEXT, *PATOMIC_CREATE_ECP_CONTEXT; + +static const GUID GUID_ECP_ATOMIC_CREATE = { 0x4720bd83, 0x52ac, 0x4104, { 0xa1, 0x30, 0xd1, 0xec, 0x6a, 0x8c, 0xc8, 0xe5 } };
fcb* create_fcb(device_extension* Vcb, POOL_TYPE pool_type) { fcb* fcb; @@ -308,11 +325,11 @@ static NTSTATUS split_path(device_extension* Vcb, PUNICODE_STRING path, LIST_ENT InsertTailList(parts, &nb->list_entry);
if (has_stream) { - static WCHAR datasuf[] = {':','$','D','A','T','A',0}; + static const WCHAR datasuf[] = {':','$','D','A','T','A',0}; UNICODE_STRING dsus;
- dsus.Buffer = datasuf; - dsus.Length = dsus.MaximumLength = (UINT16)wcslen(datasuf) * sizeof(WCHAR); + dsus.Buffer = (WCHAR*)datasuf; + dsus.Length = dsus.MaximumLength = sizeof(datasuf) - sizeof(WCHAR);
for (i = 0; i < nb->us.Length / sizeof(WCHAR); i++) { if (nb->us.Buffer[i] == ':') { @@ -799,7 +816,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo ULONG len; DIR_ITEM* di;
- static char xapref[] = "user."; + static const char xapref[] = "user.";
if (tp.item->size < offsetof(DIR_ITEM, name[0])) { ERR("(%llx,%x,%llx) was %u bytes, expected at least %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, offsetof(DIR_ITEM, name[0])); @@ -813,7 +830,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo if (len < offsetof(DIR_ITEM, name[0]) + di->m + di->n) break;
- if (tp.item->key.offset == EA_REPARSE_HASH && di->n == strlen(EA_REPARSE) && RtlCompareMemory(EA_REPARSE, di->name, di->n) == di->n) { + if (tp.item->key.offset == EA_REPARSE_HASH && di->n == sizeof(EA_REPARSE) - 1 && RtlCompareMemory(EA_REPARSE, di->name, di->n) == di->n) { if (di->m > 0) { fcb->reparse_xattr.Buffer = ExAllocatePoolWithTag(PagedPool, di->m, ALLOC_TAG); if (!fcb->reparse_xattr.Buffer) { @@ -827,7 +844,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo fcb->reparse_xattr.Buffer = NULL;
fcb->reparse_xattr.Length = fcb->reparse_xattr.MaximumLength = di->m; - } else if (tp.item->key.offset == EA_EA_HASH && di->n == strlen(EA_EA) && RtlCompareMemory(EA_EA, di->name, di->n) == di->n) { + } else if (tp.item->key.offset == EA_EA_HASH && di->n == sizeof(EA_EA) - 1 && RtlCompareMemory(EA_EA, di->name, di->n) == di->n) { if (di->m > 0) { ULONG offset;
@@ -863,7 +880,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo } while (TRUE); } } - } else if (tp.item->key.offset == EA_DOSATTRIB_HASH && di->n == strlen(EA_DOSATTRIB) && RtlCompareMemory(EA_DOSATTRIB, di->name, di->n) == di->n) { + } else if (tp.item->key.offset == EA_DOSATTRIB_HASH && di->n == sizeof(EA_DOSATTRIB) - 1 && RtlCompareMemory(EA_DOSATTRIB, di->name, di->n) == di->n) { if (di->m > 0) { if (get_file_attributes_from_xattr(&di->name[di->n], di->m, &fcb->atts)) { atts_set = TRUE; @@ -884,7 +901,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo } } } - } else if (tp.item->key.offset == EA_NTACL_HASH && di->n == strlen(EA_NTACL) && RtlCompareMemory(EA_NTACL, di->name, di->n) == di->n) { + } else if (tp.item->key.offset == EA_NTACL_HASH && di->n == sizeof(EA_NTACL) - 1 && RtlCompareMemory(EA_NTACL, di->name, di->n) == di->n) { if (di->m > 0) { fcb->sd = ExAllocatePoolWithTag(PagedPool, di->m, ALLOC_TAG); if (!fcb->sd) { @@ -902,23 +919,26 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo else sd_set = TRUE; } - } else if (tp.item->key.offset == EA_PROP_COMPRESSION_HASH && di->n == strlen(EA_PROP_COMPRESSION) && RtlCompareMemory(EA_PROP_COMPRESSION, di->name, di->n) == di->n) { + } else if (tp.item->key.offset == EA_PROP_COMPRESSION_HASH && di->n == sizeof(EA_PROP_COMPRESSION) - 1 && RtlCompareMemory(EA_PROP_COMPRESSION, di->name, di->n) == di->n) { if (di->m > 0) { - const char lzo[] = "lzo"; - const char zlib[] = "zlib"; + static const char lzo[] = "lzo"; + static const char zlib[] = "zlib"; + static const char zstd[] = "zstd";
- if (di->m == strlen(lzo) && RtlCompareMemory(&di->name[di->n], lzo, di->m) == di->m) + if (di->m == sizeof(lzo) - 1 && RtlCompareMemory(&di->name[di->n], lzo, di->m) == di->m) fcb->prop_compression = PropCompression_LZO; - else if (di->m == strlen(zlib) && RtlCompareMemory(&di->name[di->n], zlib, di->m) == di->m) + else if (di->m == sizeof(zlib) - 1 && RtlCompareMemory(&di->name[di->n], zlib, di->m) == di->m) fcb->prop_compression = PropCompression_Zlib; + else if (di->m == sizeof(zstd) - 1 && RtlCompareMemory(&di->name[di->n], zstd, di->m) == di->m) + fcb->prop_compression = PropCompression_ZSTD; else fcb->prop_compression = PropCompression_None; } - } else if (di->n > strlen(xapref) && RtlCompareMemory(xapref, di->name, strlen(xapref)) == strlen(xapref)) { + } else if (di->n > sizeof(xapref) - 1 && RtlCompareMemory(xapref, di->name, sizeof(xapref) - 1) == sizeof(xapref) - 1) { dir_child* dc; ULONG utf16len;
- Status = RtlUTF8ToUnicodeN(NULL, 0, &utf16len, &di->name[strlen(xapref)], di->n - (ULONG)strlen(xapref)); + Status = RtlUTF8ToUnicodeN(NULL, 0, &utf16len, &di->name[sizeof(xapref) - 1], di->n + 1 - sizeof(xapref)); if (!NT_SUCCESS(Status)) { ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status); free_fcb(Vcb, fcb); @@ -934,7 +954,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo
RtlZeroMemory(dc, sizeof(dir_child));
- dc->utf8.MaximumLength = dc->utf8.Length = di->n - (UINT16)strlen(xapref); + dc->utf8.MaximumLength = dc->utf8.Length = di->n + 1 - sizeof(xapref); dc->utf8.Buffer = ExAllocatePoolWithTag(PagedPool, dc->utf8.MaximumLength, ALLOC_TAG); if (!dc->utf8.Buffer) { ERR("out of memory\n"); @@ -943,7 +963,7 @@ NTSTATUS open_fcb(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lo return STATUS_INSUFFICIENT_RESOURCES; }
- RtlCopyMemory(dc->utf8.Buffer, &di->name[strlen(xapref)], dc->utf8.Length); + RtlCopyMemory(dc->utf8.Buffer, &di->name[sizeof(xapref) - 1], dc->utf8.Length);
dc->name.MaximumLength = dc->name.Length = (UINT16)utf16len; dc->name.Buffer = ExAllocatePoolWithTag(PagedPool, dc->name.MaximumLength, ALLOC_TAG); @@ -1113,11 +1133,11 @@ static NTSTATUS open_fcb_stream(_Requires_lock_held_(_Curr_->tree_lock) _Require NTSTATUS Status; KEY searchkey; traverse_ptr tp; - static char xapref[] = "user."; + static const char xapref[] = "user."; ANSI_STRING xattr; UINT32 crc32;
- xattr.Length = (UINT16)strlen(xapref) + dc->utf8.Length; + xattr.Length = sizeof(xapref) - 1 + dc->utf8.Length; xattr.MaximumLength = xattr.Length + 1; xattr.Buffer = ExAllocatePoolWithTag(PagedPool, xattr.MaximumLength, ALLOC_TAG); if (!xattr.Buffer) { @@ -1125,8 +1145,8 @@ static NTSTATUS open_fcb_stream(_Requires_lock_held_(_Curr_->tree_lock) _Require return STATUS_INSUFFICIENT_RESOURCES; }
- RtlCopyMemory(xattr.Buffer, xapref, strlen(xapref)); - RtlCopyMemory(&xattr.Buffer[strlen(xapref)], dc->utf8.Buffer, dc->utf8.Length); + RtlCopyMemory(xattr.Buffer, xapref, sizeof(xapref) - 1); + RtlCopyMemory(&xattr.Buffer[sizeof(xapref) - 1], dc->utf8.Buffer, dc->utf8.Length); xattr.Buffer[xattr.Length] = 0;
fcb = create_fcb(Vcb, PagedPool); @@ -1454,7 +1474,7 @@ NTSTATUS open_fileref(_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusiv InitializeListHead(&parts);
if (fnus->Length != 0 && - (fnus->Length != wcslen(datastring) * sizeof(WCHAR) || RtlCompareMemory(fnus->Buffer, datastring, wcslen(datastring) * sizeof(WCHAR)) != wcslen(datastring) * sizeof(WCHAR))) { + (fnus->Length != sizeof(datastring) - sizeof(WCHAR) || RtlCompareMemory(fnus->Buffer, datastring, sizeof(datastring) - sizeof(WCHAR)) != sizeof(datastring) - sizeof(WCHAR))) { Status = split_path(Vcb, &fnus2, &parts, &has_stream); if (!NT_SUCCESS(Status)) { ERR("split_path returned %08x\n", Status); @@ -1649,6 +1669,218 @@ UINT32 inherit_mode(fcb* parfcb, BOOL is_dir) { return mode; }
+static NTSTATUS file_create_parse_ea(fcb* fcb, FILE_FULL_EA_INFORMATION* ea) { + NTSTATUS Status; + LIST_ENTRY ealist, *le; + UINT16 size = 0; + char* buf; + + InitializeListHead(&ealist); + + do { + STRING s; + BOOL found = FALSE; + + s.Length = s.MaximumLength = ea->EaNameLength; + s.Buffer = ea->EaName; + + RtlUpperString(&s, &s); + + le = ealist.Flink; + while (le != &ealist) { + ea_item* item = CONTAINING_RECORD(le, ea_item, list_entry); + + if (item->name.Length == s.Length && RtlCompareMemory(item->name.Buffer, s.Buffer, s.Length) == s.Length) { + item->flags = ea->Flags; + item->value.Length = item->value.MaximumLength = ea->EaValueLength; + item->value.Buffer = &ea->EaName[ea->EaNameLength + 1]; + found = TRUE; + break; + } + + le = le->Flink; + } + + if (!found) { + ea_item* item = ExAllocatePoolWithTag(PagedPool, sizeof(ea_item), ALLOC_TAG); + if (!item) { + ERR("out of memory\n"); + Status = STATUS_INSUFFICIENT_RESOURCES; + goto end; + } + + item->name.Length = item->name.MaximumLength = ea->EaNameLength; + item->name.Buffer = ea->EaName; + + item->value.Length = item->value.MaximumLength = ea->EaValueLength; + item->value.Buffer = &ea->EaName[ea->EaNameLength + 1]; + + item->flags = ea->Flags; + + InsertTailList(&ealist, &item->list_entry); + } + + if (ea->NextEntryOffset == 0) + break; + + ea = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ea) + ea->NextEntryOffset); + } while (TRUE); + + // handle LXSS values + le = ealist.Flink; + while (le != &ealist) { + LIST_ENTRY* le2 = le->Flink; + ea_item* item = CONTAINING_RECORD(le, ea_item, list_entry); + + if (item->name.Length == sizeof(lxuid) - 1 && RtlCompareMemory(item->name.Buffer, lxuid, item->name.Length) == item->name.Length) { + if (item->value.Length < sizeof(UINT32)) { + ERR("uid value was shorter than expected\n"); + Status = STATUS_INVALID_PARAMETER; + goto end; + } + + RtlCopyMemory(&fcb->inode_item.st_uid, item->value.Buffer, sizeof(UINT32)); + fcb->sd_dirty = TRUE; + fcb->sd_deleted = FALSE; + + RemoveEntryList(&item->list_entry); + ExFreePool(item); + } else if (item->name.Length == sizeof(lxgid) - 1 && RtlCompareMemory(item->name.Buffer, lxgid, item->name.Length) == item->name.Length) { + if (item->value.Length < sizeof(UINT32)) { + ERR("gid value was shorter than expected\n"); + Status = STATUS_INVALID_PARAMETER; + goto end; + } + + RtlCopyMemory(&fcb->inode_item.st_gid, item->value.Buffer, sizeof(UINT32)); + + RemoveEntryList(&item->list_entry); + ExFreePool(item); + } else if (item->name.Length == sizeof(lxmod) - 1 && RtlCompareMemory(item->name.Buffer, lxmod, item->name.Length) == item->name.Length) { + UINT32 allowed = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH | S_ISGID | S_ISVTX | S_ISUID; + UINT32 val; + + if (item->value.Length < sizeof(UINT32)) { + ERR("mode value was shorter than expected\n"); + Status = STATUS_INVALID_PARAMETER; + goto end; + } + + RtlCopyMemory(&val, item->value.Buffer, sizeof(UINT32)); + + if (fcb->type != BTRFS_TYPE_DIRECTORY) + allowed |= __S_IFIFO | __S_IFCHR | __S_IFBLK | __S_IFSOCK; + + fcb->inode_item.st_mode &= ~allowed; + fcb->inode_item.st_mode |= val & allowed; + + if (fcb->type != BTRFS_TYPE_DIRECTORY) { + if ((fcb->inode_item.st_mode & __S_IFCHR) == __S_IFCHR) + fcb->type = BTRFS_TYPE_CHARDEV; + else if ((fcb->inode_item.st_mode & __S_IFBLK) == __S_IFBLK) + fcb->type = BTRFS_TYPE_BLOCKDEV; + else if ((fcb->inode_item.st_mode & __S_IFIFO) == __S_IFIFO) + fcb->type = BTRFS_TYPE_FIFO; + else if ((fcb->inode_item.st_mode & __S_IFSOCK) == __S_IFSOCK) + fcb->type = BTRFS_TYPE_SOCKET; + } + + RemoveEntryList(&item->list_entry); + ExFreePool(item); + } else if (item->name.Length == sizeof(lxdev) - 1 && RtlCompareMemory(item->name.Buffer, lxdev, item->name.Length) == item->name.Length) { + UINT32 major, minor; + + if (item->value.Length < sizeof(UINT64)) { + ERR("dev value was shorter than expected\n"); + Status = STATUS_INVALID_PARAMETER; + goto end; + } + + major = *(UINT32*)item->value.Buffer; + minor = *(UINT32*)&item->value.Buffer[sizeof(UINT32)]; + + fcb->inode_item.st_rdev = (minor & 0xFFFFF) | ((major & 0xFFFFFFFFFFF) << 20); + + RemoveEntryList(&item->list_entry); + ExFreePool(item); + } + + le = le2; + } + + if (fcb->type != BTRFS_TYPE_CHARDEV && fcb->type != BTRFS_TYPE_BLOCKDEV) + fcb->inode_item.st_rdev = 0; + + if (IsListEmpty(&ealist)) + return STATUS_SUCCESS; + + le = ealist.Flink; + while (le != &ealist) { + ea_item* item = CONTAINING_RECORD(le, ea_item, list_entry); + + if (size % 4 > 0) + size += 4 - (size % 4); + + size += (UINT16)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + item->name.Length + 1 + item->value.Length; + + le = le->Flink; + } + + buf = ExAllocatePoolWithTag(PagedPool, size, ALLOC_TAG); + if (!buf) { + ERR("out of memory\n"); + Status = STATUS_INSUFFICIENT_RESOURCES; + goto end; + } + + fcb->ea_xattr.Length = fcb->ea_xattr.MaximumLength = size; + fcb->ea_xattr.Buffer = buf; + + fcb->ealen = 4; + ea = NULL; + + le = ealist.Flink; + while (le != &ealist) { + ea_item* item = CONTAINING_RECORD(le, ea_item, list_entry); + + if (ea) { + ea->NextEntryOffset = (ULONG)offsetof(FILE_FULL_EA_INFORMATION, EaName[0]) + ea->EaNameLength + ea->EaValueLength; + + if (ea->NextEntryOffset % 4 > 0) + ea->NextEntryOffset += 4 - (ea->NextEntryOffset % 4); + + ea = (FILE_FULL_EA_INFORMATION*)(((UINT8*)ea) + ea->NextEntryOffset); + } else + ea = (FILE_FULL_EA_INFORMATION*)fcb->ea_xattr.Buffer; + + ea->NextEntryOffset = 0; + ea->Flags = item->flags; + ea->EaNameLength = (UCHAR)item->name.Length; + ea->EaValueLength = item->value.Length; + + RtlCopyMemory(ea->EaName, item->name.Buffer, item->name.Length); + ea->EaName[item->name.Length] = 0; + RtlCopyMemory(&ea->EaName[item->name.Length + 1], item->value.Buffer, item->value.Length); + + fcb->ealen += 5 + item->name.Length + item->value.Length; + + le = le->Flink; + } + + fcb->ea_changed = TRUE; + + Status = STATUS_SUCCESS; + +end: + while (!IsListEmpty(&ealist)) { + ea_item* item = CONTAINING_RECORD(RemoveHeadList(&ealist), ea_item, list_entry); + + ExFreePool(item); + } + + return Status; +} + static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension* Vcb, _In_ PUNICODE_STRING fpus, _In_ file_ref* parfileref, _In_ ULONG options, _In_reads_bytes_opt_(ealen) FILE_FULL_EA_INFORMATION* ea, _In_ ULONG ealen, _Out_ file_ref** pfr, _In_ LIST_ENTRY* rollback) { @@ -1843,44 +2075,17 @@ static NTSTATUS file_create2(_In_ PIRP Irp, _Requires_exclusive_lock_held_(_Curr fcb->sd_dirty = TRUE;
if (ea && ealen > 0) { - FILE_FULL_EA_INFORMATION* eainfo; - - fcb->ealen = 4; - - // capitalize EA names - eainfo = ea; - do { - STRING s; - - s.Length = s.MaximumLength = eainfo->EaNameLength; - s.Buffer = eainfo->EaName; - - RtlUpperString(&s, &s); - - fcb->ealen += 5 + eainfo->EaNameLength + eainfo->EaValueLength; - - if (eainfo->NextEntryOffset == 0) - break; - - eainfo = (FILE_FULL_EA_INFORMATION*)(((UINT8*)eainfo) + eainfo->NextEntryOffset); - } while (TRUE); - - fcb->ea_xattr.Buffer = ExAllocatePoolWithTag(pool_type, ealen, ALLOC_TAG); - if (!fcb->ea_xattr.Buffer) { - ERR("out of memory\n"); + Status = file_create_parse_ea(fcb, ea); + if (!NT_SUCCESS(Status)) { + ERR("file_create_parse_ea returned %08x\n", Status); free_fcb(Vcb, fcb);
ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE); parfileref->fcb->inode_item.st_size -= utf8len * 2; ExReleaseResourceLite(parfileref->fcb->Header.Resource);
- return STATUS_INSUFFICIENT_RESOURCES; + return Status; } - - fcb->ea_xattr.Length = fcb->ea_xattr.MaximumLength = (UINT16)ealen; - RtlCopyMemory(fcb->ea_xattr.Buffer, ea, fcb->ea_xattr.Length); - - fcb->ea_changed = TRUE; }
fileref = create_fileref(Vcb); @@ -1989,11 +2194,10 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp); file_ref *fileref, *newpar, *parfileref; fcb* fcb; - static char xapref[] = "user."; - static WCHAR DOSATTRIB[] = L"DOSATTRIB"; - static WCHAR EA[] = L"EA"; - static WCHAR reparse[] = L"reparse"; - UINT16 xapreflen = (UINT16)strlen(xapref); + static const char xapref[] = "user."; + static const WCHAR DOSATTRIB[] = L"DOSATTRIB"; + static const WCHAR EA[] = L"EA"; + static const WCHAR reparse[] = L"reparse"; LARGE_INTEGER time; BTRFS_TIME now; ULONG utf8len, overhead; @@ -2086,9 +2290,9 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
SeUnlockSubjectContext(&IrpSp->Parameters.Create.SecurityContext->AccessState->SubjectSecurityContext);
- if ((stream->Length == wcslen(DOSATTRIB) * sizeof(WCHAR) && RtlCompareMemory(stream->Buffer, DOSATTRIB, stream->Length) == stream->Length) || - (stream->Length == wcslen(EA) * sizeof(WCHAR) && RtlCompareMemory(stream->Buffer, EA, stream->Length) == stream->Length) || - (stream->Length == wcslen(reparse) * sizeof(WCHAR) && RtlCompareMemory(stream->Buffer, reparse, stream->Length) == stream->Length)) { + if ((stream->Length == sizeof(DOSATTRIB) - sizeof(WCHAR) && RtlCompareMemory(stream->Buffer, DOSATTRIB, stream->Length) == stream->Length) || + (stream->Length == sizeof(EA) - sizeof(WCHAR) && RtlCompareMemory(stream->Buffer, EA, stream->Length) == stream->Length) || + (stream->Length == sizeof(reparse) - sizeof(WCHAR) && RtlCompareMemory(stream->Buffer, reparse, stream->Length) == stream->Length)) { return STATUS_OBJECT_NAME_INVALID; }
@@ -2124,7 +2328,7 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ return Status; }
- fcb->adsxattr.Length = (UINT16)utf8len + xapreflen; + fcb->adsxattr.Length = (UINT16)utf8len + sizeof(xapref) - 1; fcb->adsxattr.MaximumLength = fcb->adsxattr.Length + 1; fcb->adsxattr.Buffer = ExAllocatePoolWithTag(pool_type, fcb->adsxattr.MaximumLength, ALLOC_TAG); if (!fcb->adsxattr.Buffer) { @@ -2133,9 +2337,9 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ return STATUS_INSUFFICIENT_RESOURCES; }
- RtlCopyMemory(fcb->adsxattr.Buffer, xapref, xapreflen); + RtlCopyMemory(fcb->adsxattr.Buffer, xapref, sizeof(xapref) - 1);
- Status = RtlUnicodeToUTF8N(&fcb->adsxattr.Buffer[xapreflen], utf8len, &utf8len, stream->Buffer, stream->Length); + Status = RtlUnicodeToUTF8N(&fcb->adsxattr.Buffer[sizeof(xapref) - 1], utf8len, &utf8len, stream->Buffer, stream->Length); if (!NT_SUCCESS(Status)) { ERR("RtlUnicodeToUTF8N 2 returned %08x\n", Status); free_fcb(Vcb, fcb); @@ -2167,12 +2371,12 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
fcb->adsmaxlen = Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node) - (sizeof(DIR_ITEM) - 1);
- if (utf8len + xapreflen + overhead > fcb->adsmaxlen) { - WARN("not enough room for new DIR_ITEM (%u + %u > %u)", utf8len + xapreflen, overhead, fcb->adsmaxlen); + if (utf8len + sizeof(xapref) - 1 + overhead > fcb->adsmaxlen) { + WARN("not enough room for new DIR_ITEM (%u + %u > %u)", utf8len + sizeof(xapref) - 1, overhead, fcb->adsmaxlen); free_fcb(Vcb, fcb); return STATUS_DISK_FULL; } else - fcb->adsmaxlen -= overhead + utf8len + xapreflen; + fcb->adsmaxlen -= overhead + utf8len + sizeof(xapref) - 1;
fileref = create_fileref(Vcb); if (!fileref) { @@ -2192,7 +2396,7 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_
RtlZeroMemory(dc, sizeof(dir_child));
- dc->utf8.MaximumLength = dc->utf8.Length = fcb->adsxattr.Length - xapreflen; + dc->utf8.MaximumLength = dc->utf8.Length = fcb->adsxattr.Length + 1 - sizeof(xapref); dc->utf8.Buffer = ExAllocatePoolWithTag(PagedPool, dc->utf8.MaximumLength, ALLOC_TAG); if (!dc->utf8.Buffer) { ERR("out of memory\n"); @@ -2201,7 +2405,7 @@ static NTSTATUS create_stream(_Requires_lock_held_(_Curr_->tree_lock) _Requires_ return STATUS_INSUFFICIENT_RESOURCES; }
- RtlCopyMemory(dc->utf8.Buffer, &fcb->adsxattr.Buffer[xapreflen], fcb->adsxattr.Length - xapreflen); + RtlCopyMemory(dc->utf8.Buffer, &fcb->adsxattr.Buffer[sizeof(xapref) - 1], fcb->adsxattr.Length + 1 - sizeof(xapref));
dc->name.MaximumLength = dc->name.Length = stream->Length; dc->name.Buffer = ExAllocatePoolWithTag(pool_type, dc->name.MaximumLength, ALLOC_TAG); @@ -2302,10 +2506,14 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R file_ref *fileref, *parfileref = NULL; ULONG i, j; ccb* ccb; - static WCHAR datasuf[] = {':','$','D','A','T','A',0}; + static const WCHAR datasuf[] = {':','$','D','A','T','A',0}; UNICODE_STRING dsus, fpus, stream; PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp); POOL_TYPE pool_type = IrpSp->Flags & SL_OPEN_PAGING_FILE ? NonPagedPool : PagedPool; +#ifndef __REACTOS__ + ECP_LIST* ecp_list; + ATOMIC_CREATE_ECP_CONTEXT* acec = NULL; +#endif #ifdef DEBUG_FCB_REFCOUNTS LONG oc; #endif @@ -2318,8 +2526,27 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R if (options & FILE_DELETE_ON_CLOSE && IrpSp->Parameters.Create.FileAttributes & FILE_ATTRIBUTE_READONLY) return STATUS_CANNOT_DELETE;
- dsus.Buffer = datasuf; - dsus.Length = dsus.MaximumLength = (USHORT)wcslen(datasuf) * sizeof(WCHAR); +#ifndef __REACTOS__ + if (NT_SUCCESS(FsRtlGetEcpListFromIrp(Irp, &ecp_list)) && ecp_list) { + void* ctx = NULL; + GUID type; + ULONG ctxsize; + + do { + Status = FsRtlGetNextExtraCreateParameter(ecp_list, ctx, &type, &ctx, &ctxsize); + + if (NT_SUCCESS(Status)) { + if (RtlCompareMemory(&type, &GUID_ECP_ATOMIC_CREATE, sizeof(GUID)) == sizeof(GUID) && ctxsize >= sizeof(ATOMIC_CREATE_ECP_CONTEXT)) { + acec = ctx; + break; + } + } + } while (NT_SUCCESS(Status)); + } +#endif + + dsus.Buffer = (WCHAR*)datasuf; + dsus.Length = dsus.MaximumLength = sizeof(datasuf) - sizeof(WCHAR); fpus.Buffer = NULL;
if (!loaded_related) { @@ -2451,6 +2678,15 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R if (!ccb) { ERR("out of memory\n"); Status = STATUS_INSUFFICIENT_RESOURCES; + fileref->deleted = TRUE; + fileref->fcb->deleted = TRUE; + + if (stream.Length == 0) { + ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE); + parfileref->fcb->inode_item.st_size -= fileref->dc->utf8.Length * 2; + ExReleaseResourceLite(parfileref->fcb->Header.Resource); + } + free_fileref(Vcb, fileref); goto end; } @@ -2484,6 +2720,41 @@ static NTSTATUS file_create(PIRP Irp, _Requires_lock_held_(_Curr_->tree_lock) _R
FileObject->SectionObjectPointer = &fileref->fcb->nonpaged->segment_object;
+#ifndef __REACTOS__ + // FIXME - ATOMIC_CREATE_ECP_IN_FLAG_BEST_EFFORT + if (acec && acec->InFlags & ATOMIC_CREATE_ECP_IN_FLAG_REPARSE_POINT_SPECIFIED) { + if (acec->ReparseBufferLength > sizeof(UINT32) && *(UINT32*)acec->ReparseBuffer == IO_REPARSE_TAG_SYMLINK) { + fileref->fcb->inode_item.st_mode &= ~(__S_IFIFO | __S_IFCHR | __S_IFBLK | __S_IFSOCK); + fileref->fcb->type = BTRFS_TYPE_FILE; + } + + if (fileref->fcb->type == BTRFS_TYPE_SOCKET || fileref->fcb->type == BTRFS_TYPE_FIFO || + fileref->fcb->type == BTRFS_TYPE_CHARDEV || fileref->fcb->type == BTRFS_TYPE_BLOCKDEV) { + // NOP. If called from LXSS, humour it - we hardcode the values elsewhere. + } else { + Status = set_reparse_point2(fileref->fcb, acec->ReparseBuffer, acec->ReparseBufferLength, NULL, NULL, Irp, rollback); + if (!NT_SUCCESS(Status)) { + ERR("set_reparse_point2 returned %08x\n", Status); + fileref->deleted = TRUE; + fileref->fcb->deleted = TRUE; + + if (stream.Length == 0) { + ExAcquireResourceExclusiveLite(parfileref->fcb->Header.Resource, TRUE); + parfileref->fcb->inode_item.st_size -= fileref->dc->utf8.Length * 2; + ExReleaseResourceLite(parfileref->fcb->Header.Resource); + } + + free_fileref(Vcb, fileref); + return Status; + } + } + + acec->OutFlags |= ATOMIC_CREATE_ECP_OUT_FLAG_REPARSE_POINT_SET; + } +#endif + + fileref->dc->type = fileref->fcb->type; + goto end2;
end: @@ -2738,7 +3009,8 @@ static NTSTATUS get_reparse_block(fcb* fcb, UINT8** data) { }
RtlCopyMemory(*data, fcb->reparse_xattr.Buffer, fcb->reparse_xattr.Length); - } + } else + return STATUS_INVALID_PARAMETER;
return STATUS_SUCCESS; } diff --git a/drivers/filesystems/btrfs/dirctrl.c b/drivers/filesystems/btrfs/dirctrl.c index 64ab60f15a..4d8df559d0 100644 --- a/drivers/filesystems/btrfs/dirctrl.c +++ b/drivers/filesystems/btrfs/dirctrl.c @@ -31,16 +31,46 @@ typedef struct { dir_child* dc; } dir_entry;
+ULONG get_reparse_tag_fcb(fcb* fcb) { + ULONG tag; + + if (fcb->type == BTRFS_TYPE_SYMLINK) + return IO_REPARSE_TAG_SYMLINK; + else if (fcb->type == BTRFS_TYPE_DIRECTORY) { + if (!fcb->reparse_xattr.Buffer || fcb->reparse_xattr.Length < sizeof(ULONG)) + return 0; + + RtlCopyMemory(&tag, fcb->reparse_xattr.Buffer, sizeof(ULONG)); + } else { + NTSTATUS Status; + ULONG br; + + Status = read_file(fcb, (UINT8*)&tag, 0, sizeof(ULONG), &br, NULL); + if (!NT_SUCCESS(Status)) { + ERR("read_file returned %08x\n", Status); + return 0; + } + } + + return tag; +} + ULONG get_reparse_tag(device_extension* Vcb, root* subvol, UINT64 inode, UINT8 type, ULONG atts, BOOL lxss, PIRP Irp) { fcb* fcb; - ULONG tag = 0, br; + ULONG tag = 0; NTSTATUS Status;
- if (type == BTRFS_TYPE_SYMLINK) { - if (lxss) - return IO_REPARSE_TAG_LXSS_SYMLINK; - else - return IO_REPARSE_TAG_SYMLINK; + if (type == BTRFS_TYPE_SYMLINK) + return IO_REPARSE_TAG_SYMLINK; + else if (lxss) { + if (type == BTRFS_TYPE_SOCKET) + return IO_REPARSE_TAG_LXSS_SOCKET; + else if (type == BTRFS_TYPE_FIFO) + return IO_REPARSE_TAG_LXSS_FIFO; + else if (type == BTRFS_TYPE_CHARDEV) + return IO_REPARSE_TAG_LXSS_CHARDEV; + else if (type == BTRFS_TYPE_BLOCKDEV) + return IO_REPARSE_TAG_LXSS_BLOCKDEV; }
if (type != BTRFS_TYPE_FILE && type != BTRFS_TYPE_DIRECTORY) @@ -57,23 +87,8 @@ ULONG get_reparse_tag(device_extension* Vcb, root* subvol, UINT64 inode, UINT8 t
ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
- if (type == BTRFS_TYPE_DIRECTORY) { - if (!fcb->reparse_xattr.Buffer || fcb->reparse_xattr.Length < sizeof(ULONG)) - goto end; - - RtlCopyMemory(&tag, fcb->reparse_xattr.Buffer, sizeof(ULONG)); - } else { - Status = read_file(fcb, (UINT8*)&tag, 0, sizeof(ULONG), &br, NULL); - if (!NT_SUCCESS(Status)) { - ERR("read_file returned %08x\n", Status); - goto end; - } - - if (br < sizeof(ULONG)) - goto end; - } + tag = get_reparse_tag_fcb(fcb);
-end: ExReleaseResourceLite(fcb->Header.Resource);
free_fcb(Vcb, fcb); @@ -675,11 +690,7 @@ static NTSTATUS query_directory(PIRP Irp) { if (IrpSp->Parameters.QueryDirectory.FileName && IrpSp->Parameters.QueryDirectory.FileName->Length > 1) { TRACE("QD filename: %.*S\n", IrpSp->Parameters.QueryDirectory.FileName->Length / sizeof(WCHAR), IrpSp->Parameters.QueryDirectory.FileName->Buffer);
-#ifndef __REACTOS__ - if (IrpSp->Parameters.QueryDirectory.FileName->Buffer[0] != '*') { -#else if (IrpSp->Parameters.QueryDirectory.FileName->Length > sizeof(WCHAR) || IrpSp->Parameters.QueryDirectory.FileName->Buffer[0] != L'*') { -#endif specific_file = TRUE;
if (FsRtlDoesNameContainWildCards(IrpSp->Parameters.QueryDirectory.FileName)) { diff --git a/drivers/filesystems/btrfs/fastio.c b/drivers/filesystems/btrfs/fastio.c index 9f4c504a12..9ee282d04c 100644 --- a/drivers/filesystems/btrfs/fastio.c +++ b/drivers/filesystems/btrfs/fastio.c @@ -296,11 +296,21 @@ static NTSTATUS fast_io_acquire_for_mod_write(PFILE_OBJECT FileObject, PLARGE_IN if (!fcb) return STATUS_INVALID_PARAMETER;
- *ResourceToRelease = fcb->Header.PagingIoResource; + // Make sure we don't get interrupted by the flush thread, which can cause a deadlock
- if (!ExAcquireResourceSharedLite(*ResourceToRelease, FALSE)) + if (!ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, FALSE)) return STATUS_CANT_WAIT;
+ // Ideally this would be PagingIoResource, but that doesn't play well with copy-on-write, + // as we can't guarantee that we won't need to do any reallocations. + + *ResourceToRelease = fcb->Header.Resource; + + if (!ExAcquireResourceExclusiveLite(*ResourceToRelease, FALSE)) { + ExReleaseResourceLite(&fcb->Vcb->tree_lock); + return STATUS_CANT_WAIT; + } + return STATUS_SUCCESS; }
@@ -310,11 +320,16 @@ static NTSTATUS NTAPI fast_io_release_for_mod_write(PFILE_OBJECT FileObject, str #else static NTSTATUS fast_io_release_for_mod_write(PFILE_OBJECT FileObject, struct _ERESOURCE *ResourceToRelease, PDEVICE_OBJECT DeviceObject) { #endif - UNUSED(FileObject); + fcb* fcb; + UNUSED(DeviceObject);
+ fcb = FileObject->FsContext; + ExReleaseResourceLite(ResourceToRelease);
+ ExReleaseResourceLite(&fcb->Vcb->tree_lock); + return STATUS_SUCCESS; }
diff --git a/drivers/filesystems/btrfs/fileinfo.c b/drivers/filesystems/btrfs/fileinfo.c index 1d03a669f4..1c342b0f55 100644 --- a/drivers/filesystems/btrfs/fileinfo.c +++ b/drivers/filesystems/btrfs/fileinfo.c @@ -21,6 +21,34 @@ // not currently in mingw - introduced with Windows 10 #ifndef FileIdInformation #define FileIdInformation (enum _FILE_INFORMATION_CLASS)59 +#define FileStatLxInformation (enum _FILE_INFORMATION_CLASS)70 + +typedef struct _FILE_STAT_LX_INFORMATION { + LARGE_INTEGER FileId; + LARGE_INTEGER CreationTime; + LARGE_INTEGER LastAccessTime; + LARGE_INTEGER LastWriteTime; + LARGE_INTEGER ChangeTime; + LARGE_INTEGER AllocationSize; + LARGE_INTEGER EndOfFile; + ULONG FileAttributes; + ULONG ReparseTag; + ULONG NumberOfLinks; + ACCESS_MASK EffectiveAccess; + ULONG LxFlags; + ULONG LxUid; + ULONG LxGid; + ULONG LxMode; + ULONG LxDeviceIdMajor; + ULONG LxDeviceIdMinor; +} FILE_STAT_LX_INFORMATION, *PFILE_STAT_LX_INFORMATION; + +#define LX_FILE_METADATA_HAS_UID 0x01 +#define LX_FILE_METADATA_HAS_GID 0x02 +#define LX_FILE_METADATA_HAS_MODE 0x04 +#define LX_FILE_METADATA_HAS_DEVICE_ID 0x08 +#define LX_FILE_CASE_SENSITIVE_DIR 0x10 + #endif #endif
@@ -70,6 +98,20 @@ static NTSTATUS set_basic_information(device_extension* Vcb, PIRP Irp, PFILE_OBJ goto end; }
+ // times of -2 are some sort of undocumented behaviour to do with LXSS + + if (fbi->CreationTime.QuadPart == -2) + fbi->CreationTime.QuadPart = 0; + + if (fbi->LastAccessTime.QuadPart == -2) + fbi->LastAccessTime.QuadPart = 0; + + if (fbi->LastWriteTime.QuadPart == -2) + fbi->LastWriteTime.QuadPart = 0; + + if (fbi->ChangeTime.QuadPart == -2) + fbi->ChangeTime.QuadPart = 0; + if (fbi->CreationTime.QuadPart == -1) ccb->user_set_creation_time = TRUE; else if (fbi->CreationTime.QuadPart != 0) { @@ -2946,8 +2988,8 @@ static NTSTATUS fill_in_file_name_information(FILE_NAME_INFORMATION* fni, fcb* f ULONG reqlen; UNICODE_STRING fn; NTSTATUS Status; - static WCHAR datasuf[] = {':','$','D','A','T','A',0}; - UINT16 datasuflen = (UINT16)wcslen(datasuf) * sizeof(WCHAR); + static const WCHAR datasuf[] = {':','$','D','A','T','A',0}; + UINT16 datasuflen = sizeof(datasuf) - sizeof(WCHAR);
if (!fileref) { ERR("called without fileref\n"); @@ -2999,7 +3041,7 @@ static NTSTATUS fill_in_file_name_information(FILE_NAME_INFORMATION* fni, fcb* f return Status; }
-static NTSTATUS fill_in_file_attribute_information(FILE_ATTRIBUTE_TAG_INFORMATION* ati, fcb* fcb, ccb* ccb, PIRP Irp, LONG* length) { +static NTSTATUS fill_in_file_attribute_information(FILE_ATTRIBUTE_TAG_INFORMATION* ati, fcb* fcb, ccb* ccb, LONG* length) { *length -= sizeof(FILE_ATTRIBUTE_TAG_INFORMATION);
if (fcb->ads) { @@ -3015,7 +3057,7 @@ static NTSTATUS fill_in_file_attribute_information(FILE_ATTRIBUTE_TAG_INFORMATIO if (!(ati->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) ati->ReparseTag = 0; else - ati->ReparseTag = get_reparse_tag(fcb->Vcb, fcb->subvol, fcb->inode, fcb->type, fcb->atts, ccb->lxss, Irp); + ati->ReparseTag = get_reparse_tag_fcb(fcb);
return STATUS_SUCCESS; } @@ -3026,7 +3068,7 @@ static NTSTATUS fill_in_file_stream_information(FILE_STREAM_INFORMATION* fsi, fi FILE_STREAM_INFORMATION *entry, *lastentry; NTSTATUS Status;
- static WCHAR datasuf[] = L":$DATA"; + static const WCHAR datasuf[] = L":$DATA"; UNICODE_STRING suf;
if (!fileref) { @@ -3034,8 +3076,8 @@ static NTSTATUS fill_in_file_stream_information(FILE_STREAM_INFORMATION* fsi, fi return STATUS_INVALID_PARAMETER; }
- suf.Buffer = datasuf; - suf.Length = suf.MaximumLength = (UINT16)wcslen(datasuf) * sizeof(WCHAR); + suf.Buffer = (WCHAR*)datasuf; + suf.Length = suf.MaximumLength = sizeof(datasuf) - sizeof(WCHAR);
if (fileref->fcb->type != BTRFS_TYPE_DIRECTORY) reqsize = sizeof(FILE_STREAM_INFORMATION) - sizeof(WCHAR) + suf.Length + sizeof(WCHAR); @@ -3606,6 +3648,80 @@ static NTSTATUS fill_in_file_id_information(FILE_ID_INFORMATION* fii, fcb* fcb, } #endif
+#ifndef __REACTOS__ +static NTSTATUS fill_in_file_stat_lx_information(FILE_STAT_LX_INFORMATION* fsli, fcb* fcb, ccb* ccb, LONG* length) { + INODE_ITEM* ii; + + fsli->FileId.LowPart = (UINT32)fcb->inode; + fsli->FileId.HighPart = (UINT32)fcb->subvol->id; + + if (fcb->ads) + ii = &ccb->fileref->parent->fcb->inode_item; + else + ii = &fcb->inode_item; + + if (fcb == fcb->Vcb->dummy_fcb) { + LARGE_INTEGER time; + + KeQuerySystemTime(&time); + fsli->CreationTime = fsli->LastAccessTime = fsli->LastWriteTime = fsli->ChangeTime = time; + } else { + fsli->CreationTime.QuadPart = unix_time_to_win(&ii->otime); + fsli->LastAccessTime.QuadPart = unix_time_to_win(&ii->st_atime); + fsli->LastWriteTime.QuadPart = unix_time_to_win(&ii->st_mtime); + fsli->ChangeTime.QuadPart = unix_time_to_win(&ii->st_ctime); + } + + if (fcb->ads) { + fsli->AllocationSize.QuadPart = fsli->EndOfFile.QuadPart = fcb->adsdata.Length; + fsli->FileAttributes = ccb->fileref->parent->fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : ccb->fileref->parent->fcb->atts; + } else { + fsli->AllocationSize.QuadPart = fcb_alloc_size(fcb); + fsli->EndOfFile.QuadPart = S_ISDIR(fcb->inode_item.st_mode) ? 0 : fcb->inode_item.st_size; + fsli->FileAttributes = fcb->atts == 0 ? FILE_ATTRIBUTE_NORMAL : fcb->atts; + } + + if (fcb->type == BTRFS_TYPE_SOCKET) + fsli->ReparseTag = IO_REPARSE_TAG_LXSS_SOCKET; + else if (fcb->type == BTRFS_TYPE_FIFO) + fsli->ReparseTag = IO_REPARSE_TAG_LXSS_FIFO; + else if (fcb->type == BTRFS_TYPE_CHARDEV) + fsli->ReparseTag = IO_REPARSE_TAG_LXSS_CHARDEV; + else if (fcb->type == BTRFS_TYPE_BLOCKDEV) + fsli->ReparseTag = IO_REPARSE_TAG_LXSS_BLOCKDEV; + else if (!(fsli->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) + fsli->ReparseTag = 0; + else + fsli->ReparseTag = get_reparse_tag_fcb(fcb); + + if (fcb->type == BTRFS_TYPE_SOCKET || fcb->type == BTRFS_TYPE_FIFO || fcb->type == BTRFS_TYPE_CHARDEV || fcb->type == BTRFS_TYPE_BLOCKDEV) + fsli->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT; + + if (fcb->ads) + fsli->NumberOfLinks = ccb->fileref->parent->fcb->inode_item.st_nlink; + else + fsli->NumberOfLinks = fcb->inode_item.st_nlink; + + fsli->EffectiveAccess = ccb->access; + fsli->LxFlags = LX_FILE_METADATA_HAS_UID | LX_FILE_METADATA_HAS_GID | LX_FILE_METADATA_HAS_MODE | LX_FILE_METADATA_HAS_DEVICE_ID; // FIXME - LX_FILE_CASE_SENSITIVE_DIR + fsli->LxUid = ii->st_uid; + fsli->LxGid = ii->st_gid; + fsli->LxMode = ii->st_mode; + + if (ii->st_mode & __S_IFBLK || ii->st_mode & __S_IFCHR) { + fsli->LxDeviceIdMajor = (ii->st_rdev & 0xFFFFFFFFFFF00000) >> 20; + fsli->LxDeviceIdMinor = (ii->st_rdev & 0xFFFFF); + } else { + fsli->LxDeviceIdMajor = 0; + fsli->LxDeviceIdMinor = 0; + } + + *length -= sizeof(FILE_STAT_LX_INFORMATION); + + return STATUS_SUCCESS; +} +#endif + static NTSTATUS query_info(device_extension* Vcb, PFILE_OBJECT FileObject, PIRP Irp) { PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp); LONG length = IrpSp->Parameters.QueryFile.Length; @@ -3694,7 +3810,7 @@ static NTSTATUS query_info(device_extension* Vcb, PFILE_OBJECT FileObject, PIRP }
ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE); - Status = fill_in_file_attribute_information(ati, fcb, ccb, Irp, &length); + Status = fill_in_file_attribute_information(ati, fcb, ccb, &length); ExReleaseResourceLite(&Vcb->tree_lock);
break; @@ -3893,6 +4009,23 @@ static NTSTATUS query_info(device_extension* Vcb, PFILE_OBJECT FileObject, PIRP
break; } + + case FileStatLxInformation: + { + FILE_STAT_LX_INFORMATION* fsli = Irp->AssociatedIrp.SystemBuffer; + + if (IrpSp->Parameters.QueryFile.Length < sizeof(FILE_STAT_LX_INFORMATION)) { + WARN("overflow\n"); + Status = STATUS_BUFFER_OVERFLOW; + goto exit; + } + + TRACE("FileStatLxInformation\n"); + + Status = fill_in_file_stat_lx_information(fsli, fcb, ccb, &length); + + break; + } #ifndef _MSC_VER #pragma GCC diagnostic pop #endif @@ -4194,13 +4327,6 @@ end: return Status; }
-typedef struct { - ANSI_STRING name; - ANSI_STRING value; - UCHAR flags; - LIST_ENTRY list_entry; -} ea_item; - _Dispatch_type_(IRP_MJ_SET_EA) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { @@ -4386,6 +4512,64 @@ NTSTATUS NTAPI drv_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { le = le2; }
+ // handle LXSS values + le = ealist.Flink; + while (le != &ealist) { + LIST_ENTRY* le2 = le->Flink; + + item = CONTAINING_RECORD(le, ea_item, list_entry); + + if (item->name.Length == sizeof(lxuid) - 1 && RtlCompareMemory(item->name.Buffer, lxuid, item->name.Length) == item->name.Length) { + if (item->value.Length < sizeof(UINT32)) { + ERR("uid value was shorter than expected\n"); + Status = STATUS_INVALID_PARAMETER; + goto end2; + } + + if (Irp->RequestorMode == KernelMode) { + RtlCopyMemory(&fcb->inode_item.st_uid, item->value.Buffer, sizeof(UINT32)); + fcb->sd_dirty = TRUE; + fcb->sd_deleted = FALSE; + } + + RemoveEntryList(&item->list_entry); + ExFreePool(item); + } else if (item->name.Length == sizeof(lxgid) - 1 && RtlCompareMemory(item->name.Buffer, lxgid, item->name.Length) == item->name.Length) { + if (item->value.Length < sizeof(UINT32)) { + ERR("gid value was shorter than expected\n"); + Status = STATUS_INVALID_PARAMETER; + goto end2; + } + + if (Irp->RequestorMode == KernelMode) + RtlCopyMemory(&fcb->inode_item.st_gid, item->value.Buffer, sizeof(UINT32)); + + RemoveEntryList(&item->list_entry); + ExFreePool(item); + } else if (item->name.Length == sizeof(lxmod) - 1 && RtlCompareMemory(item->name.Buffer, lxmod, item->name.Length) == item->name.Length) { + if (item->value.Length < sizeof(UINT32)) { + ERR("mode value was shorter than expected\n"); + Status = STATUS_INVALID_PARAMETER; + goto end2; + } + + if (Irp->RequestorMode == KernelMode) { + UINT32 allowed = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH | S_ISGID | S_ISVTX | S_ISUID; + UINT32 val; + + RtlCopyMemory(&val, item->value.Buffer, sizeof(UINT32)); + + fcb->inode_item.st_mode &= ~allowed; + fcb->inode_item.st_mode |= val & allowed; + } + + RemoveEntryList(&item->list_entry); + ExFreePool(item); + } + + le = le2; + } + if (IsListEmpty(&ealist)) { fcb->ealen = 0;
diff --git a/drivers/filesystems/btrfs/flushthread.c b/drivers/filesystems/btrfs/flushthread.c index 9e95f82834..6353abb583 100644 --- a/drivers/filesystems/btrfs/flushthread.c +++ b/drivers/filesystems/btrfs/flushthread.c @@ -316,14 +316,14 @@ static void clean_space_cache(device_extension* Vcb) { c = CONTAINING_RECORD(le, chunk, list_entry);
if (c->space_changed) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if (c->space_changed) clean_space_cache_chunk(Vcb, c);
c->space_changed = FALSE;
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); }
le = le->Flink; @@ -599,11 +599,11 @@ static BOOL insert_tree_extent_skinny(device_extension* Vcb, UINT8 level, UINT64 return FALSE; }
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
space_list_subtract(c, FALSE, address, Vcb->superblock.node_size, rollback);
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
add_parents_to_cache(insert_tp.tree);
@@ -731,11 +731,11 @@ static BOOL insert_tree_extent(device_extension* Vcb, UINT8 level, UINT64 root_i return FALSE; }
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
space_list_subtract(c, FALSE, address, Vcb->superblock.node_size, rollback);
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
add_parents_to_cache(insert_tp.tree);
@@ -773,11 +773,11 @@ NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENT c = CONTAINING_RECORD(le, chunk, list_entry);
if (!c->readonly && !c->reloc) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if (c != origchunk && c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= Vcb->superblock.node_size) { if (insert_tree_extent(Vcb, t->header.level, t->root->id, c, &addr, Irp, rollback)) { - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); ExReleaseResourceLite(&Vcb->chunk_lock); t->new_address = addr; t->has_new_address = TRUE; @@ -785,7 +785,7 @@ NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENT } }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); }
le = le->Flink; @@ -801,11 +801,11 @@ NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENT return Status; }
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if ((c->chunk_item->size - c->used) >= Vcb->superblock.node_size) { if (insert_tree_extent(Vcb, t->header.level, t->root->id, c, &addr, Irp, rollback)) { - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); ExReleaseResourceLite(&Vcb->chunk_lock); t->new_address = addr; t->has_new_address = TRUE; @@ -813,7 +813,7 @@ NTSTATUS get_tree_new_address(device_extension* Vcb, tree* t, PIRP Irp, LIST_ENT } }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
ExReleaseResourceLite(&Vcb->chunk_lock);
@@ -849,14 +849,14 @@ static NTSTATUS reduce_tree_extent(device_extension* Vcb, UINT64 address, tree* chunk* c = get_chunk_from_address(Vcb, address);
if (c) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if (!c->cache_loaded) { Status = load_cache_chunk(Vcb, c, NULL);
if (!NT_SUCCESS(Status)) { ERR("load_cache_chunk returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); return Status; } } @@ -865,7 +865,7 @@ static NTSTATUS reduce_tree_extent(device_extension* Vcb, UINT64 address, tree*
space_list_add(c, address, Vcb->superblock.node_size, rollback);
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); } else ERR("could not find chunk for address %llx\n", address); } @@ -1351,19 +1351,19 @@ static NTSTATUS allocate_tree_extents(device_extension* Vcb, PIRP Irp, LIST_ENTR
if (c) { if (!c->cache_loaded) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if (!c->cache_loaded) { Status = load_cache_chunk(Vcb, c, NULL);
if (!NT_SUCCESS(Status)) { ERR("load_cache_chunk returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); return Status; } }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); } } } @@ -2644,14 +2644,14 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY* while (le != &Vcb->chunks) { c = CONTAINING_RECORD(le, chunk, list_entry);
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if (!c->cache_loaded && (!IsListEmpty(&c->changed_extents) || c->used != c->oldused)) { Status = load_cache_chunk(Vcb, c, NULL);
if (!NT_SUCCESS(Status)) { ERR("load_cache_chunk returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); goto end; } } @@ -2664,7 +2664,7 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY* Status = flush_changed_extent(Vcb, c, ce, Irp, rollback); if (!NT_SUCCESS(Status)) { ERR("flush_changed_extent returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); goto end; }
@@ -2677,7 +2677,7 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY* Status = create_chunk(Vcb, c, Irp); if (!NT_SUCCESS(Status)) { ERR("create_chunk returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); goto end; } } @@ -2691,7 +2691,7 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY* Status = flush_fcb(c->old_cache, FALSE, &batchlist, Irp); if (!NT_SUCCESS(Status)) { ERR("flush_fcb returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); clear_batch_list(Vcb, &batchlist); goto end; } @@ -2699,7 +2699,7 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY* Status = commit_batch_list(Vcb, &batchlist, Irp); if (!NT_SUCCESS(Status)) { ERR("commit_batch_list returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); goto end; } } @@ -2716,21 +2716,21 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY* Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, FALSE, Irp); if (!NT_SUCCESS(Status)) { ERR("error - find_item returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); goto end; }
if (keycmp(searchkey, tp.item->key)) { ERR("could not find (%llx,%x,%llx) in extent_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset); Status = STATUS_INTERNAL_ERROR; - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); goto end; }
if (tp.item->size < sizeof(BLOCK_GROUP_ITEM)) { ERR("(%llx,%x,%llx) was %u bytes, expected %u\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(BLOCK_GROUP_ITEM)); Status = STATUS_INTERNAL_ERROR; - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); goto end; }
@@ -2738,7 +2738,7 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY* if (!bgi) { ERR("out of memory\n"); Status = STATUS_INSUFFICIENT_RESOURCES; - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); goto end; }
@@ -2751,7 +2751,7 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY* if (!NT_SUCCESS(Status)) { ERR("delete_tree_item returned %08x\n", Status); ExFreePool(bgi); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); goto end; }
@@ -2759,7 +2759,7 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY* if (!NT_SUCCESS(Status)) { ERR("insert_tree_item returned %08x\n", Status); ExFreePool(bgi); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); goto end; }
@@ -2772,7 +2772,7 @@ static NTSTATUS update_chunk_usage(device_extension* Vcb, PIRP Irp, LIST_ENTRY* c->oldused = c->used; }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
le = le->Flink; } @@ -4414,14 +4414,14 @@ cont: if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) add_checksum_entry(fcb->Vcb, er->address, (ULONG)(er->skip_start / fcb->Vcb->superblock.sector_size), NULL, NULL);
- ExAcquireResourceExclusiveLite(&er->chunk->lock, TRUE); + acquire_chunk_lock(er->chunk, fcb->Vcb);
if (!er->chunk->cache_loaded) { NTSTATUS Status = load_cache_chunk(fcb->Vcb, er->chunk, NULL);
if (!NT_SUCCESS(Status)) { ERR("load_cache_chunk returned %08x\n", Status); - ExReleaseResourceLite(&er->chunk->lock); + release_chunk_lock(er->chunk, fcb->Vcb); goto end; } } @@ -4430,7 +4430,7 @@ cont:
space_list_add(er->chunk, er->address, er->skip_start, NULL);
- ExReleaseResourceLite(&er->chunk->lock); + release_chunk_lock(er->chunk, fcb->Vcb);
er->address += er->skip_start; er->length -= er->skip_start; @@ -4468,14 +4468,14 @@ cont: if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) add_checksum_entry(fcb->Vcb, er->address + er->length - er->skip_end, (ULONG)(er->skip_end / fcb->Vcb->superblock.sector_size), NULL, NULL);
- ExAcquireResourceExclusiveLite(&er->chunk->lock, TRUE); + acquire_chunk_lock(er->chunk, fcb->Vcb);
if (!er->chunk->cache_loaded) { NTSTATUS Status = load_cache_chunk(fcb->Vcb, er->chunk, NULL);
if (!NT_SUCCESS(Status)) { ERR("load_cache_chunk returned %08x\n", Status); - ExReleaseResourceLite(&er->chunk->lock); + release_chunk_lock(er->chunk, fcb->Vcb); goto end; } } @@ -4484,7 +4484,7 @@ cont:
space_list_add(er->chunk, er->address + er->length - er->skip_end, er->skip_end, NULL);
- ExReleaseResourceLite(&er->chunk->lock); + release_chunk_lock(er->chunk, fcb->Vcb);
er->length -= er->skip_end; } @@ -4924,14 +4924,14 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
if (fcb->sd_dirty) { if (!fcb->sd_deleted) { - Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_NTACL, (UINT16)strlen(EA_NTACL), + Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_NTACL, sizeof(EA_NTACL) - 1, EA_NTACL_HASH, (UINT8*)fcb->sd, (UINT16)RtlLengthSecurityDescriptor(fcb->sd)); if (!NT_SUCCESS(Status)) { ERR("set_xattr returned %08x\n", Status); goto end; } } else { - Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_NTACL, (UINT16)strlen(EA_NTACL), EA_NTACL_HASH); + Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_NTACL, sizeof(EA_NTACL) - 1, EA_NTACL_HASH); if (!NT_SUCCESS(Status)) { ERR("delete_xattr returned %08x\n", Status); goto end; @@ -4966,14 +4966,14 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) { val2--; *val2 = '0';
- Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_DOSATTRIB, (UINT16)strlen(EA_DOSATTRIB), + Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_DOSATTRIB, sizeof(EA_DOSATTRIB) - 1, EA_DOSATTRIB_HASH, val2, (UINT16)(val + sizeof(val) - val2)); if (!NT_SUCCESS(Status)) { ERR("set_xattr returned %08x\n", Status); goto end; } } else { - Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_DOSATTRIB, (UINT16)strlen(EA_DOSATTRIB), EA_DOSATTRIB_HASH); + Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_DOSATTRIB, sizeof(EA_DOSATTRIB) - 1, EA_DOSATTRIB_HASH); if (!NT_SUCCESS(Status)) { ERR("delete_xattr returned %08x\n", Status); goto end; @@ -4986,14 +4986,14 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
if (fcb->reparse_xattr_changed) { if (fcb->reparse_xattr.Buffer && fcb->reparse_xattr.Length > 0) { - Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_REPARSE, (UINT16)strlen(EA_REPARSE), + Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_REPARSE, sizeof(EA_REPARSE) - 1, EA_REPARSE_HASH, (UINT8*)fcb->reparse_xattr.Buffer, (UINT16)fcb->reparse_xattr.Length); if (!NT_SUCCESS(Status)) { ERR("set_xattr returned %08x\n", Status); goto end; } } else { - Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_REPARSE, (UINT16)strlen(EA_REPARSE), EA_REPARSE_HASH); + Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_REPARSE, sizeof(EA_REPARSE) - 1, EA_REPARSE_HASH); if (!NT_SUCCESS(Status)) { ERR("delete_xattr returned %08x\n", Status); goto end; @@ -5005,14 +5005,14 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
if (fcb->ea_changed) { if (fcb->ea_xattr.Buffer && fcb->ea_xattr.Length > 0) { - Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_EA, (UINT16)strlen(EA_EA), + Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_EA, sizeof(EA_EA) - 1, EA_EA_HASH, (UINT8*)fcb->ea_xattr.Buffer, (UINT16)fcb->ea_xattr.Length); if (!NT_SUCCESS(Status)) { ERR("set_xattr returned %08x\n", Status); goto end; } } else { - Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_EA, (UINT16)strlen(EA_EA), EA_EA_HASH); + Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_EA, sizeof(EA_EA) - 1, EA_EA_HASH); if (!NT_SUCCESS(Status)) { ERR("delete_xattr returned %08x\n", Status); goto end; @@ -5024,25 +5024,34 @@ NTSTATUS flush_fcb(fcb* fcb, BOOL cache, LIST_ENTRY* batchlist, PIRP Irp) {
if (fcb->prop_compression_changed) { if (fcb->prop_compression == PropCompression_None) { - Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_PROP_COMPRESSION, (UINT16)strlen(EA_PROP_COMPRESSION), EA_PROP_COMPRESSION_HASH); + Status = delete_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_PROP_COMPRESSION, sizeof(EA_PROP_COMPRESSION) - 1, EA_PROP_COMPRESSION_HASH); if (!NT_SUCCESS(Status)) { ERR("delete_xattr returned %08x\n", Status); goto end; } } else if (fcb->prop_compression == PropCompression_Zlib) { - const char zlib[] = "zlib"; + static const char zlib[] = "zlib";
- Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_PROP_COMPRESSION, (UINT16)strlen(EA_PROP_COMPRESSION), - EA_PROP_COMPRESSION_HASH, (UINT8*)zlib, (UINT16)strlen(zlib)); + Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_PROP_COMPRESSION, sizeof(EA_PROP_COMPRESSION) - 1, + EA_PROP_COMPRESSION_HASH, (UINT8*)zlib, sizeof(zlib) - 1); if (!NT_SUCCESS(Status)) { ERR("set_xattr returned %08x\n", Status); goto end; } } else if (fcb->prop_compression == PropCompression_LZO) { - const char lzo[] = "lzo"; + static const char lzo[] = "lzo";
- Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_PROP_COMPRESSION, (UINT16)strlen(EA_PROP_COMPRESSION), - EA_PROP_COMPRESSION_HASH, (UINT8*)lzo, (UINT16)strlen(lzo)); + Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_PROP_COMPRESSION, sizeof(EA_PROP_COMPRESSION) - 1, + EA_PROP_COMPRESSION_HASH, (UINT8*)lzo, sizeof(lzo) - 1); + if (!NT_SUCCESS(Status)) { + ERR("set_xattr returned %08x\n", Status); + goto end; + } + } else if (fcb->prop_compression == PropCompression_ZSTD) { + static const char zstd[] = "zstd"; + + Status = set_xattr(fcb->Vcb, batchlist, fcb->subvol, fcb->inode, EA_PROP_COMPRESSION, sizeof(EA_PROP_COMPRESSION) - 1, + EA_PROP_COMPRESSION_HASH, (UINT8*)zstd, sizeof(zstd) - 1); if (!NT_SUCCESS(Status)) { ERR("set_xattr returned %08x\n", Status); goto end; @@ -5282,29 +5291,26 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis return Status; }
- if (keycmp(tp.item->key, searchkey)) { - ERR("error - could not find DEV_ITEM for device %llx\n", searchkey.offset); - return STATUS_INTERNAL_ERROR; - } - - Status = delete_tree_item(Vcb, &tp); - if (!NT_SUCCESS(Status)) { - ERR("delete_tree_item returned %08x\n", Status); - return Status; - } + if (!keycmp(tp.item->key, searchkey)) { + Status = delete_tree_item(Vcb, &tp); + if (!NT_SUCCESS(Status)) { + ERR("delete_tree_item returned %08x\n", Status); + return Status; + }
- di = ExAllocatePoolWithTag(PagedPool, sizeof(DEV_ITEM), ALLOC_TAG); - if (!di) { - ERR("out of memory\n"); - return STATUS_INSUFFICIENT_RESOURCES; - } + di = ExAllocatePoolWithTag(PagedPool, sizeof(DEV_ITEM), ALLOC_TAG); + if (!di) { + ERR("out of memory\n"); + return STATUS_INSUFFICIENT_RESOURCES; + }
- RtlCopyMemory(di, &c->devices[i]->devitem, sizeof(DEV_ITEM)); + RtlCopyMemory(di, &c->devices[i]->devitem, sizeof(DEV_ITEM));
- Status = insert_tree_item(Vcb, Vcb->chunk_root, 1, TYPE_DEV_ITEM, c->devices[i]->devitem.dev_id, di, sizeof(DEV_ITEM), NULL, Irp); - if (!NT_SUCCESS(Status)) { - ERR("insert_tree_item returned %08x\n", Status); - return Status; + Status = insert_tree_item(Vcb, Vcb->chunk_root, 1, TYPE_DEV_ITEM, c->devices[i]->devitem.dev_id, di, sizeof(DEV_ITEM), NULL, Irp); + if (!NT_SUCCESS(Status)) { + ERR("insert_tree_item returned %08x\n", Status); + return Status; + } }
for (j = i + 1; j < c->chunk_item->num_stripes; j++) { @@ -5404,6 +5410,8 @@ static NTSTATUS drop_chunk(device_extension* Vcb, chunk* c, LIST_ENTRY* batchlis ExFreePool(s); }
+ release_chunk_lock(c, Vcb); + ExDeleteResourceLite(&c->partial_stripes_lock); ExDeleteResourceLite(&c->range_locks_lock); ExDeleteResourceLite(&c->lock); @@ -5718,7 +5726,7 @@ static NTSTATUS update_chunks(device_extension* Vcb, LIST_ENTRY* batchlist, PIRP le2 = le->Flink;
if (c->changed) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
// flush partial stripes if (!Vcb->readonly && (c->chunk_item->type & BLOCK_FLAG_RAID5 || c->chunk_item->type & BLOCK_FLAG_RAID6)) { @@ -5737,7 +5745,7 @@ static NTSTATUS update_chunks(device_extension* Vcb, LIST_ENTRY* batchlist, PIRP if (!NT_SUCCESS(Status)) { ERR("flush_partial_stripe returned %08x\n", Status); ExReleaseResourceLite(&c->partial_stripes_lock); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); ExReleaseResourceLite(&Vcb->chunk_lock); return Status; } @@ -5747,12 +5755,14 @@ static NTSTATUS update_chunks(device_extension* Vcb, LIST_ENTRY* batchlist, PIRP }
if (c->list_entry_balance.Flink) { - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); le = le2; continue; }
if (c->space_changed || c->created) { + BOOL created = c->created; + used_minus_cache = c->used;
// subtract self-hosted cache @@ -5781,23 +5791,28 @@ static NTSTATUS update_chunks(device_extension* Vcb, LIST_ENTRY* batchlist, PIRP Status = drop_chunk(Vcb, c, batchlist, Irp, rollback); if (!NT_SUCCESS(Status)) { ERR("drop_chunk returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); ExReleaseResourceLite(&Vcb->chunk_lock); return Status; } + + // c is now freed, so avoid releasing non-existent lock + le = le2; + continue; } else if (c->created) { Status = create_chunk(Vcb, c, Irp); if (!NT_SUCCESS(Status)) { ERR("create_chunk returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); ExReleaseResourceLite(&Vcb->chunk_lock); return Status; } }
- if (used_minus_cache > 0) - ExReleaseResourceLite(&c->lock); - } + if (used_minus_cache > 0 || created) + release_chunk_lock(c, Vcb); + } else + release_chunk_lock(c, Vcb); }
le = le2; diff --git a/drivers/filesystems/btrfs/free-space.c b/drivers/filesystems/btrfs/free-space.c index 1ed2da9361..f6248e9038 100644 --- a/drivers/filesystems/btrfs/free-space.c +++ b/drivers/filesystems/btrfs/free-space.c @@ -161,12 +161,12 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
if (!c->cache_loaded) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
Status = load_cache_chunk(Vcb, c, NULL); if (!NT_SUCCESS(Status)) { ERR("load_cache_chunk(%llx) returned %08x\n", c->offset, Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); ExReleaseResourceLite(&Vcb->chunk_lock); return Status; } @@ -174,7 +174,7 @@ NTSTATUS clear_free_space_cache(device_extension* Vcb, LIST_ENTRY* batchlist, PI c->changed = TRUE; c->space_changed = TRUE;
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); }
le = le->Flink; @@ -975,14 +975,14 @@ static NTSTATUS insert_cache_extent(fcb* fcb, UINT64 start, UINT64 length, LIST_ c = CONTAINING_RECORD(le, chunk, list_entry);
if (!c->readonly && !c->reloc) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= length) { if (insert_extent_chunk(fcb->Vcb, fcb, c, start, length, FALSE, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, length, FALSE, 0)) return STATUS_SUCCESS; }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, fcb->Vcb); }
le = le->Flink; @@ -995,14 +995,14 @@ static NTSTATUS insert_cache_extent(fcb* fcb, UINT64 start, UINT64 length, LIST_ return Status; }
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= length) { if (insert_extent_chunk(fcb->Vcb, fcb, c, start, length, FALSE, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, length, FALSE, 0)) return STATUS_SUCCESS; }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, fcb->Vcb);
return STATUS_DISK_FULL; } @@ -1360,9 +1360,9 @@ NTSTATUS allocate_cache(device_extension* Vcb, BOOL* changed, PIRP Irp, LIST_ENT if (c->space_changed) { BOOL b;
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb); Status = allocate_cache_chunk(Vcb, c, &b, &batchlist, Irp, rollback); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
if (b) *changed = TRUE; @@ -1828,9 +1828,9 @@ NTSTATUS update_chunk_caches(device_extension* Vcb, PIRP Irp, LIST_ENTRY* rollba c = CONTAINING_RECORD(le, chunk, list_entry);
if (c->space_changed) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb); Status = update_chunk_cache(Vcb, c, &now, &batchlist, Irp, rollback); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
if (!NT_SUCCESS(Status)) { ERR("update_chunk_cache(%llx) returned %08x\n", c->offset, Status); @@ -1897,9 +1897,9 @@ NTSTATUS update_chunk_caches_tree(device_extension* Vcb, PIRP Irp) { c = CONTAINING_RECORD(le, chunk, list_entry);
if (c->space_changed) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb); Status = update_chunk_cache_tree(Vcb, c, &batchlist); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
if (!NT_SUCCESS(Status)) { ERR("update_chunk_cache_tree(%llx) returned %08x\n", c->offset, Status); diff --git a/drivers/filesystems/btrfs/fsctl.c b/drivers/filesystems/btrfs/fsctl.c index 6cc0f45ab1..3b13e89766 100644 --- a/drivers/filesystems/btrfs/fsctl.c +++ b/drivers/filesystems/btrfs/fsctl.c @@ -1024,7 +1024,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo
// add INODE_REF
- irsize = (UINT16)(offsetof(INODE_REF, name[0]) + strlen(DOTDOT)); + irsize = (UINT16)(offsetof(INODE_REF, name[0]) + sizeof(DOTDOT) - 1); ir = ExAllocatePoolWithTag(PagedPool, irsize, ALLOC_TAG); if (!ir) { ERR("out of memory\n"); @@ -1033,7 +1033,7 @@ static NTSTATUS create_subvol(device_extension* Vcb, PFILE_OBJECT FileObject, vo }
ir->index = 0; - ir->n = (USHORT)strlen(DOTDOT); + ir->n = sizeof(DOTDOT) - 1; RtlCopyMemory(ir->name, DOTDOT, ir->n);
Status = insert_tree_item(Vcb, r, r->root_item.objid, TYPE_INODE_REF, r->root_item.objid, ir, irsize, NULL, Irp); @@ -1164,9 +1164,10 @@ end2: }
static NTSTATUS get_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length) { - btrfs_inode_info* bii = data; + btrfs_inode_info2* bii = data; fcb* fcb; ccb* ccb; + BOOL old_style;
if (length < sizeof(btrfs_inode_info)) return STATUS_BUFFER_OVERFLOW; @@ -1192,6 +1193,8 @@ static NTSTATUS get_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length if (fcb->ads) fcb = ccb->fileref->parent->fcb;
+ old_style = length < sizeof(btrfs_inode_info2); + ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
bii->subvol = fcb->subvol->id; @@ -1210,52 +1213,84 @@ static NTSTATUS get_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length bii->flags = fcb->inode_item.flags;
bii->inline_length = 0; - bii->disk_size[0] = 0; - bii->disk_size[1] = 0; - bii->disk_size[2] = 0; + bii->disk_size_uncompressed = 0; + bii->disk_size_zlib = 0; + bii->disk_size_lzo = 0; + + if (!old_style) { + bii->disk_size_zstd = 0; + bii->sparse_size = 0; + }
if (fcb->type != BTRFS_TYPE_DIRECTORY) { + UINT64 last_end = 0; LIST_ENTRY* le; + BOOL extents_inline = FALSE;
le = fcb->extents.Flink; while (le != &fcb->extents) { extent* ext = CONTAINING_RECORD(le, extent, list_entry);
if (!ext->ignore) { + if (!old_style && ext->offset > last_end) + bii->sparse_size += ext->offset - last_end; + if (ext->extent_data.type == EXTENT_TYPE_INLINE) { bii->inline_length += ext->datalen - (UINT16)offsetof(EXTENT_DATA, data[0]); + last_end = ext->offset + ext->extent_data.decoded_size; + extents_inline = TRUE; } else { EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ext->extent_data.data;
// FIXME - compressed extents with a hole in them are counted more than once if (ed2->size != 0) { - if (ext->extent_data.compression == BTRFS_COMPRESSION_NONE) { - bii->disk_size[0] += ed2->num_bytes; - } else if (ext->extent_data.compression == BTRFS_COMPRESSION_ZLIB) { - bii->disk_size[1] += ed2->size; - } else if (ext->extent_data.compression == BTRFS_COMPRESSION_LZO) { - bii->disk_size[2] += ed2->size; + switch (ext->extent_data.compression) { + case BTRFS_COMPRESSION_NONE: + bii->disk_size_uncompressed += ed2->num_bytes; + break; + + case BTRFS_COMPRESSION_ZLIB: + bii->disk_size_zlib += ed2->size; + break; + + case BTRFS_COMPRESSION_LZO: + bii->disk_size_lzo += ed2->size; + break; + + case BTRFS_COMPRESSION_ZSTD: + if (!old_style) + bii->disk_size_zstd += ed2->size; + break; } } + + last_end = ext->offset + ed2->num_bytes; } }
le = le->Flink; } + + if (!extents_inline && !old_style && sector_align(fcb->inode_item.st_size, fcb->Vcb->superblock.sector_size) > last_end) + bii->sparse_size += sector_align(fcb->inode_item.st_size, fcb->Vcb->superblock.sector_size) - last_end; }
switch (fcb->prop_compression) { case PropCompression_Zlib: bii->compression_type = BTRFS_COMPRESSION_ZLIB; - break; + break;
case PropCompression_LZO: bii->compression_type = BTRFS_COMPRESSION_LZO; - break; + break; + + case PropCompression_ZSTD: + bii->compression_type = BTRFS_COMPRESSION_ZSTD; + break;
default: bii->compression_type = BTRFS_COMPRESSION_ANY; - break; + break; }
ExReleaseResourceLite(fcb->Header.Resource); @@ -1295,7 +1330,7 @@ static NTSTATUS set_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length return STATUS_ACCESS_DENIED; }
- if (bsii->compression_type_changed && bsii->compression_type > BTRFS_COMPRESSION_LZO) + if (bsii->compression_type_changed && bsii->compression_type > BTRFS_COMPRESSION_ZSTD) return STATUS_INVALID_PARAMETER;
if (fcb->ads) @@ -1358,6 +1393,10 @@ static NTSTATUS set_inode_info(PFILE_OBJECT FileObject, void* data, ULONG length case BTRFS_COMPRESSION_LZO: fcb->prop_compression = PropCompression_LZO; break; + + case BTRFS_COMPRESSION_ZSTD: + fcb->prop_compression = PropCompression_ZSTD; + break; }
fcb->prop_compression_changed = TRUE; @@ -2351,10 +2390,6 @@ static NTSTATUS invalidate_volumes(PIRP Irp) {
RtlZeroMemory(newvpb, sizeof(VPB));
- IoAcquireVpbSpinLock(&irql); - devobj->Vpb->Flags &= ~VPB_MOUNTED; - IoReleaseVpbSpinLock(irql); - ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
Vcb->removing = TRUE; @@ -2403,7 +2438,7 @@ static NTSTATUS invalidate_volumes(PIRP Irp) { ExFreePool(newvpb);
if (Vcb->open_files == 0) - uninit(Vcb, FALSE); + uninit(Vcb); }
break; @@ -2517,7 +2552,6 @@ static void update_volumes(device_extension* Vcb) {
static NTSTATUS dismount_volume(device_extension* Vcb, PIRP Irp) { NTSTATUS Status; - KIRQL irql;
TRACE("FSCTL_DISMOUNT_VOLUME\n");
@@ -2558,11 +2592,6 @@ static NTSTATUS dismount_volume(device_extension* Vcb, PIRP Irp) {
ExReleaseResourceLite(&Vcb->tree_lock);
- IoAcquireVpbSpinLock(&irql); - Vcb->Vpb->Flags &= ~VPB_MOUNTED; - Vcb->Vpb->Flags |= VPB_DIRECT_WRITES_ALLOWED; - IoReleaseVpbSpinLock(irql); - return STATUS_SUCCESS; }
@@ -3631,10 +3660,6 @@ end: return Status; }
-// based on functions in sys/sysmacros.h -#define major(rdev) ((((rdev) >> 8) & 0xFFF) | ((UINT32)((rdev) >> 32) & ~0xFFF)) -#define minor(rdev) (((rdev) & 0xFF) | ((UINT32)((rdev) >> 12) & ~0xFF)) - static NTSTATUS mknod(device_extension* Vcb, PFILE_OBJECT FileObject, void* data, ULONG datalen, PIRP Irp) { NTSTATUS Status; btrfs_mknod* bmn; @@ -4161,7 +4186,7 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
- if (bsxa->namelen == strlen(EA_NTACL) && RtlCompareMemory(bsxa->data, EA_NTACL, strlen(EA_NTACL)) == strlen(EA_NTACL)) { + if (bsxa->namelen == sizeof(EA_NTACL) - 1 && RtlCompareMemory(bsxa->data, EA_NTACL, sizeof(EA_NTACL) - 1) == sizeof(EA_NTACL) - 1) { if ((!(ccb->access & WRITE_DAC) || !(ccb->access & WRITE_OWNER)) && Irp->RequestorMode == UserMode) { WARN("insufficient privileges\n"); Status = STATUS_ACCESS_DENIED; @@ -4199,7 +4224,7 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
Status = STATUS_SUCCESS; goto end; - } else if (bsxa->namelen == strlen(EA_DOSATTRIB) && RtlCompareMemory(bsxa->data, EA_DOSATTRIB, strlen(EA_DOSATTRIB)) == strlen(EA_DOSATTRIB)) { + } else if (bsxa->namelen == sizeof(EA_DOSATTRIB) - 1 && RtlCompareMemory(bsxa->data, EA_DOSATTRIB, sizeof(EA_DOSATTRIB) - 1) == sizeof(EA_DOSATTRIB) - 1) { ULONG atts;
if (bsxa->valuelen > 0 && get_file_attributes_from_xattr(bsxa->data + bsxa->namelen, bsxa->valuelen, &atts)) { @@ -4230,7 +4255,7 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
Status = STATUS_SUCCESS; goto end; - } else if (bsxa->namelen == strlen(EA_REPARSE) && RtlCompareMemory(bsxa->data, EA_REPARSE, strlen(EA_REPARSE)) == strlen(EA_REPARSE)) { + } else if (bsxa->namelen == sizeof(EA_REPARSE) - 1 && RtlCompareMemory(bsxa->data, EA_REPARSE, sizeof(EA_REPARSE) - 1) == sizeof(EA_REPARSE) - 1) { if (fcb->reparse_xattr.Buffer) { ExFreePool(fcb->reparse_xattr.Buffer); fcb->reparse_xattr.Buffer = NULL; @@ -4254,7 +4279,7 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
Status = STATUS_SUCCESS; goto end; - } else if (bsxa->namelen == strlen(EA_EA) && RtlCompareMemory(bsxa->data, EA_EA, strlen(EA_EA)) == strlen(EA_EA)) { + } else if (bsxa->namelen == sizeof(EA_EA) - 1 && RtlCompareMemory(bsxa->data, EA_EA, sizeof(EA_EA) - 1) == sizeof(EA_EA) - 1) { if (!(ccb->access & FILE_WRITE_EA) && Irp->RequestorMode == UserMode) { WARN("insufficient privileges\n"); Status = STATUS_ACCESS_DENIED; @@ -4310,13 +4335,16 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
Status = STATUS_SUCCESS; goto end; - } else if (bsxa->namelen == strlen(EA_PROP_COMPRESSION) && RtlCompareMemory(bsxa->data, EA_PROP_COMPRESSION, strlen(EA_PROP_COMPRESSION)) == strlen(EA_PROP_COMPRESSION)) { - const char lzo[] = "lzo"; - const char zlib[] = "zlib"; - - if (bsxa->valuelen == strlen(lzo) && RtlCompareMemory(bsxa->data + bsxa->namelen, lzo, bsxa->valuelen) == bsxa->valuelen) + } else if (bsxa->namelen == sizeof(EA_PROP_COMPRESSION) - 1 && RtlCompareMemory(bsxa->data, EA_PROP_COMPRESSION, sizeof(EA_PROP_COMPRESSION) - 1) == sizeof(EA_PROP_COMPRESSION) - 1) { + static const char lzo[] = "lzo"; + static const char zlib[] = "zlib"; + static const char zstd[] = "zstd"; + + if (bsxa->valuelen == sizeof(zstd) - 1 && RtlCompareMemory(bsxa->data + bsxa->namelen, zstd, bsxa->valuelen) == bsxa->valuelen) + fcb->prop_compression = PropCompression_ZSTD; + else if (bsxa->valuelen == sizeof(lzo) - 1 && RtlCompareMemory(bsxa->data + bsxa->namelen, lzo, bsxa->valuelen) == bsxa->valuelen) fcb->prop_compression = PropCompression_LZO; - else if (bsxa->valuelen == strlen(zlib) && RtlCompareMemory(bsxa->data + bsxa->namelen, zlib, bsxa->valuelen) == bsxa->valuelen) + else if (bsxa->valuelen == sizeof(zlib) - 1 && RtlCompareMemory(bsxa->data + bsxa->namelen, zlib, bsxa->valuelen) == bsxa->valuelen) fcb->prop_compression = PropCompression_Zlib; else fcb->prop_compression = PropCompression_None; @@ -4331,7 +4359,7 @@ static NTSTATUS fsctl_set_xattr(device_extension* Vcb, PFILE_OBJECT FileObject,
Status = STATUS_SUCCESS; goto end; - } else if (bsxa->namelen >= strlen(stream_pref) && RtlCompareMemory(bsxa->data, stream_pref, strlen(stream_pref)) == strlen(stream_pref)) { + } else if (bsxa->namelen >= (sizeof(stream_pref) - 1) && RtlCompareMemory(bsxa->data, stream_pref, sizeof(stream_pref) - 1) == sizeof(stream_pref) - 1) { // don't allow xattrs beginning with user., as these appear as streams instead Status = STATUS_OBJECT_NAME_INVALID; goto end; diff --git a/drivers/filesystems/btrfs/pnp.c b/drivers/filesystems/btrfs/pnp.c index 5a7e91b410..fbb535f070 100644 --- a/drivers/filesystems/btrfs/pnp.c +++ b/drivers/filesystems/btrfs/pnp.c @@ -247,12 +247,10 @@ static NTSTATUS pnp_remove_device(PDEVICE_OBJECT DeviceObject) {
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE); Vcb->removing = TRUE; - Vcb->Vpb->Flags &= ~VPB_MOUNTED; - Vcb->Vpb->Flags |= VPB_DIRECT_WRITES_ALLOWED; ExReleaseResourceLite(&Vcb->tree_lock);
if (Vcb->open_files == 0) - uninit(Vcb, FALSE); + uninit(Vcb); }
return STATUS_SUCCESS; @@ -270,13 +268,11 @@ NTSTATUS pnp_surprise_removal(PDEVICE_OBJECT DeviceObject, PIRP Irp) { Vcb->vde->mounted_device = NULL;
Vcb->removing = TRUE; - Vcb->Vpb->Flags &= ~VPB_MOUNTED; - Vcb->Vpb->Flags |= VPB_DIRECT_WRITES_ALLOWED;
ExReleaseResourceLite(&Vcb->tree_lock);
if (Vcb->open_files == 0) - uninit(Vcb, FALSE); + uninit(Vcb); }
return STATUS_SUCCESS; @@ -349,7 +345,7 @@ end: static NTSTATUS bus_query_hardware_ids(PIRP Irp) { WCHAR* out;
- static WCHAR ids[] = L"ROOT\btrfs\0"; + static const WCHAR ids[] = L"ROOT\btrfs\0";
out = ExAllocatePoolWithTag(PagedPool, sizeof(ids), ALLOC_TAG); if (!out) { @@ -402,11 +398,11 @@ static NTSTATUS pdo_query_device_id(pdo_device_extension* pdode, PIRP Irp) { WCHAR name[100], *noff, *out; int i;
- static WCHAR pref[] = L"Btrfs\"; + static const WCHAR pref[] = L"Btrfs\";
- RtlCopyMemory(name, pref, wcslen(pref) * sizeof(WCHAR)); + RtlCopyMemory(name, pref, sizeof(pref) - sizeof(WCHAR));
- noff = &name[wcslen(pref)]; + noff = &name[(sizeof(pref) / sizeof(WCHAR)) - 1]; for (i = 0; i < 16; i++) { *noff = hex_digit(pdode->uuid.uuid[i] >> 4); noff++; *noff = hex_digit(pdode->uuid.uuid[i] & 0xf); noff++; @@ -434,7 +430,7 @@ static NTSTATUS pdo_query_device_id(pdo_device_extension* pdode, PIRP Irp) { static NTSTATUS pdo_query_hardware_ids(PIRP Irp) { WCHAR* out;
- static WCHAR ids[] = L"BtrfsVolume\0"; + static const WCHAR ids[] = L"BtrfsVolume\0";
out = ExAllocatePoolWithTag(PagedPool, sizeof(ids), ALLOC_TAG); if (!out) { diff --git a/drivers/filesystems/btrfs/read.c b/drivers/filesystems/btrfs/read.c index 4384d65784..2eb19b1a80 100644 --- a/drivers/filesystems/btrfs/read.c +++ b/drivers/filesystems/btrfs/read.c @@ -1645,6 +1645,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
if (!context.stripes[i].mdl) { ERR("IoAllocateMdl failed\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -1654,6 +1656,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(UINT32) * ci->num_stripes, ALLOC_TAG); if (!stripeoff) { ERR("out of memory\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -1760,6 +1764,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len stripes = ExAllocatePoolWithTag(NonPagedPool, sizeof(read_data_stripe*) * ci->num_stripes / ci->sub_stripes, ALLOC_TAG); if (!stripes) { ERR("out of memory\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -1795,6 +1801,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
if (!context.stripes[i+j].mdl) { ERR("IoAllocateMdl failed\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -1818,6 +1826,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
if (!context.stripes[i+j].mdl) { ERR("IoAllocateMdl failed\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -1839,6 +1849,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(UINT32) * ci->num_stripes / ci->sub_stripes, ALLOC_TAG); if (!stripeoff) { ERR("out of memory\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -2075,6 +2087,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
if (!context.stripes[i].mdl) { ERR("IoAllocateMdl failed\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -2085,6 +2099,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len dummypage = ExAllocatePoolWithTag(NonPagedPool, PAGE_SIZE, ALLOC_TAG); if (!dummypage) { ERR("out of memory\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -2092,6 +2108,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len dummy_mdl = IoAllocateMdl(dummypage, PAGE_SIZE, FALSE, FALSE, NULL); if (!dummy_mdl) { ERR("IoAllocateMdl failed\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -2104,6 +2122,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(UINT32) * ci->num_stripes, ALLOC_TAG); if (!stripeoff) { ERR("out of memory\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -2328,6 +2348,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len
if (!context.stripes[i].mdl) { ERR("IoAllocateMdl failed\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -2338,6 +2360,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len dummypage = ExAllocatePoolWithTag(NonPagedPool, PAGE_SIZE, ALLOC_TAG); if (!dummypage) { ERR("out of memory\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -2345,6 +2369,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len dummy_mdl = IoAllocateMdl(dummypage, PAGE_SIZE, FALSE, FALSE, NULL); if (!dummy_mdl) { ERR("IoAllocateMdl failed\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -2357,6 +2383,8 @@ NTSTATUS read_data(_In_ device_extension* Vcb, _In_ UINT64 addr, _In_ UINT32 len stripeoff = ExAllocatePoolWithTag(NonPagedPool, sizeof(UINT32) * ci->num_stripes, ALLOC_TAG); if (!stripeoff) { ERR("out of memory\n"); + MmUnlockPages(master_mdl); + IoFreeMdl(master_mdl); Status = STATUS_INSUFFICIENT_RESOURCES; goto exit; } @@ -2785,7 +2813,7 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb read = (UINT32)min(min(len, ext->datalen) - off, length);
RtlCopyMemory(data + bytes_read, &ed->data[off], read); - } else if (ed->compression == BTRFS_COMPRESSION_ZLIB || ed->compression == BTRFS_COMPRESSION_LZO) { + } else if (ed->compression == BTRFS_COMPRESSION_ZLIB || ed->compression == BTRFS_COMPRESSION_LZO || ed->compression == BTRFS_COMPRESSION_ZSTD) { UINT8* decomp; BOOL decomp_alloc; UINT16 inlen = ext->datalen - (UINT16)offsetof(EXTENT_DATA, data[0]); @@ -2834,6 +2862,13 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb if (decomp_alloc) ExFreePool(decomp); goto exit; } + } else if (ed->compression == BTRFS_COMPRESSION_ZSTD) { + Status = zstd_decompress(ed->data, inlen, decomp, (UINT32)(read + off)); + if (!NT_SUCCESS(Status)) { + ERR("zstd_decompress returned %08x\n", Status); + if (decomp_alloc) ExFreePool(decomp); + goto exit; + } }
if (decomp_alloc) { @@ -3000,6 +3035,18 @@ NTSTATUS read_file(fcb* fcb, UINT8* data, UINT64 start, UINT64 length, ULONG* pb ERR("lzo_decompress returned %08x\n", Status); ExFreePool(buf);
+ if (decomp) + ExFreePool(decomp); + + goto exit; + } + } else if (ed->compression == BTRFS_COMPRESSION_ZSTD) { + Status = zstd_decompress(buf2, inlen, decomp ? decomp : (data + bytes_read), outlen); + + if (!NT_SUCCESS(Status)) { + ERR("zstd_decompress returned %08x\n", Status); + ExFreePool(buf); + if (decomp) ExFreePool(decomp);
diff --git a/drivers/filesystems/btrfs/registry.c b/drivers/filesystems/btrfs/registry.c index 05f66f5df2..84196df002 100644 --- a/drivers/filesystems/btrfs/registry.c +++ b/drivers/filesystems/btrfs/registry.c @@ -16,6 +16,7 @@ * along with WinBtrfs. If not, see http://www.gnu.org/licenses/. */
#include "btrfs_drv.h" +#include "zstd/zstd.h"
extern UNICODE_STRING log_device, log_file, registry_path; extern LIST_ENTRY uid_map_list, gid_map_list; @@ -30,13 +31,13 @@ extern PDEVICE_OBJECT comdo;
WORK_QUEUE_ITEM wqi;
-static WCHAR option_mounted[] = L"Mounted"; +static const WCHAR option_mounted[] = L"Mounted";
NTSTATUS registry_load_volume_options(device_extension* Vcb) { BTRFS_UUID* uuid = &Vcb->superblock.uuid; mount_options* options = &Vcb->options; UNICODE_STRING path, ignoreus, compressus, compressforceus, compresstypeus, readonlyus, zliblevelus, flushintervalus, - maxinlineus, subvolidus, skipbalanceus, nobarrierus, notrimus, clearcacheus, allowdegradedus; + maxinlineus, subvolidus, skipbalanceus, nobarrierus, notrimus, clearcacheus, allowdegradedus, zstdlevelus; OBJECT_ATTRIBUTES oa; NTSTATUS Status; ULONG i, j, kvfilen, index, retlen; @@ -45,9 +46,10 @@ NTSTATUS registry_load_volume_options(device_extension* Vcb) {
options->compress = mount_compress; options->compress_force = mount_compress_force; - options->compress_type = mount_compress_type > BTRFS_COMPRESSION_LZO ? 0 : mount_compress_type; + options->compress_type = mount_compress_type > BTRFS_COMPRESSION_ZSTD ? 0 : mount_compress_type; options->readonly = mount_readonly; options->zlib_level = mount_zlib_level; + options->zstd_level = mount_zstd_level; options->flush_interval = mount_flush_interval; options->max_inline = min(mount_max_inline, Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node) - sizeof(EXTENT_DATA) + 1); options->skip_balance = mount_skip_balance; @@ -118,6 +120,7 @@ NTSTATUS registry_load_volume_options(device_extension* Vcb) { RtlInitUnicodeString(¬rimus, L"NoTrim"); RtlInitUnicodeString(&clearcacheus, L"ClearCache"); RtlInitUnicodeString(&allowdegradedus, L"AllowDegraded"); + RtlInitUnicodeString(&zstdlevelus, L"ZstdLevel");
do { Status = ZwEnumerateValueKey(h, index, KeyValueFullInformation, kvfi, kvfilen, &retlen); @@ -145,7 +148,7 @@ NTSTATUS registry_load_volume_options(device_extension* Vcb) { } else if (FsRtlAreNamesEqual(&compresstypeus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) { DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
- options->compress_type = (UINT8)(*val > BTRFS_COMPRESSION_LZO ? 0 : *val); + options->compress_type = (UINT8)(*val > BTRFS_COMPRESSION_ZSTD ? 0 : *val); } else if (FsRtlAreNamesEqual(&readonlyus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) { DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
@@ -186,6 +189,10 @@ NTSTATUS registry_load_volume_options(device_extension* Vcb) { DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
options->allow_degraded = *val; + } else if (FsRtlAreNamesEqual(&zstdlevelus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) { + DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset); + + options->zstd_level = *val; } } else if (Status != STATUS_NO_MORE_ENTRIES) { ERR("ZwEnumerateValueKey returned %08x\n", Status); @@ -199,6 +206,9 @@ NTSTATUS registry_load_volume_options(device_extension* Vcb) { if (options->zlib_level > 9) options->zlib_level = 9;
+ if (options->zstd_level > (UINT32)ZSTD_maxCLevel()) + options->zstd_level = ZSTD_maxCLevel(); + if (options->flush_interval == 0) options->flush_interval = mount_flush_interval;
@@ -258,8 +268,8 @@ NTSTATUS registry_mark_volume_mounted(BTRFS_UUID* uuid) { goto end; }
- mountedus.Buffer = option_mounted; - mountedus.Length = mountedus.MaximumLength = (USHORT)wcslen(option_mounted) * sizeof(WCHAR); + mountedus.Buffer = (WCHAR*)option_mounted; + mountedus.Length = mountedus.MaximumLength = sizeof(option_mounted) - sizeof(WCHAR);
data = 1;
@@ -308,8 +318,8 @@ static NTSTATUS registry_mark_volume_unmounted_path(PUNICODE_STRING path) {
index = 0;
- mountedus.Buffer = option_mounted; - mountedus.Length = mountedus.MaximumLength = (USHORT)wcslen(option_mounted) * sizeof(WCHAR); + mountedus.Buffer = (WCHAR*)option_mounted; + mountedus.Length = mountedus.MaximumLength = sizeof(option_mounted) - sizeof(WCHAR);
do { Status = ZwEnumerateValueKey(h, index, KeyValueBasicInformation, kvbi, kvbilen, &retlen); @@ -526,7 +536,7 @@ static void read_mappings(PUNICODE_STRING regpath) { ULONG dispos; NTSTATUS Status;
- const WCHAR mappings[] = L"\Mappings"; + static const WCHAR mappings[] = L"\Mappings";
while (!IsListEmpty(&uid_map_list)) { uid_map* um = CONTAINING_RECORD(RemoveHeadList(&uid_map_list), uid_map, listentry); @@ -535,17 +545,17 @@ static void read_mappings(PUNICODE_STRING regpath) { ExFreePool(um); }
- path = ExAllocatePoolWithTag(PagedPool, regpath->Length + (wcslen(mappings) * sizeof(WCHAR)), ALLOC_TAG); + path = ExAllocatePoolWithTag(PagedPool, regpath->Length + sizeof(mappings) - sizeof(WCHAR), ALLOC_TAG); if (!path) { ERR("out of memory\n"); return; }
RtlCopyMemory(path, regpath->Buffer, regpath->Length); - RtlCopyMemory((UINT8*)path + regpath->Length, mappings, wcslen(mappings) * sizeof(WCHAR)); + RtlCopyMemory((UINT8*)path + regpath->Length, mappings, sizeof(mappings) - sizeof(WCHAR));
us.Buffer = path; - us.Length = us.MaximumLength = regpath->Length + ((USHORT)wcslen(mappings) * sizeof(WCHAR)); + us.Length = us.MaximumLength = regpath->Length + sizeof(mappings) - sizeof(WCHAR);
InitializeObjectAttributes(&oa, &us, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
@@ -604,7 +614,7 @@ static void read_group_mappings(PUNICODE_STRING regpath) { ULONG dispos; NTSTATUS Status;
- const WCHAR mappings[] = L"\GroupMappings"; + static const WCHAR mappings[] = L"\GroupMappings";
while (!IsListEmpty(&gid_map_list)) { gid_map* gm = CONTAINING_RECORD(RemoveHeadList(&gid_map_list), gid_map, listentry); @@ -613,17 +623,17 @@ static void read_group_mappings(PUNICODE_STRING regpath) { ExFreePool(gm); }
- path = ExAllocatePoolWithTag(PagedPool, regpath->Length + (wcslen(mappings) * sizeof(WCHAR)), ALLOC_TAG); + path = ExAllocatePoolWithTag(PagedPool, regpath->Length + sizeof(mappings) - sizeof(WCHAR), ALLOC_TAG); if (!path) { ERR("out of memory\n"); return; }
RtlCopyMemory(path, regpath->Buffer, regpath->Length); - RtlCopyMemory((UINT8*)path + regpath->Length, mappings, wcslen(mappings) * sizeof(WCHAR)); + RtlCopyMemory((UINT8*)path + regpath->Length, mappings, sizeof(mappings) - sizeof(WCHAR));
us.Buffer = path; - us.Length = us.MaximumLength = regpath->Length + ((USHORT)wcslen(mappings) * sizeof(WCHAR)); + us.Length = us.MaximumLength = regpath->Length + sizeof(mappings) - sizeof(WCHAR);
InitializeObjectAttributes(&oa, &us, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
@@ -676,7 +686,7 @@ static void read_group_mappings(PUNICODE_STRING regpath) { // If we're creating the key for the first time, we add a default mapping of // BUILTIN\Users to gid 100, which ought to correspond to the "users" group on Linux.
- us2.Length = us2.MaximumLength = (USHORT)wcslen(builtin_users) * sizeof(WCHAR); + us2.Length = us2.MaximumLength = sizeof(builtin_users) - sizeof(WCHAR); us2.Buffer = ExAllocatePoolWithTag(PagedPool, us2.MaximumLength, ALLOC_TAG);
if (us2.Buffer) { @@ -760,7 +770,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) { ULONG kvfilen, old_debug_log_level = debug_log_level; UNICODE_STRING us, old_log_file, old_log_device;
- static WCHAR def_log_file[] = L"\??\C:\btrfs.log"; + static const WCHAR def_log_file[] = L"\??\C:\btrfs.log"; #endif
ExAcquireResourceExclusiveLite(&mapping_lock, TRUE); @@ -794,6 +804,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) { get_registry_value(h, L"ClearCache", REG_DWORD, &mount_clear_cache, sizeof(mount_clear_cache)); get_registry_value(h, L"AllowDegraded", REG_DWORD, &mount_allow_degraded, sizeof(mount_allow_degraded)); get_registry_value(h, L"Readonly", REG_DWORD, &mount_readonly, sizeof(mount_readonly)); + get_registry_value(h, L"ZstdLevel", REG_DWORD, &mount_zstd_level, sizeof(mount_zstd_level));
if (!refresh) get_registry_value(h, L"NoPNP", REG_DWORD, &no_pnp, sizeof(no_pnp)); @@ -935,7 +946,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
ExFreePool(kvfi); } else if (Status == STATUS_OBJECT_NAME_NOT_FOUND) { - Status = ZwSetValueKey(h, &us, 0, REG_SZ, def_log_file, (ULONG)(wcslen(def_log_file) + 1) * sizeof(WCHAR)); + Status = ZwSetValueKey(h, &us, 0, REG_SZ, (void*)def_log_file, sizeof(def_log_file));
if (!NT_SUCCESS(Status)) ERR("ZwSetValueKey returned %08x\n", Status); @@ -947,7 +958,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) { }
if (log_file.Length == 0) { - log_file.Length = log_file.MaximumLength = (UINT16)wcslen(def_log_file) * sizeof(WCHAR); + log_file.Length = log_file.MaximumLength = sizeof(def_log_file) - sizeof(WCHAR); log_file.Buffer = ExAllocatePoolWithTag(PagedPool, log_file.MaximumLength, ALLOC_TAG);
if (!log_file.Buffer) { diff --git a/drivers/filesystems/btrfs/reparse.c b/drivers/filesystems/btrfs/reparse.c index 8e8d319b58..957ad07305 100644 --- a/drivers/filesystems/btrfs/reparse.c +++ b/drivers/filesystems/btrfs/reparse.c @@ -169,7 +169,7 @@ end: return Status; }
-static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, ccb* ccb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, BOOL write, LIST_ENTRY* rollback) { +static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, BOOL write, LIST_ENTRY* rollback) { NTSTATUS Status; ULONG minlen; ULONG tlength; @@ -197,15 +197,15 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, ccb* ccb, REPARSE_DATA_ TRACE("substitute name = %.*S\n", subname.Length / sizeof(WCHAR), subname.Buffer); }
- fileref->fcb->type = BTRFS_TYPE_SYMLINK; - fileref->fcb->inode_item.st_mode |= __S_IFLNK; - fileref->fcb->inode_item.generation = fileref->fcb->Vcb->superblock.generation; // so we don't confuse btrfs send on Linux + fcb->type = BTRFS_TYPE_SYMLINK; + fcb->inode_item.st_mode |= __S_IFLNK; + fcb->inode_item.generation = fcb->Vcb->superblock.generation; // so we don't confuse btrfs send on Linux
- if (fileref->dc) - fileref->dc->type = fileref->fcb->type; + if (fileref && fileref->dc) + fileref->dc->type = fcb->type;
if (write) { - Status = truncate_file(fileref->fcb, 0, Irp, rollback); + Status = truncate_file(fcb, 0, Irp, rollback); if (!NT_SUCCESS(Status)) { ERR("truncate_file returned %08x\n", Status); return Status; @@ -238,7 +238,7 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, ccb* ccb, REPARSE_DATA_
offset.QuadPart = 0; tlength = target.Length; - Status = write_file2(fileref->fcb->Vcb, Irp, offset, target.Buffer, &tlength, FALSE, TRUE, + Status = write_file2(fcb->Vcb, Irp, offset, target.Buffer, &tlength, FALSE, TRUE, TRUE, FALSE, FALSE, rollback); ExFreePool(target.Buffer); } else @@ -247,86 +247,34 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, ccb* ccb, REPARSE_DATA_ KeQuerySystemTime(&time); win_time_to_unix(time, &now);
- fileref->fcb->inode_item.transid = fileref->fcb->Vcb->superblock.generation; - fileref->fcb->inode_item.sequence++; + fcb->inode_item.transid = fcb->Vcb->superblock.generation; + fcb->inode_item.sequence++;
- if (!ccb->user_set_change_time) - fileref->fcb->inode_item.st_ctime = now; + if (!ccb || !ccb->user_set_change_time) + fcb->inode_item.st_ctime = now;
- if (!ccb->user_set_write_time) - fileref->fcb->inode_item.st_mtime = now; + if (!ccb || !ccb->user_set_write_time) + fcb->inode_item.st_mtime = now;
- fileref->fcb->subvol->root_item.ctransid = fileref->fcb->Vcb->superblock.generation; - fileref->fcb->subvol->root_item.ctime = now; + fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation; + fcb->subvol->root_item.ctime = now;
- fileref->fcb->inode_item_changed = TRUE; - mark_fcb_dirty(fileref->fcb); + fcb->inode_item_changed = TRUE; + mark_fcb_dirty(fcb);
- mark_fileref_dirty(fileref); + if (fileref) + mark_fileref_dirty(fileref);
return Status; }
-NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) { - PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp); - PFILE_OBJECT FileObject = IrpSp->FileObject; - void* buffer = Irp->AssociatedIrp.SystemBuffer; - REPARSE_DATA_BUFFER* rdb = buffer; - DWORD buflen = IrpSp->Parameters.DeviceIoControl.InputBufferLength; - NTSTATUS Status = STATUS_SUCCESS; - fcb* fcb; - ccb* ccb; - file_ref* fileref; +NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, ccb* ccb, file_ref* fileref, PIRP Irp, LIST_ENTRY* rollback) { + NTSTATUS Status; ULONG tag; - LIST_ENTRY rollback; - - TRACE("(%p, %p)\n", DeviceObject, Irp); - - InitializeListHead(&rollback); - - if (!FileObject) { - ERR("FileObject was NULL\n"); - return STATUS_INVALID_PARAMETER; - } - - // IFSTest insists on this, for some reason... - if (Irp->UserBuffer) - return STATUS_INVALID_PARAMETER; - - fcb = FileObject->FsContext; - ccb = FileObject->FsContext2; - - if (!ccb) { - ERR("ccb was NULL\n"); - return STATUS_INVALID_PARAMETER; - } - - if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_WRITE_ATTRIBUTES | FILE_WRITE_DATA))) { - WARN("insufficient privileges\n"); - return STATUS_ACCESS_DENIED; - } - - fileref = ccb->fileref; - - if (!fileref) { - ERR("fileref was NULL\n"); - return STATUS_INVALID_PARAMETER; - } - - if (fcb->ads) { - fileref = fileref->parent; - fcb = fileref->fcb; - } - - TRACE("%S\n", file_desc(FileObject)); - - ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE); - ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
if (fcb->type == BTRFS_TYPE_SYMLINK) { WARN("tried to set a reparse point on an existing symlink\n"); - Status = STATUS_INVALID_PARAMETER; - goto end; + return STATUS_INVALID_PARAMETER; }
// FIXME - fail if we already have the attribute FILE_ATTRIBUTE_REPARSE_POINT @@ -335,34 +283,32 @@ NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
if (buflen < sizeof(ULONG)) { WARN("buffer was not long enough to hold tag\n"); - Status = STATUS_INVALID_BUFFER_SIZE; - goto end; + return STATUS_INVALID_BUFFER_SIZE; }
Status = FsRtlValidateReparsePointBuffer(buflen, rdb); if (!NT_SUCCESS(Status)) { ERR("FsRtlValidateReparsePointBuffer returned %08x\n", Status); - goto end; + return Status; }
- RtlCopyMemory(&tag, buffer, sizeof(ULONG)); + RtlCopyMemory(&tag, rdb, sizeof(ULONG));
if (fcb->type == BTRFS_TYPE_FILE && ((tag == IO_REPARSE_TAG_SYMLINK && rdb->SymbolicLinkReparseBuffer.Flags & SYMLINK_FLAG_RELATIVE) || tag == IO_REPARSE_TAG_LXSS_SYMLINK)) { - Status = set_symlink(Irp, fileref, ccb, rdb, buflen, tag == IO_REPARSE_TAG_SYMLINK, &rollback); + Status = set_symlink(Irp, fileref, fcb, ccb, rdb, buflen, tag == IO_REPARSE_TAG_SYMLINK, rollback); fcb->atts |= FILE_ATTRIBUTE_REPARSE_POINT; } else { LARGE_INTEGER offset, time; BTRFS_TIME now;
- if (fcb->type == BTRFS_TYPE_DIRECTORY) { // for directories, store as xattr + if (fcb->type == BTRFS_TYPE_DIRECTORY || fcb->type == BTRFS_TYPE_CHARDEV || fcb->type == BTRFS_TYPE_BLOCKDEV) { // store as xattr ANSI_STRING buf;
buf.Buffer = ExAllocatePoolWithTag(PagedPool, buflen, ALLOC_TAG); if (!buf.Buffer) { ERR("out of memory\n"); - Status = STATUS_INSUFFICIENT_RESOURCES; - goto end; + return STATUS_INSUFFICIENT_RESOURCES; } buf.Length = buf.MaximumLength = (UINT16)buflen;
@@ -370,24 +316,24 @@ NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) { ExFreePool(fcb->reparse_xattr.Buffer);
fcb->reparse_xattr = buf; - RtlCopyMemory(buf.Buffer, buffer, buflen); + RtlCopyMemory(buf.Buffer, rdb, buflen);
fcb->reparse_xattr_changed = TRUE;
Status = STATUS_SUCCESS; } else { // otherwise, store as file data - Status = truncate_file(fcb, 0, Irp, &rollback); + Status = truncate_file(fcb, 0, Irp, rollback); if (!NT_SUCCESS(Status)) { ERR("truncate_file returned %08x\n", Status); - goto end; + return Status; }
offset.QuadPart = 0;
- Status = write_file2(fcb->Vcb, Irp, offset, buffer, &buflen, FALSE, TRUE, TRUE, FALSE, FALSE, &rollback); + Status = write_file2(fcb->Vcb, Irp, offset, rdb, &buflen, FALSE, TRUE, TRUE, FALSE, FALSE, rollback); if (!NT_SUCCESS(Status)) { ERR("write_file2 returned %08x\n", Status); - goto end; + return Status; } }
@@ -397,10 +343,10 @@ NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) { fcb->inode_item.transid = fcb->Vcb->superblock.generation; fcb->inode_item.sequence++;
- if (!ccb->user_set_change_time) + if (!ccb || !ccb->user_set_change_time) fcb->inode_item.st_ctime = now;
- if (!ccb->user_set_write_time) + if (!ccb || !ccb->user_set_write_time) fcb->inode_item.st_mtime = now;
fcb->atts |= FILE_ATTRIBUTE_REPARSE_POINT; @@ -413,6 +359,70 @@ NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) { mark_fcb_dirty(fcb); }
+ return STATUS_SUCCESS; +} + +NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) { + PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp); + PFILE_OBJECT FileObject = IrpSp->FileObject; + void* buffer = Irp->AssociatedIrp.SystemBuffer; + REPARSE_DATA_BUFFER* rdb = buffer; + DWORD buflen = IrpSp->Parameters.DeviceIoControl.InputBufferLength; + NTSTATUS Status = STATUS_SUCCESS; + fcb* fcb; + ccb* ccb; + file_ref* fileref; + LIST_ENTRY rollback; + + TRACE("(%p, %p)\n", DeviceObject, Irp); + + InitializeListHead(&rollback); + + if (!FileObject) { + ERR("FileObject was NULL\n"); + return STATUS_INVALID_PARAMETER; + } + + // IFSTest insists on this, for some reason... + if (Irp->UserBuffer) + return STATUS_INVALID_PARAMETER; + + fcb = FileObject->FsContext; + ccb = FileObject->FsContext2; + + if (!ccb) { + ERR("ccb was NULL\n"); + return STATUS_INVALID_PARAMETER; + } + + if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_WRITE_ATTRIBUTES | FILE_WRITE_DATA))) { + WARN("insufficient privileges\n"); + return STATUS_ACCESS_DENIED; + } + + fileref = ccb->fileref; + + if (!fileref) { + ERR("fileref was NULL\n"); + return STATUS_INVALID_PARAMETER; + } + + if (fcb->ads) { + fileref = fileref->parent; + fcb = fileref->fcb; + } + + TRACE("%S\n", file_desc(FileObject)); + + ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE); + ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE); + + Status = set_reparse_point2(fcb, rdb, buflen, ccb, fileref, Irp, &rollback); + if (!NT_SUCCESS(Status)) { + ERR("set_reparse_point2 returned %08x\n", Status); + goto end; + } + send_notification_fcb(fileref, FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES, FILE_ACTION_MODIFIED, NULL);
end: diff --git a/drivers/filesystems/btrfs/scrub.c b/drivers/filesystems/btrfs/scrub.c index 9dd7c2008d..f2d3d5e9ed 100644 --- a/drivers/filesystems/btrfs/scrub.c +++ b/drivers/filesystems/btrfs/scrub.c @@ -3190,7 +3190,7 @@ static void scrub_thread(void* context) { while (le != &Vcb->chunks) { chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if (!c->readonly) { InsertTailList(&chunks, &c->list_entry_balance); @@ -3198,7 +3198,7 @@ static void scrub_thread(void* context) { Vcb->scrub.chunks_left++; }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
le = le->Flink; } diff --git a/drivers/filesystems/btrfs/search.c b/drivers/filesystems/btrfs/search.c index bec1aba420..7333a1e1df 100644 --- a/drivers/filesystems/btrfs/search.c +++ b/drivers/filesystems/btrfs/search.c @@ -496,7 +496,7 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo pdo = vde->pdo; IoDeleteDevice(vde->device);
- if (no_pnp) + if (!no_pnp) IoDeleteDevice(pdo); } } else @@ -540,7 +540,7 @@ void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) { TRACE("DeviceType = %u, DeviceNumber = %u, PartitionNumber = %u\n", sdn.DeviceType, sdn.DeviceNumber, sdn.PartitionNumber);
// If we've just added a partition to a whole-disk filesystem, unmount it - if (sdn.DeviceNumber != 0xffffffff) { + if (sdn.DeviceNumber != 0xffffffff && sdn.PartitionNumber != 0) { LIST_ENTRY* le;
ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE); @@ -823,7 +823,7 @@ static void mountmgr_process_drive(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devi static void mountmgr_updated(PDEVICE_OBJECT mountmgr, MOUNTMGR_MOUNT_POINTS* mmps) { ULONG i;
- static WCHAR pref[] = L"\DosDevices\"; + static const WCHAR pref[] = L"\DosDevices\";
for (i = 0; i < mmps->NumberOfMountPoints; i++) { UNICODE_STRING symlink, device_name; @@ -844,8 +844,8 @@ static void mountmgr_updated(PDEVICE_OBJECT mountmgr, MOUNTMGR_MOUNT_POINTS* mmp device_name.Length = device_name.MaximumLength = 0; }
- if (symlink.Length > wcslen(pref) * sizeof(WCHAR) && - RtlCompareMemory(symlink.Buffer, pref, wcslen(pref) * sizeof(WCHAR)) == wcslen(pref) * sizeof(WCHAR)) + if (symlink.Length > sizeof(pref) - sizeof(WCHAR) && + RtlCompareMemory(symlink.Buffer, pref, sizeof(pref) - sizeof(WCHAR)) == sizeof(pref) - sizeof(WCHAR)) mountmgr_process_drive(mountmgr, &device_name); } } diff --git a/drivers/filesystems/btrfs/send.c b/drivers/filesystems/btrfs/send.c index a865c62c3e..260612a155 100644 --- a/drivers/filesystems/btrfs/send.c +++ b/drivers/filesystems/btrfs/send.c @@ -1648,7 +1648,7 @@ static NTSTATUS wait_for_flush(send_context* context, traverse_ptr* tp1, travers return STATUS_SUCCESS; }
-static NTSTATUS add_ext_holes(LIST_ENTRY* exts, UINT64 size) { +static NTSTATUS add_ext_holes(device_extension* Vcb, LIST_ENTRY* exts, UINT64 size) { UINT64 lastoff = 0; LIST_ENTRY* le;
@@ -1699,7 +1699,7 @@ static NTSTATUS add_ext_holes(LIST_ENTRY* exts, UINT64 size) {
ext2->offset = lastoff; ext2->datalen = offsetof(EXTENT_DATA, data) + sizeof(EXTENT_DATA2); - ext2->data.decoded_size = ed2->num_bytes = size - lastoff; + ext2->data.decoded_size = ed2->num_bytes = sector_align(size - lastoff, Vcb->superblock.sector_size); ext2->data.type = EXTENT_TYPE_REGULAR; ed2->address = ed2->size = ed2->offset = 0;
@@ -2130,13 +2130,13 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse return STATUS_SUCCESS;
if (context->parent) { - Status = add_ext_holes(&context->lastinode.exts, context->lastinode.size); + Status = add_ext_holes(context->Vcb, &context->lastinode.exts, context->lastinode.size); if (!NT_SUCCESS(Status)) { ERR("add_ext_holes returned %08x\n", Status); return Status; }
- Status = add_ext_holes(&context->lastinode.oldexts, context->lastinode.size); + Status = add_ext_holes(context->Vcb, &context->lastinode.oldexts, context->lastinode.size); if (!NT_SUCCESS(Status)) { ERR("add_ext_holes returned %08x\n", Status); return Status; @@ -2187,7 +2187,7 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse
if (se->data.compression == BTRFS_COMPRESSION_NONE) send_add_tlv(context, BTRFS_SEND_TLV_DATA, se->data.data, (UINT16)se->data.decoded_size); - else if (se->data.compression == BTRFS_COMPRESSION_ZLIB || se->data.compression == BTRFS_COMPRESSION_LZO) { + else if (se->data.compression == BTRFS_COMPRESSION_ZLIB || se->data.compression == BTRFS_COMPRESSION_LZO || se->data.compression == BTRFS_COMPRESSION_ZSTD) { ULONG inlen = se->datalen - (ULONG)offsetof(EXTENT_DATA, data[0]);
send_add_tlv(context, BTRFS_SEND_TLV_DATA, NULL, (UINT16)se->data.decoded_size); @@ -2217,6 +2217,14 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse if (se2) ExFreePool(se2); return Status; } + } else if (se->data.compression == BTRFS_COMPRESSION_ZSTD) { + Status = zstd_decompress(se->data.data, inlen, &context->data[context->datalen - se->data.decoded_size], (UINT32)se->data.decoded_size); + if (!NT_SUCCESS(Status)) { + ERR("zlib_decompress returned %08x\n", Status); + ExFreePool(se); + if (se2) ExFreePool(se2); + return Status; + } } } else { ERR("unhandled compression type %x\n", se->data.compression); @@ -2367,7 +2375,7 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse offset = se->offset + off; send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &offset, sizeof(UINT64));
- length = min((UINT16)(context->lastinode.size - se->offset - off), length); + length = (UINT16)min(context->lastinode.size - se->offset - off, length); send_add_tlv(context, BTRFS_SEND_TLV_DATA, buf + skip_start, length);
send_command_finish(context, pos); @@ -2459,6 +2467,16 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse if (se2) ExFreePool(se2); return Status; } + } else if (se->data.compression == BTRFS_COMPRESSION_ZSTD) { + Status = zstd_decompress(compbuf, (UINT32)ed2->size, buf, (UINT32)se->data.decoded_size); + if (!NT_SUCCESS(Status)) { + ERR("zstd_decompress returned %08x\n", Status); + ExFreePool(compbuf); + ExFreePool(buf); + ExFreePool(se); + if (se2) ExFreePool(se2); + return Status; + } }
ExFreePool(compbuf); @@ -2494,7 +2512,7 @@ static NTSTATUS flush_extents(send_context* context, traverse_ptr* tp1, traverse offset = se->offset + off; send_add_tlv(context, BTRFS_SEND_TLV_OFFSET, &offset, sizeof(UINT64));
- length = min((UINT16)(context->lastinode.size - se->offset - off), length); + length = (UINT16)min(context->lastinode.size - se->offset - off, length); send_add_tlv(context, BTRFS_SEND_TLV_DATA, &buf[off], length);
send_command_finish(context, pos); @@ -2639,7 +2657,8 @@ static NTSTATUS send_extent_data(send_context* context, traverse_ptr* tp, traver return STATUS_INTERNAL_ERROR; }
- if (ed->compression != BTRFS_COMPRESSION_NONE && ed->compression != BTRFS_COMPRESSION_ZLIB && ed->compression != BTRFS_COMPRESSION_LZO) { + if (ed->compression != BTRFS_COMPRESSION_NONE && ed->compression != BTRFS_COMPRESSION_ZLIB && + ed->compression != BTRFS_COMPRESSION_LZO && ed->compression != BTRFS_COMPRESSION_ZSTD) { ERR("unknown compression type %u\n", ed->compression); return STATUS_INTERNAL_ERROR; } @@ -2697,7 +2716,8 @@ static NTSTATUS send_extent_data(send_context* context, traverse_ptr* tp, traver return STATUS_INTERNAL_ERROR; }
- if (ed->compression != BTRFS_COMPRESSION_NONE && ed->compression != BTRFS_COMPRESSION_ZLIB && ed->compression != BTRFS_COMPRESSION_LZO) { + if (ed->compression != BTRFS_COMPRESSION_NONE && ed->compression != BTRFS_COMPRESSION_ZLIB && + ed->compression != BTRFS_COMPRESSION_LZO && ed->compression != BTRFS_COMPRESSION_ZSTD) { ERR("unknown compression type %u\n", ed->compression); return STATUS_INTERNAL_ERROR; } @@ -3730,6 +3750,10 @@ NTSTATUS send_subvol(device_extension* Vcb, void* data, ULONG datalen, PFILE_OBJ context = ExAllocatePoolWithTag(NonPagedPool, sizeof(send_context), ALLOC_TAG); if (!context) { ERR("out of memory\n"); + + if (clones) + ExFreePool(clones); + ExReleaseResourceLite(&Vcb->send_load_lock); return STATUS_INSUFFICIENT_RESOURCES; } @@ -3769,6 +3793,10 @@ NTSTATUS send_subvol(device_extension* Vcb, void* data, ULONG datalen, PFILE_OBJ ERR("out of memory\n"); ExFreePool(context->data); ExFreePool(context); + + if (clones) + ExFreePool(clones); + ExReleaseResourceLite(&Vcb->send_load_lock); return STATUS_INSUFFICIENT_RESOURCES; } @@ -3794,6 +3822,10 @@ NTSTATUS send_subvol(device_extension* Vcb, void* data, ULONG datalen, PFILE_OBJ ExFreePool(send); ExFreePool(context->data); ExFreePool(context); + + if (clones) + ExFreePool(clones); + ExReleaseResourceLite(&Vcb->send_load_lock); return Status; } diff --git a/drivers/filesystems/btrfs/treefuncs.c b/drivers/filesystems/btrfs/treefuncs.c index e2f6001e65..9785e12713 100644 --- a/drivers/filesystems/btrfs/treefuncs.c +++ b/drivers/filesystems/btrfs/treefuncs.c @@ -72,6 +72,7 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, root* r, tree** pt, UINT6
if ((t->header.num_items * sizeof(leaf_node)) + sizeof(tree_header) > Vcb->superblock.node_size) { ERR("tree at %llx has more items than expected (%x)\n", t->header.num_items); + ExFreePool(t); ExFreePool(buf); return STATUS_INSUFFICIENT_RESOURCES; } @@ -80,6 +81,7 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, root* r, tree** pt, UINT6 td = ExAllocateFromPagedLookasideList(&Vcb->tree_data_lookaside); if (!td) { ERR("out of memory\n"); + ExFreePool(t); ExFreePool(buf); return STATUS_INSUFFICIENT_RESOURCES; } @@ -93,6 +95,8 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, root* r, tree** pt, UINT6
if (ln[i].size + sizeof(tree_header) + sizeof(leaf_node) > Vcb->superblock.node_size) { ERR("overlarge item in tree %llx: %u > %u\n", addr, ln[i].size, Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node)); + ExFreeToPagedLookasideList(&t->Vcb->tree_data_lookaside, td); + ExFreePool(t); ExFreePool(buf); return STATUS_INTERNAL_ERROR; } @@ -114,6 +118,7 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, root* r, tree** pt, UINT6
if ((t->header.num_items * sizeof(internal_node)) + sizeof(tree_header) > Vcb->superblock.node_size) { ERR("tree at %llx has more items than expected (%x)\n", t->header.num_items); + ExFreePool(t); ExFreePool(buf); return STATUS_INSUFFICIENT_RESOURCES; } @@ -122,6 +127,7 @@ NTSTATUS load_tree(device_extension* Vcb, UINT64 addr, root* r, tree** pt, UINT6 td = ExAllocateFromPagedLookasideList(&Vcb->tree_data_lookaside); if (!td) { ERR("out of memory\n"); + ExFreePool(t); ExFreePool(buf); return STATUS_INSUFFICIENT_RESOURCES; } @@ -1096,7 +1102,7 @@ void do_rollback(device_extension* Vcb, LIST_ENTRY* rollback) { rollback_space* rs = ri->ptr;
if (rs->chunk) - ExAcquireResourceExclusiveLite(&rs->chunk->lock, TRUE); + acquire_chunk_lock(rs->chunk, Vcb);
if (ri->type == ROLLBACK_ADD_SPACE) space_list_subtract2(rs->list, rs->list_size, rs->address, rs->length, NULL, NULL); @@ -1138,7 +1144,7 @@ void do_rollback(device_extension* Vcb, LIST_ENTRY* rollback) { le2 = le3; }
- ExReleaseResourceLite(&rs->chunk->lock); + release_chunk_lock(rs->chunk, Vcb); }
ExFreePool(rs); @@ -1509,6 +1515,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr td2 = ExAllocateFromPagedLookasideList(&Vcb->tree_data_lookaside); if (!td2) { ERR("out of memory\n"); + ExFreePool(newdi); return STATUS_INSUFFICIENT_RESOURCES; }
@@ -1595,6 +1602,7 @@ static NTSTATUS handle_batch_collision(device_extension* Vcb, batch_item* bi, tr td2 = ExAllocateFromPagedLookasideList(&Vcb->tree_data_lookaside); if (!td2) { ERR("out of memory\n"); + ExFreePool(newir); return STATUS_INSUFFICIENT_RESOURCES; }
diff --git a/drivers/filesystems/btrfs/volume.c b/drivers/filesystems/btrfs/volume.c index 5f7516a5c2..fa33221b7c 100644 --- a/drivers/filesystems/btrfs/volume.c +++ b/drivers/filesystems/btrfs/volume.c @@ -53,6 +53,8 @@ NTSTATUS vol_close(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
Irp->IoStatus.Information = 0;
+ ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE); + ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
if (InterlockedDecrement(&vde->open_count) == 0 && vde->removing) { @@ -83,16 +85,20 @@ NTSTATUS vol_close(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
ExReleaseResourceLite(&pdode->child_lock); ExDeleteResourceLite(&pdode->child_lock); - IoDetachDevice(vde->pdo); + + if (vde->pdo->AttachedDevice) + IoDetachDevice(vde->pdo);
pdo = vde->pdo; IoDeleteDevice(vde->device);
- if (no_pnp) + if (!no_pnp) IoDeleteDevice(pdo); } else ExReleaseResourceLite(&pdode->child_lock);
+ ExReleaseResourceLite(&pdo_list_lock); + return STATUS_SUCCESS; }
@@ -971,7 +977,7 @@ static BOOL allow_degraded_mount(BTRFS_UUID* uuid) { }
adus.Buffer = L"AllowDegraded"; - adus.Length = adus.MaximumLength = (USHORT)(wcslen(adus.Buffer) * sizeof(WCHAR)); + adus.Length = adus.MaximumLength = sizeof(adus.Buffer) - sizeof(WCHAR);
if (NT_SUCCESS(ZwQueryValueKey(h, &adus, KeyValueFullInformation, kvfi, kvfilen, &retlen))) { if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(UINT32)) { diff --git a/drivers/filesystems/btrfs/write.c b/drivers/filesystems/btrfs/write.c index 6292d7efb0..ed1df4c897 100644 --- a/drivers/filesystems/btrfs/write.c +++ b/drivers/filesystems/btrfs/write.c @@ -404,10 +404,6 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_ return STATUS_INTERNAL_ERROR; }
- max_chunk_size = min(max_chunk_size, total_size / 10); // cap at 10% - - TRACE("would allocate a new chunk of %llx bytes and stripe %llx\n", max_chunk_size, max_stripe_size); - if (flags & BLOCK_FLAG_DUPLICATE) { min_stripes = 2; max_stripes = 2; @@ -452,6 +448,13 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_ allowed_missing = 0; }
+ if (max_chunk_size > total_size / 10) { // cap at 10% + max_chunk_size = total_size / 10; + max_stripe_size = max_chunk_size / min_stripes; + } + + TRACE("would allocate a new chunk of %llx bytes and stripe %llx\n", max_chunk_size, max_stripe_size); + stripes = ExAllocatePoolWithTag(PagedPool, sizeof(stripe) * max_stripes, ALLOC_TAG); if (!stripes) { ERR("out of memory\n"); @@ -511,6 +514,8 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_ goto end; }
+ c->devices = NULL; + cisize = sizeof(CHUNK_ITEM) + (num_stripes * sizeof(CHUNK_ITEM_STRIPE)); c->chunk_item = ExAllocatePoolWithTag(NonPagedPool, cisize, ALLOC_TAG); if (!c->chunk_item) { @@ -549,7 +554,8 @@ NTSTATUS alloc_chunk(device_extension* Vcb, UINT64 flags, chunk** pc, BOOL full_ stripe_size -= stripe_size % stripe_length;
if (stripe_size == 0) { - Status = STATUS_INTERNAL_ERROR; + ERR("not enough free space found (stripe_size == 0)\n"); + Status = STATUS_DISK_FULL; goto end; }
@@ -1287,7 +1293,8 @@ static NTSTATUS prepare_raid5_write(device_extension* Vcb, chunk* c, UINT64 addr stripes[i].mdl = IoAllocateMdl((UINT8*)MmGetMdlVirtualAddress(master_mdl) + irp_offset, (ULONG)(stripes[i].end - stripes[i].start), FALSE, FALSE, NULL); if (!stripes[i].mdl) { ERR("IoAllocateMdl failed\n"); - return STATUS_INSUFFICIENT_RESOURCES; + Status = STATUS_INSUFFICIENT_RESOURCES; + goto exit; } } } @@ -1702,7 +1709,8 @@ static NTSTATUS prepare_raid6_write(device_extension* Vcb, chunk* c, UINT64 addr stripes[i].mdl = IoAllocateMdl((UINT8*)MmGetMdlVirtualAddress(master_mdl) + irp_offset, (ULONG)(stripes[i].end - stripes[i].start), FALSE, FALSE, NULL); if (!stripes[i].mdl) { ERR("IoAllocateMdl failed\n"); - return STATUS_INSUFFICIENT_RESOURCES; + Status = STATUS_INSUFFICIENT_RESOURCES; + goto exit; } } } @@ -1880,7 +1888,6 @@ NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_b NTSTATUS Status; UINT32 i; CHUNK_ITEM_STRIPE* cis; - write_data_stripe* stripe; write_stripe* stripes = NULL; UINT64 total_writing = 0; ULONG allowed_missing, missing; @@ -2001,6 +2008,7 @@ NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_b }
for (i = 0; i < c->chunk_item->num_stripes; i++) { + write_data_stripe* stripe; PIO_STACK_LOCATION IrpSp;
stripe = ExAllocatePoolWithTag(NonPagedPool, sizeof(write_data_stripe), ALLOC_TAG); @@ -2028,6 +2036,7 @@ NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_b
if (!stripe->Irp) { ERR("IoAllocateIrp failed\n"); + ExFreePool(stripe); Status = STATUS_INSUFFICIENT_RESOURCES; goto end; } @@ -2036,6 +2045,7 @@ NTSTATUS write_data(_In_ device_extension* Vcb, _In_ UINT64 address, _In_reads_b
if (!stripe->Irp) { ERR("IoMakeAssociatedIrp failed\n"); + ExFreePool(stripe); Status = STATUS_INSUFFICIENT_RESOURCES; goto end; } @@ -2333,10 +2343,9 @@ void free_write_data_stripes(write_data_context* wtc) {
last_mdl = stripe->mdl;
-#ifdef __REACTOS__ if (stripe->Irp) IoFreeIrp(stripe->Irp); -#endif + le = le->Flink; }
@@ -2888,7 +2897,7 @@ BOOL insert_extent_chunk(_In_ device_extension* Vcb, _In_ fcb* fcb, _In_ chunk*
ExReleaseResourceLite(&c->changed_extents_lock);
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
if (data) { Status = write_data_complete(Vcb, address, data, (UINT32)length, Irp, NULL, file_write, irp_offset, @@ -2949,10 +2958,10 @@ static BOOL try_extend_data(device_extension* Vcb, fcb* fcb, UINT64 start_data, if (c->reloc || c->readonly || c->chunk_item->type != Vcb->data_flags) return FALSE;
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if (length > c->chunk_item->size - c->used) { - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); return FALSE; }
@@ -2961,7 +2970,7 @@ static BOOL try_extend_data(device_extension* Vcb, fcb* fcb, UINT64 start_data,
if (!NT_SUCCESS(Status)) { ERR("load_cache_chunk returned %08x\n", Status); - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); return FALSE; } } @@ -2978,7 +2987,7 @@ static BOOL try_extend_data(device_extension* Vcb, fcb* fcb, UINT64 start_data, if (success) *written += newlen; else - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
return success; } else if (s->address > ed2->address + ed2->size) @@ -2987,7 +2996,7 @@ static BOOL try_extend_data(device_extension* Vcb, fcb* fcb, UINT64 start_data, le = le->Flink; }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb);
return FALSE; } @@ -3017,7 +3026,7 @@ static NTSTATUS insert_chunk_fragmented(fcb* fcb, UINT64 start, UINT64 length, U c = CONTAINING_RECORD(le, chunk, list_entry);
if (!c->readonly && !c->reloc) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == flags) { while (!IsListEmpty(&c->space_size) && length > 0) { @@ -3029,12 +3038,12 @@ static NTSTATUS insert_chunk_fragmented(fcb* fcb, UINT64 start, UINT64 length, U length -= extlen; if (data) data += extlen;
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, fcb->Vcb); } } }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, fcb->Vcb);
if (length == 0) break; @@ -3067,7 +3076,7 @@ static NTSTATUS insert_prealloc_extent(fcb* fcb, UINT64 start, UINT64 length, LI c = CONTAINING_RECORD(le, chunk, list_entry);
if (!c->readonly && !c->reloc) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= extlen) { if (insert_extent_chunk(fcb->Vcb, fcb, c, start, extlen, !page_file, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, extlen, FALSE, 0)) { @@ -3076,7 +3085,7 @@ static NTSTATUS insert_prealloc_extent(fcb* fcb, UINT64 start, UINT64 length, LI } }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, fcb->Vcb); }
le = le->Flink; @@ -3095,14 +3104,14 @@ static NTSTATUS insert_prealloc_extent(fcb* fcb, UINT64 start, UINT64 length, LI goto end; }
- ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= extlen) { if (insert_extent_chunk(fcb->Vcb, fcb, c, start, extlen, !page_file, NULL, NULL, rollback, BTRFS_COMPRESSION_NONE, extlen, FALSE, 0)) goto cont; }
- ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, fcb->Vcb);
Status = insert_chunk_fragmented(fcb, start, length, NULL, TRUE, rollback); if (!NT_SUCCESS(Status)) @@ -3159,7 +3168,7 @@ static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, UINT64 start_data c = CONTAINING_RECORD(le, chunk, list_entry);
if (!c->readonly && !c->reloc) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= newlen && insert_extent_chunk(Vcb, fcb, c, start_data, newlen, FALSE, data, Irp, rollback, BTRFS_COMPRESSION_NONE, newlen, file_write, irp_offset)) { @@ -3177,7 +3186,7 @@ static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, UINT64 start_data break; } } else - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); }
le = le->Flink; @@ -3201,7 +3210,7 @@ static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, UINT64 start_data }
if (c) { - ExAcquireResourceExclusiveLite(&c->lock, TRUE); + acquire_chunk_lock(c, Vcb);
if (c->chunk_item->type == flags && (c->chunk_item->size - c->used) >= newlen && insert_extent_chunk(Vcb, fcb, c, start_data, newlen, FALSE, data, Irp, rollback, BTRFS_COMPRESSION_NONE, newlen, file_write, irp_offset)) { @@ -3217,7 +3226,7 @@ static NTSTATUS insert_extent(device_extension* Vcb, fcb* fcb, UINT64 start_data data = &((UINT8*)data)[newlen]; } } else - ExReleaseResourceLite(&c->lock); + release_chunk_lock(c, Vcb); }
if (!done) { @@ -3642,6 +3651,8 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data, Irp, NULL, file_write, irp_offset + ext->offset - start_data, priority); if (!NT_SUCCESS(Status)) { ERR("write_data_complete returned %08x\n", Status); + ExFreePool(newext1); + ExFreePool(newext2); return Status; }
@@ -3737,6 +3748,8 @@ static NTSTATUS do_write_file_prealloc(fcb* fcb, extent* ext, UINT64 start_data, Status = write_data_complete(fcb->Vcb, ed2->address + ned2->offset, data, (UINT32)ned2->num_bytes, Irp, NULL, file_write, irp_offset, priority); if (!NT_SUCCESS(Status)) { ERR("write_data_complete returned %08x\n", Status); + ExFreePool(newext1); + ExFreePool(newext2); return Status; }
diff --git a/drivers/filesystems/btrfs/zstd/bitstream.h b/drivers/filesystems/btrfs/zstd/bitstream.h new file mode 100644 index 0000000000..ef89b9878e --- /dev/null +++ b/drivers/filesystems/btrfs/zstd/bitstream.h @@ -0,0 +1,455 @@ +/* ****************************************************************** + bitstream + Part of FSE library + Copyright (C) 2013-present, Yann Collet. + + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + You can contact the author at : + - Source repository : https://github.com/Cyan4973/FiniteStateEntropy +****************************************************************** */ +#ifndef BITSTREAM_H_MODULE +#define BITSTREAM_H_MODULE + +#if defined (__cplusplus) +extern "C" { +#endif + +/* +* This API consists of small unitary functions, which must be inlined for best performance. +* Since link-time-optimization is not available for all compilers, +* these functions are defined into a .h to be included. +*/ + +/*-**************************************** +* Dependencies +******************************************/ +#include "mem.h" /* unaligned access routines */ +#include "debug.h" /* assert(), DEBUGLOG(), RAWLOG() */ +#include "error_private.h" /* error codes and messages */ + + +/*========================================= +* Target specific +=========================================*/ +#if defined(__BMI__) && defined(__GNUC__) +# include <immintrin.h> /* support for bextr (experimental) */ +#endif + +#define STREAM_ACCUMULATOR_MIN_32 25 +#define STREAM_ACCUMULATOR_MIN_64 57 +#define STREAM_ACCUMULATOR_MIN ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64)) + + +/*-****************************************** +* bitStream encoding API (write forward) +********************************************/ +/* bitStream can mix input from multiple sources. + * A critical property of these streams is that they encode and decode in **reverse** direction. + * So the first bit sequence you add will be the last to be read, like a LIFO stack. + */ +typedef struct { + size_t bitContainer; + unsigned bitPos; + char* startPtr; + char* ptr; + char* endPtr; +} BIT_CStream_t; + +MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity); +MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits); +MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC); +MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC); + +/* Start with initCStream, providing the size of buffer to write into. +* bitStream will never write outside of this buffer. +* `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code. +* +* bits are first added to a local register. +* Local register is size_t, hence 64-bits on 64-bits systems, or 32-bits on 32-bits systems. +* Writing data into memory is an explicit operation, performed by the flushBits function. +* Hence keep track how many bits are potentially stored into local register to avoid register overflow. +* After a flushBits, a maximum of 7 bits might still be stored into local register. +* +* Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream readers. +* +* Last operation is to close the bitStream. +* The function returns the final size of CStream in bytes. +* If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable) +*/ + + +/*-******************************************** +* bitStream decoding API (read backward) +**********************************************/ +typedef struct { + size_t bitContainer; + unsigned bitsConsumed; + const char* ptr; + const char* start; + const char* limitPtr; +} BIT_DStream_t; + +typedef enum { BIT_DStream_unfinished = 0, + BIT_DStream_endOfBuffer = 1, + BIT_DStream_completed = 2, + BIT_DStream_overflow = 3 } BIT_DStream_status; /* result of BIT_reloadDStream() */ + /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ + +MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize); +MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits); +MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD); +MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD); + + +/* Start by invoking BIT_initDStream(). +* A chunk of the bitStream is then stored into a local register. +* Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t). +* You can then retrieve bitFields stored into the local register, **in reverse order**. +* Local register is explicitly reloaded from memory by the BIT_reloadDStream() method. +* A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished. +* Otherwise, it can be less than that, so proceed accordingly. +* Checking if DStream has reached its end can be performed with BIT_endOfDStream(). +*/ + + +/*-**************************************** +* unsafe API +******************************************/ +MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits); +/* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */ + +MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC); +/* unsafe version; does not check buffer overflow */ + +MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits); +/* faster, but works only if nbBits >= 1 */ + + + +/*-************************************************************** +* Internal functions +****************************************************************/ +MEM_STATIC unsigned BIT_highbit32 (U32 val) +{ + assert(val != 0); + { +# if defined(_MSC_VER) /* Visual */ + unsigned long r=0; + _BitScanReverse ( &r, val ); + return (unsigned) r; +# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */ + return 31 - __builtin_clz (val); +# else /* Software version */ + static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, + 11, 14, 16, 18, 22, 25, 3, 30, + 8, 12, 20, 28, 15, 17, 24, 7, + 19, 27, 23, 6, 26, 5, 4, 31 }; + U32 v = val; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + return DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; +# endif + } +} + +/*===== Local Constants =====*/ +static const unsigned BIT_mask[] = { + 0, 1, 3, 7, 0xF, 0x1F, + 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, + 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, 0x1FFFF, + 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF, + 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF, + 0x3FFFFFFF, 0x7FFFFFFF}; /* up to 31 bits */ +#define BIT_MASK_SIZE (sizeof(BIT_mask) / sizeof(BIT_mask[0])) + +/*-************************************************************** +* bitStream encoding +****************************************************************/ +/*! BIT_initCStream() : + * `dstCapacity` must be > sizeof(size_t) + * @return : 0 if success, + * otherwise an error code (can be tested using ERR_isError()) */ +MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, + void* startPtr, size_t dstCapacity) +{ + bitC->bitContainer = 0; + bitC->bitPos = 0; + bitC->startPtr = (char*)startPtr; + bitC->ptr = bitC->startPtr; + bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer); + if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall); + return 0; +} + +/*! BIT_addBits() : + * can add up to 31 bits into `bitC`. + * Note : does not check for register overflow ! */ +MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC, + size_t value, unsigned nbBits) +{ + MEM_STATIC_ASSERT(BIT_MASK_SIZE == 32); + assert(nbBits < BIT_MASK_SIZE); + assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8); + bitC->bitContainer |= (value & BIT_mask[nbBits]) << bitC->bitPos; + bitC->bitPos += nbBits; +} + +/*! BIT_addBitsFast() : + * works only if `value` is _clean_, + * meaning all high bits above nbBits are 0 */ +MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, + size_t value, unsigned nbBits) +{ + assert((value>>nbBits) == 0); + assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8); + bitC->bitContainer |= value << bitC->bitPos; + bitC->bitPos += nbBits; +} + +/*! BIT_flushBitsFast() : + * assumption : bitContainer has not overflowed + * unsafe version; does not check buffer overflow */ +MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC) +{ + size_t const nbBytes = bitC->bitPos >> 3; + assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8); + MEM_writeLEST(bitC->ptr, bitC->bitContainer); + bitC->ptr += nbBytes; + assert(bitC->ptr <= bitC->endPtr); + bitC->bitPos &= 7; + bitC->bitContainer >>= nbBytes*8; +} + +/*! BIT_flushBits() : + * assumption : bitContainer has not overflowed + * safe version; check for buffer overflow, and prevents it. + * note : does not signal buffer overflow. + * overflow will be revealed later on using BIT_closeCStream() */ +MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC) +{ + size_t const nbBytes = bitC->bitPos >> 3; + assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8); + MEM_writeLEST(bitC->ptr, bitC->bitContainer); + bitC->ptr += nbBytes; + if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr; + bitC->bitPos &= 7; + bitC->bitContainer >>= nbBytes*8; +} + +/*! BIT_closeCStream() : + * @return : size of CStream, in bytes, + * or 0 if it could not fit into dstBuffer */ +MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC) +{ + BIT_addBitsFast(bitC, 1, 1); /* endMark */ + BIT_flushBits(bitC); + if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */ + return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0); +} + + +/*-******************************************************** +* bitStream decoding +**********************************************************/ +/*! BIT_initDStream() : + * Initialize a BIT_DStream_t. + * `bitD` : a pointer to an already allocated BIT_DStream_t structure. + * `srcSize` must be the *exact* size of the bitStream, in bytes. + * @return : size of stream (== srcSize), or an errorCode if a problem is detected + */ +MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize) +{ + if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } + + bitD->start = (const char*)srcBuffer; + bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); + + if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */ + bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); + bitD->bitContainer = MEM_readLEST(bitD->ptr); + { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; + bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */ + if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ } + } else { + bitD->ptr = bitD->start; + bitD->bitContainer = *(const BYTE*)(bitD->start); + switch(srcSize) + { + case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16); + /* fall-through */ + + case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24); + /* fall-through */ + + case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32); + /* fall-through */ + + case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; + /* fall-through */ + + case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; + /* fall-through */ + + case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8; + /* fall-through */ + + default: break; + } + { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; + bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; + if (lastByte == 0) return ERROR(corruption_detected); /* endMark not present */ + } + bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; + } + + return srcSize; +} + +MEM_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start) +{ + return bitContainer >> start; +} + +MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits) +{ + U32 const regMask = sizeof(bitContainer)*8 - 1; + /* if start > regMask, bitstream is corrupted, and result is undefined */ + assert(nbBits < BIT_MASK_SIZE); + return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; +} + +MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits) +{ + assert(nbBits < BIT_MASK_SIZE); + return bitContainer & BIT_mask[nbBits]; +} + +/*! BIT_lookBits() : + * Provides next n bits from local register. + * local register is not modified. + * On 32-bits, maxNbBits==24. + * On 64-bits, maxNbBits==56. + * @return : value extracted */ +MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits) +{ + /* arbitrate between double-shift and shift+mask */ +#if 1 + /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8, + * bitstream is likely corrupted, and result is undefined */ + return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); +#else ... 20921 lines suppressed ...
-
Pierre Schweitzer