Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 07:02:56 +00:00
Code Issues Projects Releases Packages Wiki Activity

[BTRFS] Upgrade to 1.4

Browse source 
CORE-16354
This commit is contained in:
Pierre Schweitzer 2019-09-01 14:53:20 +02:00
parent a0592b71e9
commit 318da0c18c
No known key found for this signature in database
GPG key ID: 7545556C3D585B0B
43 changed files with 7554 additions and 6744 deletions
Download patch file Download diff file Expand all files Collapse all files

8
dll/shellext/shellbtrfs/contextmenu.cpp
View file

@ -542,7 +542,7 @@ void BtrfsContextMenu::reflink_copy(HWND hwnd, const WCHAR* fn, const WCHAR* dir
wstring dirw, newpath;
FILE_BASIC_INFO fbi;
FILETIME atime, mtime;
btrfs_inode_info2 bii;
btrfs_inode_info bii;
btrfs_set_inode_info bsii;
ULONG bytesret;
NTSTATUS Status;
@ -575,7 +575,7 @@ void BtrfsContextMenu::reflink_copy(HWND hwnd, const WCHAR* fn, const WCHAR* dir
if (source == INVALID_HANDLE_VALUE)
throw last_error(GetLastError());
Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info2));
Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info));
if (!NT_SUCCESS(Status))
throw ntstatus_error(Status);
@ -1302,7 +1302,7 @@ static void reflink_copy2(const wstring& srcfn, const wstring& destdir, const ws
win_handle source, dest;
FILE_BASIC_INFO fbi;
FILETIME atime, mtime;
btrfs_inode_info2 bii;
btrfs_inode_info bii;
btrfs_set_inode_info bsii;
ULONG bytesret;
NTSTATUS Status;
@ -1313,7 +1313,7 @@ static void reflink_copy2(const wstring& srcfn, const wstring& destdir, const ws
if (source == INVALID_HANDLE_VALUE)
throw last_error(GetLastError());
Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info2));
Status = NtFsControlFile(source, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii, sizeof(btrfs_inode_info));
if (!NT_SUCCESS(Status))
throw ntstatus_error(Status);

16
dll/shellext/shellbtrfs/propsheet.cpp
View file

@ -111,11 +111,11 @@ void BtrfsPropSheet::do_search(const wstring& fn) {
if (fh != INVALID_HANDLE_VALUE) {
NTSTATUS Status;
IO_STATUS_BLOCK iosb;
btrfs_inode_info2 bii2;
btrfs_inode_info bii2;
memset(&bii2, 0, sizeof(bii2));
Status = NtFsControlFile(fh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info2));
Status = NtFsControlFile(fh, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info));
if (NT_SUCCESS(Status)) {
sizes[0] += bii2.inline_length;
@ -167,7 +167,7 @@ HRESULT BtrfsPropSheet::check_file(const wstring& fn, UINT i, UINT num_files, UI
NTSTATUS Status;
FILE_ACCESS_INFORMATION fai;
BY_HANDLE_FILE_INFORMATION bhfi;
btrfs_inode_info2 bii2;
btrfs_inode_info bii2;
h = CreateFileW(fn.c_str(), MAXIMUM_ALLOWED, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
@ -192,7 +192,7 @@ HRESULT BtrfsPropSheet::check_file(const wstring& fn, UINT i, UINT num_files, UI
memset(&bii2, 0, sizeof(bii2));
Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info2));
Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info));
if (NT_SUCCESS(Status) && !bii2.top) {
LARGE_INTEGER filesize;
@ -396,7 +396,7 @@ void BtrfsPropSheet::set_cmdline(const wstring& cmdline) {
NTSTATUS Status;
UINT sv = 0;
BY_HANDLE_FILE_INFORMATION bhfi;
btrfs_inode_info2 bii2;
btrfs_inode_info bii2;
FILE_ACCESS_INFORMATION fai;
min_mode = 0;
@ -430,7 +430,7 @@ void BtrfsPropSheet::set_cmdline(const wstring& cmdline) {
memset(&bii2, 0, sizeof(bii2));
Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info2));
Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info));
if (NT_SUCCESS(Status) && !bii2.top) {
LARGE_INTEGER filesize;
@ -583,7 +583,7 @@ void BtrfsPropSheet::apply_changes_file(HWND hDlg, const wstring& fn) {
IO_STATUS_BLOCK iosb;
NTSTATUS Status;
btrfs_set_inode_info bsii;
btrfs_inode_info2 bii2;
btrfs_inode_info bii2;
ULONG perms = FILE_TRAVERSE | FILE_READ_ATTRIBUTES;
if (flags_changed || ro_changed)
@ -603,7 +603,7 @@ void BtrfsPropSheet::apply_changes_file(HWND hDlg, const wstring& fn) {
ZeroMemory(&bsii, sizeof(btrfs_set_inode_info));
Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info2));
Status = NtFsControlFile(h, nullptr, nullptr, nullptr, &iosb, FSCTL_BTRFS_GET_INODE_INFO, nullptr, 0, &bii2, sizeof(btrfs_inode_info));
if (!NT_SUCCESS(Status))
throw ntstatus_error(Status);

4
drivers/filesystems/btrfs/CMakeLists.txt
View file

@ -5,6 +5,7 @@ include_directories(${REACTOS_SOURCE_DIR}/sdk/include/reactos/drivers
list(APPEND SOURCE
balance.c
boot.c
btrfs.c
cache.c
calcthread.c
@ -19,6 +20,7 @@ list(APPEND SOURCE
flushthread.c
free-space.c
fsctl.c
fsrtl.c
galois.c
guid.c
pnp.c
@ -55,6 +57,6 @@ add_library(btrfs MODULE ${SOURCE} btrfs.rc)
add_definitions(-D__KERNEL__)
set_module_type(btrfs kernelmodedriver)
target_link_libraries(btrfs rtlver ntoskrnl_vista zlib_solo chkstk wdmguid ${PSEH_LIB})
target_link_libraries(btrfs rtlver zlib_solo chkstk wdmguid ${PSEH_LIB})
add_importlibs(btrfs ntoskrnl hal)
add_cd_file(TARGET btrfs DESTINATION reactos/system32/drivers NO_CAB FOR all)

638
drivers/filesystems/btrfs/balance.c
View file

File diff suppressed because it is too large Load diff

248
drivers/filesystems/btrfs/boot.c Executable file
View file

@ -0,0 +1,248 @@
/* Copyright (c) Mark Harmstone 2019
*
* This file is part of WinBtrfs.
*
* WinBtrfs is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public Licence as published by
* the Free Software Foundation, either version 3 of the Licence, or
* (at your option) any later version.
*
* WinBtrfs is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public Licence for more details.
*
* You should have received a copy of the GNU Lesser General Public Licence
* along with WinBtrfs. If not, see <http://www.gnu.org/licenses/>. */
#include "btrfs_drv.h"
#ifndef __REACTOS__
#ifdef _MSC_VER
#include <ntstrsafe.h>
#endif
#else
#include <ntstrsafe.h>
#endif
extern ERESOURCE pdo_list_lock;
extern LIST_ENTRY pdo_list;
#ifndef _MSC_VER
NTSTATUS RtlUnicodeStringPrintf(PUNICODE_STRING DestinationString, const WCHAR* pszFormat, ...); // not in mingw
#endif
static bool get_system_root_partition(uint32_t* disk_num, uint32_t* partition_num) {
NTSTATUS Status;
HANDLE h;
UNICODE_STRING us, target;
OBJECT_ATTRIBUTES objatt;
WCHAR* s;
ULONG retlen = 0, left;
static const WCHAR system_root[] = L"\\SystemRoot";
static const WCHAR arc_prefix[] = L"\\ArcName\\multi(0)disk(0)rdisk(";
static const WCHAR arc_middle[] = L")partition(";
us.Buffer = (WCHAR*)system_root;
us.Length = us.MaximumLength = sizeof(system_root) - sizeof(WCHAR);
InitializeObjectAttributes(&objatt, &us, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
Status = ZwOpenSymbolicLinkObject(&h, GENERIC_READ, &objatt);
if (!NT_SUCCESS(Status)) {
ERR("ZwOpenSymbolicLinkObject returned %08x\n", Status);
return false;
}
target.Length = target.MaximumLength = 0;
Status = ZwQuerySymbolicLinkObject(h, &target, &retlen);
if (Status != STATUS_BUFFER_TOO_SMALL) {
ERR("ZwQuerySymbolicLinkObject returned %08x\n", Status);
NtClose(h);
return false;
}
if (retlen == 0) {
NtClose(h);
return false;
}
target.Buffer = ExAllocatePoolWithTag(NonPagedPool, retlen, ALLOC_TAG);
if (!target.Buffer) {
ERR("out of memory\n");
NtClose(h);
return false;
}
target.Length = target.MaximumLength = (USHORT)retlen;
Status = ZwQuerySymbolicLinkObject(h, &target, NULL);
if (!NT_SUCCESS(Status)) {
ERR("ZwQuerySymbolicLinkObject returned %08x\n", Status);
NtClose(h);
ExFreePool(target.Buffer);
return false;
}
NtClose(h);
TRACE("system root is %.*S\n", target.Length / sizeof(WCHAR), target.Buffer);
if (target.Length <= sizeof(arc_prefix) - sizeof(WCHAR) ||
RtlCompareMemory(target.Buffer, arc_prefix, sizeof(arc_prefix) - sizeof(WCHAR)) != sizeof(arc_prefix) - sizeof(WCHAR)) {
ExFreePool(target.Buffer);
return false;
}
s = &target.Buffer[(sizeof(arc_prefix) / sizeof(WCHAR)) - 1];
left = ((target.Length - sizeof(arc_prefix)) / sizeof(WCHAR)) + 1;
if (left == 0 || s[0] < '0' || s[0] > '9') {
ExFreePool(target.Buffer);
return false;
}
*disk_num = 0;
while (left > 0 && s[0] >= '0' && s[0] <= '9') {
*disk_num *= 10;
*disk_num += s[0] - '0';
s++;
left--;
}
if (left <= (sizeof(arc_middle) / sizeof(WCHAR)) - 1 ||
RtlCompareMemory(s, arc_middle, sizeof(arc_middle) - sizeof(WCHAR)) != sizeof(arc_middle) - sizeof(WCHAR)) {
ExFreePool(target.Buffer);
return false;
}
s = &s[(sizeof(arc_middle) / sizeof(WCHAR)) - 1];
left -= (sizeof(arc_middle) / sizeof(WCHAR)) - 1;
if (left == 0 || s[0] < '0' || s[0] > '9') {
ExFreePool(target.Buffer);
return false;
}
*partition_num = 0;
while (left > 0 && s[0] >= '0' && s[0] <= '9') {
*partition_num *= 10;
*partition_num += s[0] - '0';
s++;
left--;
}
ExFreePool(target.Buffer);
return true;
}
static void change_symlink(uint32_t disk_num, uint32_t partition_num, BTRFS_UUID* uuid) {
NTSTATUS Status;
UNICODE_STRING us, us2;
WCHAR symlink[60], target[(sizeof(BTRFS_VOLUME_PREFIX) / sizeof(WCHAR)) + 36], *w;
#ifdef __REACTOS__
unsigned int i;
#endif
us.Buffer = symlink;
us.Length = 0;
us.MaximumLength = sizeof(symlink);
Status = RtlUnicodeStringPrintf(&us, L"\\Device\\Harddisk%u\\Partition%u", disk_num, partition_num);
if (!NT_SUCCESS(Status)) {
ERR("RtlUnicodeStringPrintf returned %08x\n", Status);
return;
}
Status = IoDeleteSymbolicLink(&us);
if (!NT_SUCCESS(Status))
ERR("IoDeleteSymbolicLink returned %08x\n", Status);
RtlCopyMemory(target, BTRFS_VOLUME_PREFIX, sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR));
w = &target[(sizeof(BTRFS_VOLUME_PREFIX) / sizeof(WCHAR)) - 1];
#ifndef __REACTOS__
for (unsigned int i = 0; i < 16; i++) {
#else
for (i = 0; i < 16; i++) {
#endif
*w = hex_digit(uuid->uuid[i] >> 4); w++;
*w = hex_digit(uuid->uuid[i] & 0xf); w++;
if (i == 3 || i == 5 || i == 7 || i == 9) {
*w = L'-';
w++;
}
}
*w = L'}';
us2.Buffer = target;
us2.Length = us2.MaximumLength = sizeof(target);
Status = IoCreateSymbolicLink(&us, &us2);
if (!NT_SUCCESS(Status))
ERR("IoCreateSymbolicLink returned %08x\n", Status);
}
/* If booting from Btrfs, Windows will pass the device object for the raw partition to
* mount_vol - which is no good to us, as we only use the \Device\Btrfs{} devices we
* create so that RAID works correctly.
* At the time check_system_root gets called, \SystemRoot is a symlink to the ARC device,
* e.g. \ArcName\multi(0)disk(0)rdisk(0)partition(1)\Windows. We can't change the symlink,
* as it gets clobbered by IopReassignSystemRoot shortly afterwards, and we can't touch
* the \ArcName symlinks as they haven't been created yet. Instead, we need to change the
* symlink \Device\HarddiskX\PartitionY, which is what the ArcName symlink will shortly
* point to.
*/
void __stdcall check_system_root(PDRIVER_OBJECT DriverObject, PVOID Context, ULONG Count) {
uint32_t disk_num, partition_num;
LIST_ENTRY* le;
bool done = false;
TRACE("(%p, %p, %u)\n", DriverObject, Context, Count);
if (!get_system_root_partition(&disk_num, &partition_num))
return;
TRACE("system boot partition is disk %u, partition %u\n", disk_num, partition_num);
ExAcquireResourceSharedLite(&pdo_list_lock, true);
le = pdo_list.Flink;
while (le != &pdo_list) {
LIST_ENTRY* le2;
pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
le2 = pdode->children.Flink;
while (le2 != &pdode->children) {
volume_child* vc = CONTAINING_RECORD(le2, volume_child, list_entry);
if (vc->disk_num == disk_num && vc->part_num == partition_num) {
change_symlink(disk_num, partition_num, &pdode->uuid);
done = true;
break;
}
le2 = le2->Flink;
}
ExReleaseResourceLite(&pdode->child_lock);
if (done)
break;
le = le->Flink;
}
ExReleaseResourceLite(&pdo_list_lock);
}

1421
drivers/filesystems/btrfs/btrfs.c
View file

File diff suppressed because it is too large Load diff

419
drivers/filesystems/btrfs/btrfs.h
View file

@ -6,10 +6,11 @@
* you want with it. You don't have to, but I'd appreciate if you let me know if you
* use it anything cool - mark@harmstone.com. */
#ifndef BTRFS_H_DEFINED
#define BTRFS_H_DEFINED
#pragma once
static const UINT64 superblock_addrs[] = { 0x10000, 0x4000000, 0x4000000000, 0x4000000000000, 0 };
#include <stdint.h>
static const uint64_t superblock_addrs[] = { 0x10000, 0x4000000, 0x4000000000, 0x4000000000000, 0 };
#define BTRFS_MAGIC 0x4d5f53665248425f
#define MAX_LABEL_SIZE 0x100
@ -119,13 +120,13 @@ static const UINT64 superblock_addrs[] = { 0x10000, 0x4000000, 0x4000000000, 0x4
#pragma pack(push, 1)
typedef struct {
UINT8 uuid[16];
uint8_t uuid[16];
} BTRFS_UUID;
typedef struct {
UINT64 obj_id;
UINT8 obj_type;
UINT64 offset;
uint64_t obj_id;
uint8_t obj_type;
uint64_t offset;
} KEY;
#define HEADER_FLAG_WRITTEN 0x000000000000001
@ -133,42 +134,42 @@ typedef struct {
#define HEADER_FLAG_MIXED_BACKREF 0x100000000000000
typedef struct {
UINT8 csum[32];
uint8_t csum[32];
BTRFS_UUID fs_uuid;
UINT64 address;
UINT64 flags;
uint64_t address;
uint64_t flags;
BTRFS_UUID chunk_tree_uuid;
UINT64 generation;
UINT64 tree_id;
UINT32 num_items;
UINT8 level;
uint64_t generation;
uint64_t tree_id;
uint32_t num_items;
uint8_t level;
} tree_header;
typedef struct {
KEY key;
UINT32 offset;
UINT32 size;
uint32_t offset;
uint32_t size;
} leaf_node;
typedef struct {
KEY key;
UINT64 address;
UINT64 generation;
uint64_t address;
uint64_t generation;
} internal_node;
typedef struct {
UINT64 dev_id;
UINT64 num_bytes;
UINT64 bytes_used;
UINT32 optimal_io_align;
UINT32 optimal_io_width;
UINT32 minimal_io_size;
UINT64 type;
UINT64 generation;
UINT64 start_offset;
UINT32 dev_group;
UINT8 seek_speed;
UINT8 bandwidth;
uint64_t dev_id;
uint64_t num_bytes;
uint64_t bytes_used;
uint32_t optimal_io_align;
uint32_t optimal_io_width;
uint32_t minimal_io_size;
uint64_t type;
uint64_t generation;
uint64_t start_offset;
uint32_t dev_group;
uint8_t seek_speed;
uint8_t bandwidth;
BTRFS_UUID device_uuid;
BTRFS_UUID fs_uuid;
} DEV_ITEM;
@ -177,67 +178,67 @@ typedef struct {
#define BTRFS_NUM_BACKUP_ROOTS 4
typedef struct {
UINT64 root_tree_addr;
UINT64 root_tree_generation;
UINT64 chunk_tree_addr;
UINT64 chunk_tree_generation;
UINT64 extent_tree_addr;
UINT64 extent_tree_generation;
UINT64 fs_tree_addr;
UINT64 fs_tree_generation;
UINT64 dev_root_addr;
UINT64 dev_root_generation;
UINT64 csum_root_addr;
UINT64 csum_root_generation;
UINT64 total_bytes;
UINT64 bytes_used;
UINT64 num_devices;
UINT64 reserved[4];
UINT8 root_level;
UINT8 chunk_root_level;
UINT8 extent_root_level;
UINT8 fs_root_level;
UINT8 dev_root_level;
UINT8 csum_root_level;
UINT8 reserved2[10];
uint64_t root_tree_addr;
uint64_t root_tree_generation;
uint64_t chunk_tree_addr;
uint64_t chunk_tree_generation;
uint64_t extent_tree_addr;
uint64_t extent_tree_generation;
uint64_t fs_tree_addr;
uint64_t fs_tree_generation;
uint64_t dev_root_addr;
uint64_t dev_root_generation;
uint64_t csum_root_addr;
uint64_t csum_root_generation;
uint64_t total_bytes;
uint64_t bytes_used;
uint64_t num_devices;
uint64_t reserved[4];
uint8_t root_level;
uint8_t chunk_root_level;
uint8_t extent_root_level;
uint8_t fs_root_level;
uint8_t dev_root_level;
uint8_t csum_root_level;
uint8_t reserved2[10];
} superblock_backup;
typedef struct {
UINT8 checksum[32];
uint8_t checksum[32];
BTRFS_UUID uuid;
UINT64 sb_phys_addr;
UINT64 flags;
UINT64 magic;
UINT64 generation;
UINT64 root_tree_addr;
UINT64 chunk_tree_addr;
UINT64 log_tree_addr;
UINT64 log_root_transid;
UINT64 total_bytes;
UINT64 bytes_used;
UINT64 root_dir_objectid;
UINT64 num_devices;
UINT32 sector_size;
UINT32 node_size;
UINT32 leaf_size;
UINT32 stripe_size;
UINT32 n;
UINT64 chunk_root_generation;
UINT64 compat_flags;
UINT64 compat_ro_flags;
UINT64 incompat_flags;
UINT16 csum_type;
UINT8 root_level;
UINT8 chunk_root_level;
UINT8 log_root_level;
uint64_t sb_phys_addr;
uint64_t flags;
uint64_t magic;
uint64_t generation;
uint64_t root_tree_addr;
uint64_t chunk_tree_addr;
uint64_t log_tree_addr;
uint64_t log_root_transid;
uint64_t total_bytes;
uint64_t bytes_used;
uint64_t root_dir_objectid;
uint64_t num_devices;
uint32_t sector_size;
uint32_t node_size;
uint32_t leaf_size;
uint32_t stripe_size;
uint32_t n;
uint64_t chunk_root_generation;
uint64_t compat_flags;
uint64_t compat_ro_flags;
uint64_t incompat_flags;
uint16_t csum_type;
uint8_t root_level;
uint8_t chunk_root_level;
uint8_t log_root_level;
DEV_ITEM dev_item;
char label[MAX_LABEL_SIZE];
UINT64 cache_generation;
UINT64 uuid_tree_generation;
UINT64 reserved[30];
UINT8 sys_chunk_array[SYS_CHUNK_ARRAY_SIZE];
uint64_t cache_generation;
uint64_t uuid_tree_generation;
uint64_t reserved[30];
uint8_t sys_chunk_array[SYS_CHUNK_ARRAY_SIZE];
superblock_backup backup[BTRFS_NUM_BACKUP_ROOTS];
UINT8 reserved2[565];
uint8_t reserved2[565];
} superblock;
#define BTRFS_TYPE_UNKNOWN 0
@ -252,32 +253,32 @@ typedef struct {
typedef struct {
KEY key;
UINT64 transid;
UINT16 m;
UINT16 n;
UINT8 type;
uint64_t transid;
uint16_t m;
uint16_t n;
uint8_t type;
char name[1];
} DIR_ITEM;
typedef struct {
UINT64 seconds;
UINT32 nanoseconds;
uint64_t seconds;
uint32_t nanoseconds;
} BTRFS_TIME;
typedef struct {
UINT64 generation;
UINT64 transid;
UINT64 st_size;
UINT64 st_blocks;
UINT64 block_group;
UINT32 st_nlink;
UINT32 st_uid;
UINT32 st_gid;
UINT32 st_mode;
UINT64 st_rdev;
UINT64 flags;
UINT64 sequence;
UINT8 reserved[32];
uint64_t generation;
uint64_t transid;
uint64_t st_size;
uint64_t st_blocks;
uint64_t block_group;
uint32_t st_nlink;
uint32_t st_uid;
uint32_t st_gid;
uint32_t st_mode;
uint64_t st_rdev;
uint64_t flags;
uint64_t sequence;
uint8_t reserved[32];
BTRFS_TIME st_atime;
BTRFS_TIME st_ctime;
BTRFS_TIME st_mtime;
@ -286,77 +287,77 @@ typedef struct {
typedef struct {
INODE_ITEM inode;
UINT64 generation;
UINT64 objid;
UINT64 block_number;
UINT64 byte_limit;
UINT64 bytes_used;
UINT64 last_snapshot_generation;
UINT64 flags;
UINT32 num_references;
uint64_t generation;
uint64_t objid;
uint64_t block_number;
uint64_t byte_limit;
uint64_t bytes_used;
uint64_t last_snapshot_generation;
uint64_t flags;
uint32_t num_references;
KEY drop_progress;
UINT8 drop_level;
UINT8 root_level;
UINT64 generation2;
uint8_t drop_level;
uint8_t root_level;
uint64_t generation2;
BTRFS_UUID uuid;
BTRFS_UUID parent_uuid;
BTRFS_UUID received_uuid;
UINT64 ctransid;
UINT64 otransid;
UINT64 stransid;
UINT64 rtransid;
uint64_t ctransid;
uint64_t otransid;
uint64_t stransid;
uint64_t rtransid;
BTRFS_TIME ctime;
BTRFS_TIME otime;
BTRFS_TIME stime;
BTRFS_TIME rtime;
UINT64 reserved[8];
uint64_t reserved[8];
} ROOT_ITEM;
typedef struct {
UINT64 size;
UINT64 root_id;
UINT64 stripe_length;
UINT64 type;
UINT32 opt_io_alignment;
UINT32 opt_io_width;
UINT32 sector_size;
UINT16 num_stripes;
UINT16 sub_stripes;
uint64_t size;
uint64_t root_id;
uint64_t stripe_length;
uint64_t type;
uint32_t opt_io_alignment;
uint32_t opt_io_width;
uint32_t sector_size;
uint16_t num_stripes;
uint16_t sub_stripes;
} CHUNK_ITEM;
typedef struct {
UINT64 dev_id;
UINT64 offset;
uint64_t dev_id;
uint64_t offset;
BTRFS_UUID dev_uuid;
} CHUNK_ITEM_STRIPE;
typedef struct {
UINT64 generation;
UINT64 decoded_size;
UINT8 compression;
UINT8 encryption;
UINT16 encoding;
UINT8 type;
UINT8 data[1];
uint64_t generation;
uint64_t decoded_size;
uint8_t compression;
uint8_t encryption;
uint16_t encoding;
uint8_t type;
uint8_t data[1];
} EXTENT_DATA;
typedef struct {
UINT64 address;
UINT64 size;
UINT64 offset;
UINT64 num_bytes;
uint64_t address;
uint64_t size;
uint64_t offset;
uint64_t num_bytes;
} EXTENT_DATA2;
typedef struct {
UINT64 index;
UINT16 n;
uint64_t index;
uint16_t n;
char name[1];
} INODE_REF;
typedef struct {
UINT64 dir;
UINT64 index;
UINT16 n;
uint64_t dir;
uint64_t index;
uint16_t n;
char name[1];
} INODE_EXTREF;
@ -365,87 +366,87 @@ typedef struct {
#define EXTENT_ITEM_SHARED_BACKREFS 0x100
typedef struct {
UINT64 refcount;
UINT64 generation;
UINT64 flags;
uint64_t refcount;
uint64_t generation;
uint64_t flags;
} EXTENT_ITEM;
typedef struct {
KEY firstitem;
UINT8 level;
uint8_t level;
} EXTENT_ITEM2;
typedef struct {
UINT32 refcount;
uint32_t refcount;
} EXTENT_ITEM_V0;
typedef struct {
EXTENT_ITEM extent_item;
KEY firstitem;
UINT8 level;
uint8_t level;
} EXTENT_ITEM_TREE;
typedef struct {
UINT64 offset;
uint64_t offset;
} TREE_BLOCK_REF;
typedef struct {
UINT64 root;
UINT64 objid;
UINT64 offset;
UINT32 count;
uint64_t root;
uint64_t objid;
uint64_t offset;
uint32_t count;
} EXTENT_DATA_REF;
typedef struct {
UINT64 used;
UINT64 chunk_tree;
UINT64 flags;
uint64_t used;
uint64_t chunk_tree;
uint64_t flags;
} BLOCK_GROUP_ITEM;
typedef struct {
UINT64 root;
UINT64 gen;
UINT64 objid;
UINT32 count;
uint64_t root;
uint64_t gen;
uint64_t objid;
uint32_t count;
} EXTENT_REF_V0;
typedef struct {
UINT64 offset;
uint64_t offset;
} SHARED_BLOCK_REF;
typedef struct {
UINT64 offset;
UINT32 count;
uint64_t offset;
uint32_t count;
} SHARED_DATA_REF;
#define FREE_SPACE_EXTENT 1
#define FREE_SPACE_BITMAP 2
typedef struct {
UINT64 offset;
UINT64 size;
UINT8 type;
uint64_t offset;
uint64_t size;
uint8_t type;
} FREE_SPACE_ENTRY;
typedef struct {
KEY key;
UINT64 generation;
UINT64 num_entries;
UINT64 num_bitmaps;
uint64_t generation;
uint64_t num_entries;
uint64_t num_bitmaps;
} FREE_SPACE_ITEM;
typedef struct {
UINT64 dir;
UINT64 index;
UINT16 n;
uint64_t dir;
uint64_t index;
uint16_t n;
char name[1];
} ROOT_REF;
typedef struct {
UINT64 chunktree;
UINT64 objid;
UINT64 address;
UINT64 length;
uint64_t chunktree;
uint64_t objid;
uint64_t address;
uint64_t length;
BTRFS_UUID chunktree_uuid;
} DEV_EXTENT;
@ -466,50 +467,50 @@ typedef struct {
#define BALANCE_ARGS_FLAGS_USAGE_RANGE 0x400
typedef struct {
UINT64 profiles;
uint64_t profiles;
union {
UINT64 usage;
uint64_t usage;
struct {
UINT32 usage_start;
UINT32 usage_end;
uint32_t usage_start;
uint32_t usage_end;
};
};
UINT64 devid;
UINT64 drange_start;
UINT64 drange_end;
UINT64 vrange_start;
UINT64 vrange_end;
UINT64 convert;
UINT64 flags;
uint64_t devid;
uint64_t drange_start;
uint64_t drange_end;
uint64_t vrange_start;
uint64_t vrange_end;
uint64_t convert;
uint64_t flags;
union {
UINT64 limit;
uint64_t limit;
struct {
UINT32 limit_start;
UINT32 limit_end;
uint32_t limit_start;
uint32_t limit_end;
};
};
UINT32 stripes_start;
UINT32 stripes_end;
UINT8 reserved[48];
uint32_t stripes_start;
uint32_t stripes_end;
uint8_t reserved[48];
} BALANCE_ARGS;
typedef struct {
UINT64 flags;
uint64_t flags;
BALANCE_ARGS data;
BALANCE_ARGS metadata;
BALANCE_ARGS system;
UINT8 reserved[32];
uint8_t reserved[32];
} BALANCE_ITEM;
#define BTRFS_FREE_SPACE_USING_BITMAPS 1
typedef struct {
UINT32 count;
UINT32 flags;
uint32_t count;
uint32_t flags;
} FREE_SPACE_INFO;
#define BTRFS_DEV_STAT_WRITE_ERRORS 0
@ -569,21 +570,19 @@ typedef struct {
#define BTRFS_SEND_MAGIC "btrfs-stream"
typedef struct {
UINT8 magic[13];
UINT32 version;
uint8_t magic[13];
uint32_t version;
} btrfs_send_header;
typedef struct {
UINT32 length;
UINT16 cmd;
UINT32 csum;
uint32_t length;
uint16_t cmd;
uint32_t csum;
} btrfs_send_command;
typedef struct {
UINT16 type;
UINT16 length;
uint16_t type;
uint16_t length;
} btrfs_send_tlv;
#pragma pack(pop)
#endif

8
drivers/filesystems/btrfs/btrfs.rc
View file

@ -51,8 +51,8 @@ END
//
VS_VERSION_INFO VERSIONINFO
FILEVERSION 1,3,0,0
PRODUCTVERSION 1,3,0,0
FILEVERSION 1,4,0,0
PRODUCTVERSION 1,4,0,0
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
@ -68,12 +68,12 @@ BEGIN
BLOCK "080904b0"
BEGIN
VALUE "FileDescription", "WinBtrfs"
VALUE "FileVersion", "1.3"
VALUE "FileVersion", "1.4"
VALUE "InternalName", "btrfs"
VALUE "LegalCopyright", "Copyright (c) Mark Harmstone 2016-19"
VALUE "OriginalFilename", "btrfs.sys"
VALUE "ProductName", "WinBtrfs"
VALUE "ProductVersion", "1.3"
VALUE "ProductVersion", "1.4"
END
END
BLOCK "VarFileInfo"

929
drivers/filesystems/btrfs/btrfs_drv.h
View file

File diff suppressed because it is too large Load diff

179
drivers/filesystems/btrfs/btrfsioctl.h
View file

@ -1,7 +1,6 @@
// No copyright claimed in this file - do what you want with it.
#ifndef BTRFSIOCTL_H_DEFINED
#define BTRFSIOCTL_H_DEFINED
#pragma once
#include "btrfs.h"
@ -39,8 +38,8 @@
#define FSCTL_BTRFS_RESIZE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x848, METHOD_IN_DIRECT, FILE_ANY_ACCESS)
typedef struct {
UINT64 subvol;
UINT64 inode;
uint64_t subvol;
uint64_t inode;
BOOL top;
} btrfs_get_file_ids;
@ -48,7 +47,7 @@ typedef struct {
HANDLE subvol;
BOOL readonly;
BOOL posix;
UINT16 namelen;
uint16_t namelen;
WCHAR name[1];
} btrfs_create_snapshot;
@ -56,7 +55,7 @@ typedef struct {
void* POINTER_32 subvol;
BOOL readonly;
BOOL posix;
UINT16 namelen;
uint16_t namelen;
WCHAR name[1];
} btrfs_create_snapshot32;
@ -66,77 +65,63 @@ typedef struct {
#define BTRFS_COMPRESSION_ZSTD 3
typedef struct {
UINT64 subvol;
UINT64 inode;
uint64_t subvol;
uint64_t inode;
BOOL top;
UINT8 type;
UINT32 st_uid;
UINT32 st_gid;
UINT32 st_mode;
UINT64 st_rdev;
UINT64 flags;
UINT32 inline_length;
UINT64 disk_size[3];
UINT8 compression_type;
uint8_t type;
uint32_t st_uid;
uint32_t st_gid;
uint32_t st_mode;
uint64_t st_rdev;
uint64_t flags;
uint32_t inline_length;
uint64_t disk_size_uncompressed;
uint64_t disk_size_zlib;
uint64_t disk_size_lzo;
uint8_t compression_type;
uint64_t disk_size_zstd;
uint64_t sparse_size;
uint32_t num_extents;
} btrfs_inode_info;
typedef struct {
UINT64 subvol;
UINT64 inode;
BOOL top;
UINT8 type;
UINT32 st_uid;
UINT32 st_gid;
UINT32 st_mode;
UINT64 st_rdev;
UINT64 flags;
UINT32 inline_length;
UINT64 disk_size_uncompressed;
UINT64 disk_size_zlib;
UINT64 disk_size_lzo;
UINT8 compression_type;
UINT64 disk_size_zstd;
UINT64 sparse_size;
} btrfs_inode_info2;
typedef struct {
UINT64 flags;
uint64_t flags;
BOOL flags_changed;
UINT32 st_uid;
uint32_t st_uid;
BOOL uid_changed;
UINT32 st_gid;
uint32_t st_gid;
BOOL gid_changed;
UINT32 st_mode;
uint32_t st_mode;
BOOL mode_changed;
UINT8 compression_type;
uint8_t compression_type;
BOOL compression_type_changed;
} btrfs_set_inode_info;
typedef struct {
UINT32 next_entry;
UINT64 dev_id;
UINT64 size;
UINT64 max_size;
uint32_t next_entry;
uint64_t dev_id;
uint64_t size;
uint64_t max_size;
BOOL readonly;
BOOL missing;
ULONG device_number;
ULONG partition_number;
UINT64 stats[5];
uint64_t stats[5];
USHORT namelen;
WCHAR name[1];
} btrfs_device;
typedef struct {
UINT64 dev_id;
UINT64 alloc;
uint64_t dev_id;
uint64_t alloc;
} btrfs_usage_device;
typedef struct {
UINT32 next_entry;
UINT64 type;
UINT64 size;
UINT64 used;
UINT64 num_devices;
uint32_t next_entry;
uint64_t type;
uint64_t size;
uint64_t used;
uint64_t num_devices;
btrfs_usage_device devices[1];
} btrfs_usage;
@ -154,20 +139,20 @@ typedef struct {
#define BLOCK_FLAG_SINGLE 0x1000000000000 // only used in balance
typedef struct {
UINT64 flags;
UINT64 profiles;
UINT64 devid;
UINT64 drange_start;
UINT64 drange_end;
UINT64 vrange_start;
UINT64 vrange_end;
UINT64 limit_start;
UINT64 limit_end;
UINT16 stripes_start;
UINT16 stripes_end;
UINT8 usage_start;
UINT8 usage_end;
UINT64 convert;
uint64_t flags;
uint64_t profiles;
uint64_t devid;
uint64_t drange_start;
uint64_t drange_end;
uint64_t vrange_start;
uint64_t vrange_end;
uint64_t limit_start;
uint64_t limit_end;
uint16_t stripes_start;
uint16_t stripes_end;
uint8_t usage_start;
uint8_t usage_end;
uint64_t convert;
} btrfs_balance_opts;
#define BTRFS_BALANCE_STOPPED 0
@ -178,9 +163,9 @@ typedef struct {
#define BTRFS_BALANCE_SHRINKING 16
typedef struct {
UINT32 status;
UINT64 chunks_left;
UINT64 total_chunks;
uint32_t status;
uint64_t chunks_left;
uint64_t total_chunks;
NTSTATUS error;
btrfs_balance_opts data_opts;
btrfs_balance_opts metadata_opts;
@ -192,16 +177,16 @@ typedef struct {
} btrfs_start_balance;
typedef struct {
UINT8 uuid[16];
uint8_t uuid[16];
BOOL missing;
USHORT name_length;
WCHAR name[1];
} btrfs_filesystem_device;
typedef struct {
UINT32 next_entry;
UINT8 uuid[16];
UINT32 num_devices;
uint32_t next_entry;
uint8_t uuid[16];
uint32_t num_devices;
btrfs_filesystem_device device;
} btrfs_filesystem;
@ -210,52 +195,52 @@ typedef struct {
#define BTRFS_SCRUB_PAUSED 2
typedef struct {
UINT32 next_entry;
UINT64 address;
UINT64 device;
uint32_t next_entry;
uint64_t address;
uint64_t device;
BOOL recovered;
BOOL is_metadata;
BOOL parity;
union {
struct {
UINT64 subvol;
UINT64 offset;
UINT16 filename_length;
uint64_t subvol;
uint64_t offset;
uint16_t filename_length;
WCHAR filename[1];
} data;
struct {
UINT64 root;
UINT8 level;
uint64_t root;
uint8_t level;
KEY firstitem;
} metadata;
};
} btrfs_scrub_error;
typedef struct {
UINT32 status;
uint32_t status;
LARGE_INTEGER start_time;
LARGE_INTEGER finish_time;
UINT64 chunks_left;
UINT64 total_chunks;
UINT64 data_scrubbed;
UINT64 duration;
uint64_t chunks_left;
uint64_t total_chunks;
uint64_t data_scrubbed;
uint64_t duration;
NTSTATUS error;
UINT32 num_errors;
uint32_t num_errors;
btrfs_scrub_error errors;
} btrfs_query_scrub;
typedef struct {
UINT64 inode;
UINT8 type;
UINT64 st_rdev;
UINT16 namelen;
uint64_t inode;
uint8_t type;
uint64_t st_rdev;
uint16_t namelen;
WCHAR name[1];
} btrfs_mknod;
typedef struct {
UINT64 generation;
uint64_t generation;
BTRFS_UUID uuid;
} btrfs_received_subvol;
@ -274,7 +259,7 @@ typedef struct {
typedef struct {
BTRFS_UUID uuid;
UINT64 ctransid;
uint64_t ctransid;
} btrfs_find_subvol;
typedef struct {
@ -290,8 +275,6 @@ typedef struct {
} btrfs_send_subvol32;
typedef struct {
UINT64 device;
UINT64 size;
uint64_t device;
uint64_t size;
} btrfs_resize;
#endif

34
drivers/filesystems/btrfs/cache.c
View file

@ -19,36 +19,28 @@
CACHE_MANAGER_CALLBACKS* cache_callbacks;
#ifdef __REACTOS__
static BOOLEAN NTAPI acquire_for_lazy_write(PVOID Context, BOOLEAN Wait) {
#else
static BOOLEAN acquire_for_lazy_write(PVOID Context, BOOLEAN Wait) {
#endif
static BOOLEAN __stdcall acquire_for_lazy_write(PVOID Context, BOOLEAN Wait) {
PFILE_OBJECT FileObject = Context;
fcb* fcb = FileObject->FsContext;
TRACE("(%p, %u)\n", Context, Wait);
if (!ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, Wait))
return FALSE;
return false;
if (!ExAcquireResourceExclusiveLite(fcb->Header.Resource, Wait)) {
ExReleaseResourceLite(&fcb->Vcb->tree_lock);
return FALSE;
return false;
}
fcb->lazy_writer_thread = KeGetCurrentThread();
IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
return TRUE;
return true;
}
#ifdef __REACTOS__
static void NTAPI release_from_lazy_write(PVOID Context) {
#else
static void release_from_lazy_write(PVOID Context) {
#endif
static void __stdcall release_from_lazy_write(PVOID Context) {
PFILE_OBJECT FileObject = Context;
fcb* fcb = FileObject->FsContext;
@ -64,29 +56,21 @@ static void release_from_lazy_write(PVOID Context) {
IoSetTopLevelIrp(NULL);
}
#ifdef __REACTOS__
static BOOLEAN NTAPI acquire_for_read_ahead(PVOID Context, BOOLEAN Wait) {
#else
static BOOLEAN acquire_for_read_ahead(PVOID Context, BOOLEAN Wait) {
#endif
static BOOLEAN __stdcall acquire_for_read_ahead(PVOID Context, BOOLEAN Wait) {
PFILE_OBJECT FileObject = Context;
fcb* fcb = FileObject->FsContext;
TRACE("(%p, %u)\n", Context, Wait);
if (!ExAcquireResourceSharedLite(fcb->Header.Resource, Wait))
return FALSE;
return false;
IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
return TRUE;
return true;
}
#ifdef __REACTOS__
static void NTAPI release_from_read_ahead(PVOID Context) {
#else
static void release_from_read_ahead(PVOID Context) {
#endif
static void __stdcall release_from_read_ahead(PVOID Context) {
PFILE_OBJECT FileObject = Context;
fcb* fcb = FileObject->FsContext;

44
drivers/filesystems/btrfs/calcthread.c
View file

@ -19,7 +19,7 @@
#define SECTOR_BLOCK 16
NTSTATUS add_calc_job(device_extension* Vcb, UINT8* data, UINT32 sectors, UINT32* csum, calc_job** pcj) {
NTSTATUS add_calc_job(device_extension* Vcb, uint8_t* data, uint32_t sectors, uint32_t* csum, calc_job** pcj) {
calc_job* cj;
cj = ExAllocatePoolWithTag(NonPagedPool, sizeof(calc_job), ALLOC_TAG);
@ -34,13 +34,13 @@ NTSTATUS add_calc_job(device_extension* Vcb, UINT8* data, UINT32 sectors, UINT32
cj->pos = 0;
cj->done = 0;
cj->refcount = 1;
KeInitializeEvent(&cj->event, NotificationEvent, FALSE);
KeInitializeEvent(&cj->event, NotificationEvent, false);
ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, TRUE);
ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, true);
InsertTailList(&Vcb->calcthreads.job_list, &cj->list_entry);
KeSetEvent(&Vcb->calcthreads.event, 0, FALSE);
KeSetEvent(&Vcb->calcthreads.event, 0, false);
KeClearEvent(&Vcb->calcthreads.event);
ExReleaseResourceLite(&Vcb->calcthreads.lock);
@ -57,16 +57,16 @@ void free_calc_job(calc_job* cj) {
ExFreePool(cj);
}
static BOOL do_calc(device_extension* Vcb, calc_job* cj) {
static bool do_calc(device_extension* Vcb, calc_job* cj) {
LONG pos, done;
UINT32* csum;
UINT8* data;
uint32_t* csum;
uint8_t* data;
ULONG blocksize, i;
pos = InterlockedIncrement(&cj->pos) - 1;
if ((UINT32)pos * SECTOR_BLOCK >= cj->sectors)
return FALSE;
if ((uint32_t)pos * SECTOR_BLOCK >= cj->sectors)
return false;
csum = &cj->csum[pos * SECTOR_BLOCK];
data = cj->data + (pos * SECTOR_BLOCK * Vcb->superblock.sector_size);
@ -80,36 +80,32 @@ static BOOL do_calc(device_extension* Vcb, calc_job* cj) {
done = InterlockedIncrement(&cj->done);
if ((UINT32)done * SECTOR_BLOCK >= cj->sectors) {
ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, TRUE);
if ((uint32_t)done * SECTOR_BLOCK >= cj->sectors) {
ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, true);
RemoveEntryList(&cj->list_entry);
ExReleaseResourceLite(&Vcb->calcthreads.lock);
KeSetEvent(&cj->event, 0, FALSE);
KeSetEvent(&cj->event, 0, false);
}
return TRUE;
return true;
}
_Function_class_(KSTART_ROUTINE)
#ifdef __REACTOS__
void NTAPI calc_thread(void* context) {
#else
void calc_thread(void* context) {
#endif
void __stdcall calc_thread(void* context) {
drv_calc_thread* thread = context;
device_extension* Vcb = thread->DeviceObject->DeviceExtension;
ObReferenceObject(thread->DeviceObject);
while (TRUE) {
KeWaitForSingleObject(&Vcb->calcthreads.event, Executive, KernelMode, FALSE, NULL);
while (true) {
KeWaitForSingleObject(&Vcb->calcthreads.event, Executive, KernelMode, false, NULL);
while (TRUE) {
while (true) {
calc_job* cj;
BOOL b;
bool b;
ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, TRUE);
ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, true);
if (IsListEmpty(&Vcb->calcthreads.job_list)) {
ExReleaseResourceLite(&Vcb->calcthreads.lock);
@ -135,7 +131,7 @@ void calc_thread(void* context) {
ObDereferenceObject(thread->DeviceObject);
KeSetEvent(&thread->finished, 0, FALSE);
KeSetEvent(&thread->finished, 0, false);
PsTerminateSystemThread(STATUS_SUCCESS);
}

266
drivers/filesystems/btrfs/compress.c
View file

@ -43,20 +43,20 @@
#include "zstd/zstd.h"
#define LINUX_PAGE_SIZE 4096
#define LZO_PAGE_SIZE 4096
typedef struct {
UINT8* in;
UINT32 inlen;
UINT32 inpos;
UINT8* out;
UINT32 outlen;
UINT32 outpos;
BOOL error;
uint8_t* in;
uint32_t inlen;
uint32_t inpos;
uint8_t* out;
uint32_t outlen;
uint32_t outpos;
bool error;
void* wrkmem;
} lzo_stream;
#define LZO1X_MEM_COMPRESS ((UINT32) (16384L * sizeof(UINT8*)))
#define LZO1X_MEM_COMPRESS ((uint32_t) (16384L * sizeof(uint8_t*)))
#define M1_MAX_OFFSET 0x0400
#define M2_MAX_OFFSET 0x0800
@ -70,8 +70,8 @@ typedef struct {
#define M3_MARKER 32
#define M4_MARKER 16
#define _DV2(p, shift1, shift2) (((( (UINT32)(p[2]) << shift1) ^ p[1]) << shift2) ^ p[0])
#define DVAL_NEXT(dv, p) dv ^= p[-1]; dv = (((dv) >> 5) ^ ((UINT32)(p[2]) << (2*5)))
#define _DV2(p, shift1, shift2) (((( (uint32_t)(p[2]) << shift1) ^ p[1]) << shift2) ^ p[0])
#define DVAL_NEXT(dv, p) dv ^= p[-1]; dv = (((dv) >> 5) ^ ((uint32_t)(p[2]) << (2*5)))
#define _DV(p, shift) _DV2(p, shift, shift)
#define DVAL_FIRST(dv, p) dv = _DV((p), 5)
#define _DINDEX(dv, p) ((40799u * (dv)) >> 5)
@ -81,7 +81,7 @@ typedef struct {
#define LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, max_offset) \
((void*) m_pos < (void*) in || \
(m_off = (UINT8*) ip - (UINT8*) m_pos) <= 0 || \
(m_off = (uint8_t*) ip - (uint8_t*) m_pos) <= 0 || \
m_off > max_offset)
#define LZO_BYTE(x) ((unsigned char) (x))
@ -100,11 +100,11 @@ ZSTD_customMem zstd_mem = { .customAlloc = zstd_malloc, .customFree = zstd_free,
ZSTD_customMem zstd_mem = { zstd_malloc, zstd_free, NULL };
#endif
static UINT8 lzo_nextbyte(lzo_stream* stream) {
UINT8 c;
static uint8_t lzo_nextbyte(lzo_stream* stream) {
uint8_t c;
if (stream->inpos >= stream->inlen) {
stream->error = TRUE;
stream->error = true;
return 0;
}
@ -132,12 +132,12 @@ static int lzo_len(lzo_stream* stream, int byte, int mask) {
static void lzo_copy(lzo_stream* stream, int len) {
if (stream->inpos + len > stream->inlen) {
stream->error = TRUE;
stream->error = true;
return;
}
if (stream->outpos + len > stream->outlen) {
stream->error = TRUE;
stream->error = true;
return;
}
@ -149,14 +149,14 @@ static void lzo_copy(lzo_stream* stream, int len) {
} while (len > 0);
}
static void lzo_copyback(lzo_stream* stream, UINT32 back, int len) {
static void lzo_copyback(lzo_stream* stream, uint32_t back, int len) {
if (stream->outpos < back) {
stream->error = TRUE;
stream->error = true;
return;
}
if (stream->outpos + len > stream->outlen) {
stream->error = TRUE;
stream->error = true;
return;
}
@ -168,17 +168,17 @@ static void lzo_copyback(lzo_stream* stream, UINT32 back, int len) {
}
static NTSTATUS do_lzo_decompress(lzo_stream* stream) {
UINT8 byte;
UINT32 len, back;
BOOL backcopy = FALSE;
uint8_t byte;
uint32_t len, back;
bool backcopy = false;
stream->error = FALSE;
stream->error = false;
byte = lzo_nextbyte(stream);
if (stream->error) return STATUS_INTERNAL_ERROR;
if (byte > 17) {
lzo_copy(stream, min((UINT8)(byte - 17), (UINT32)(stream->outlen - stream->outpos)));
lzo_copy(stream, min((uint8_t)(byte - 17), (uint32_t)(stream->outlen - stream->outpos)));
if (stream->error) return STATUS_INTERNAL_ERROR;
if (stream->outlen == stream->outpos)
@ -192,7 +192,7 @@ static NTSTATUS do_lzo_decompress(lzo_stream* stream) {
while (1) {
if (byte >> 4) {
backcopy = TRUE;
backcopy = true;
if (byte >> 6) {
len = (byte >> 5) - 1;
back = (lzo_nextbyte(stream) << 3) + ((byte >> 2) & 7) + 1;
@ -275,29 +275,29 @@ static NTSTATUS do_lzo_decompress(lzo_stream* stream) {
return STATUS_SUCCESS;
}
NTSTATUS lzo_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen, UINT32 inpageoff) {
NTSTATUS lzo_decompress(uint8_t* inbuf, uint32_t inlen, uint8_t* outbuf, uint32_t outlen, uint32_t inpageoff) {
NTSTATUS Status;
UINT32 partlen, inoff, outoff;
uint32_t partlen, inoff, outoff;
lzo_stream stream;
inoff = 0;
outoff = 0;
do {
partlen = *(UINT32*)&inbuf[inoff];
partlen = *(uint32_t*)&inbuf[inoff];
if (partlen + inoff > inlen) {
ERR("overflow: %x + %x > %llx\n", partlen, inoff, inlen);
ERR("overflow: %x + %x > %I64x\n", partlen, inoff, inlen);
return STATUS_INTERNAL_ERROR;
}
inoff += sizeof(UINT32);
inoff += sizeof(uint32_t);
stream.in = &inbuf[inoff];
stream.inlen = partlen;
stream.inpos = 0;
stream.out = &outbuf[outoff];
stream.outlen = min(outlen, LINUX_PAGE_SIZE);
stream.outlen = min(outlen, LZO_PAGE_SIZE);
stream.outpos = 0;
Status = do_lzo_decompress(&stream);
@ -312,8 +312,8 @@ NTSTATUS lzo_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen
inoff += partlen;
outoff += stream.outlen;
if (LINUX_PAGE_SIZE - ((inpageoff + inoff) % LINUX_PAGE_SIZE) < sizeof(UINT32))
inoff = ((((inpageoff + inoff) / LINUX_PAGE_SIZE) + 1) * LINUX_PAGE_SIZE) - inpageoff;
if (LZO_PAGE_SIZE - ((inpageoff + inoff) % LZO_PAGE_SIZE) < sizeof(uint32_t))
inoff = ((((inpageoff + inoff) / LZO_PAGE_SIZE) + 1) * LZO_PAGE_SIZE) - inpageoff;
outlen -= stream.outlen;
} while (inoff < inlen && outlen > 0);
@ -333,7 +333,7 @@ static void zlib_free(void* opaque, void* ptr) {
ExFreePool(ptr);
}
NTSTATUS zlib_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen) {
NTSTATUS zlib_decompress(uint8_t* inbuf, uint32_t inlen, uint8_t* outbuf, uint32_t outlen) {
z_stream c_stream;
int ret;
@ -379,18 +379,18 @@ NTSTATUS zlib_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outle
return STATUS_SUCCESS;
}
static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback) {
static NTSTATUS zlib_write_compressed_bit(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, bool* compressed, PIRP Irp, LIST_ENTRY* rollback) {
NTSTATUS Status;
UINT8 compression;
UINT32 comp_length;
UINT8* comp_data;
UINT32 out_left;
uint8_t compression;
uint32_t comp_length;
uint8_t* comp_data;
uint32_t out_left;
LIST_ENTRY* le;
chunk* c;
z_stream c_stream;
int ret;
comp_data = ExAllocatePoolWithTag(PagedPool, (UINT32)(end_data - start_data), ALLOC_TAG);
comp_data = ExAllocatePoolWithTag(PagedPool, (uint32_t)(end_data - start_data), ALLOC_TAG);
if (!comp_data) {
ERR("out of memory\n");
return STATUS_INSUFFICIENT_RESOURCES;
@ -415,9 +415,9 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
return STATUS_INTERNAL_ERROR;
}
c_stream.avail_in = (UINT32)(end_data - start_data);
c_stream.avail_in = (uint32_t)(end_data - start_data);
c_stream.next_in = data;
c_stream.avail_out = (UINT32)(end_data - start_data);
c_stream.avail_out = (uint32_t)(end_data - start_data);
c_stream.next_out = comp_data;
do {
@ -443,24 +443,24 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
if (out_left < fcb->Vcb->superblock.sector_size) { // compressed extent would be larger than or same size as uncompressed extent
ExFreePool(comp_data);
comp_length = (UINT32)(end_data - start_data);
comp_length = (uint32_t)(end_data - start_data);
comp_data = data;
compression = BTRFS_COMPRESSION_NONE;
*compressed = FALSE;
*compressed = false;
} else {
UINT32 cl;
uint32_t cl;
compression = BTRFS_COMPRESSION_ZLIB;
cl = (UINT32)(end_data - start_data - out_left);
comp_length = (UINT32)sector_align(cl, fcb->Vcb->superblock.sector_size);
cl = (uint32_t)(end_data - start_data - out_left);
comp_length = (uint32_t)sector_align(cl, fcb->Vcb->superblock.sector_size);
RtlZeroMemory(comp_data + cl, comp_length - cl);
*compressed = TRUE;
*compressed = true;
}
ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, TRUE);
ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, true);
le = fcb->Vcb->chunks.Flink;
while (le != &fcb->Vcb->chunks) {
@ -470,7 +470,7 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
if (compression != BTRFS_COMPRESSION_NONE)
@ -488,9 +488,9 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, TRUE);
ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, true);
Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, FALSE);
Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, false);
ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
@ -507,7 +507,7 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
if (compression != BTRFS_COMPRESSION_NONE)
ExFreePool(comp_data);
@ -518,7 +518,7 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
release_chunk_lock(c, fcb->Vcb);
}
WARN("couldn't find any data chunks with %llx bytes free\n", comp_length);
WARN("couldn't find any data chunks with %I64x bytes free\n", comp_length);
if (compression != BTRFS_COMPRESSION_NONE)
ExFreePool(comp_data);
@ -526,14 +526,14 @@ static NTSTATUS zlib_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
return STATUS_DISK_FULL;
}
static NTSTATUS lzo_do_compress(const UINT8* in, UINT32 in_len, UINT8* out, UINT32* out_len, void* wrkmem) {
const UINT8* ip;
UINT32 dv;
UINT8* op;
const UINT8* in_end = in + in_len;
const UINT8* ip_end = in + in_len - 9 - 4;
const UINT8* ii;
const UINT8** dict = (const UINT8**)wrkmem;
static NTSTATUS lzo_do_compress(const uint8_t* in, uint32_t in_len, uint8_t* out, uint32_t* out_len, void* wrkmem) {
const uint8_t* ip;
uint32_t dv;
uint8_t* op;
const uint8_t* in_end = in + in_len;
const uint8_t* ip_end = in + in_len - 9 - 4;
const uint8_t* ii;
const uint8_t** dict = (const uint8_t**)wrkmem;
op = out;
ip = in;
@ -545,17 +545,17 @@ static NTSTATUS lzo_do_compress(const UINT8* in, UINT32 in_len, UINT8* out, UINT
DVAL_NEXT(dv, ip); UPDATE_D(dict, cycle, dv, ip); ip++;
while (1) {
const UINT8* m_pos;
UINT32 m_len;
const uint8_t* m_pos;
uint32_t m_len;
ptrdiff_t m_off;
UINT32 lit, dindex;
uint32_t lit, dindex;
dindex = DINDEX(dv, ip);
m_pos = dict[dindex];
UPDATE_I(dict, cycle, dindex, ip);
if (!LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M4_MAX_OFFSET) && m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2]) {
lit = (UINT32)(ip - ii);
lit = (uint32_t)(ip - ii);
m_pos += 3;
if (m_off <= M2_MAX_OFFSET)
goto match;
@ -584,7 +584,7 @@ static NTSTATUS lzo_do_compress(const UINT8* in, UINT32 in_len, UINT8* out, UINT
match:
/* store current literal run */
if (lit > 0) {
UINT32 t = lit;
uint32_t t = lit;
if (t <= 3) {
if (op - 2 <= out)
@ -594,7 +594,7 @@ match:
} else if (t <= 18)
*op++ = LZO_BYTE(t - 3);
else {
UINT32 tt = t - 18;
uint32_t tt = t - 18;
*op++ = 0;
while (tt > 255) {
@ -623,7 +623,7 @@ code_match:
if (*m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++ ||
*m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++) {
--ip;
m_len = (UINT32)(ip - ii);
m_len = (uint32_t)(ip - ii);
if (m_len < 3 || m_len > 8)
return STATUS_INTERNAL_ERROR;
@ -646,11 +646,11 @@ code_match:
goto m3_m4_offset;
}
} else {
const UINT8* end;
const uint8_t* end;
end = in_end;
while (ip < end && *m_pos == *ip)
m_pos++, ip++;
m_len = (UINT32)(ip - ii);
m_len = (uint32_t)(ip - ii);
if (m_len < 3)
return STATUS_INTERNAL_ERROR;
@ -701,7 +701,7 @@ m3_m4_offset:
/* store final literal run */
if (in_end - ii > 0) {
UINT32 t = (UINT32)(in_end - ii);
uint32_t t = (uint32_t)(in_end - ii);
if (op == out && t <= 238)
*op++ = LZO_BYTE(17 + t);
@ -710,7 +710,7 @@ m3_m4_offset:
else if (t <= 18)
*op++ = LZO_BYTE(t - 3);
else {
UINT32 tt = t - 18;
uint32_t tt = t - 18;
*op++ = 0;
while (tt > 255) {
@ -729,13 +729,13 @@ m3_m4_offset:
} while (--t > 0);
}
*out_len = (UINT32)(op - out);
*out_len = (uint32_t)(op - out);
return STATUS_SUCCESS;
}
static NTSTATUS lzo1x_1_compress(lzo_stream* stream) {
UINT8 *op = stream->out;
uint8_t *op = stream->out;
NTSTATUS Status = STATUS_SUCCESS;
if (stream->inlen <= 0)
@ -748,7 +748,7 @@ static NTSTATUS lzo1x_1_compress(lzo_stream* stream) {
*op++ = stream->in[stream->inpos];
stream->inpos++;
} while (stream->inlen < stream->inpos);
stream->outlen = (UINT32)(op - stream->out);
stream->outlen = (uint32_t)(op - stream->out);
} else
Status = lzo_do_compress(stream->in, stream->inlen, stream->out, &stream->outlen, stream->wrkmem);
@ -763,29 +763,29 @@ static NTSTATUS lzo1x_1_compress(lzo_stream* stream) {
return Status;
}
static __inline UINT32 lzo_max_outlen(UINT32 inlen) {
static __inline uint32_t lzo_max_outlen(uint32_t inlen) {
return inlen + (inlen / 16) + 64 + 3; // formula comes from LZO.FAQ
}
static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback) {
static NTSTATUS lzo_write_compressed_bit(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, bool* compressed, PIRP Irp, LIST_ENTRY* rollback) {
NTSTATUS Status;
UINT8 compression;
UINT64 comp_length;
uint8_t compression;
uint64_t comp_length;
ULONG comp_data_len, num_pages, i;
UINT8* comp_data;
BOOL skip_compression = FALSE;
uint8_t* comp_data;
bool skip_compression = false;
lzo_stream stream;
UINT32* out_size;
uint32_t* out_size;
LIST_ENTRY* le;
chunk* c;
num_pages = (ULONG)((sector_align(end_data - start_data, LINUX_PAGE_SIZE)) / LINUX_PAGE_SIZE);
num_pages = (ULONG)((sector_align(end_data - start_data, LZO_PAGE_SIZE)) / LZO_PAGE_SIZE);
// Four-byte overall header
// Another four-byte header page
// Each page has a maximum size of lzo_max_outlen(LINUX_PAGE_SIZE)
// Each page has a maximum size of lzo_max_outlen(LZO_PAGE_SIZE)
// Plus another four bytes for possible padding
comp_data_len = sizeof(UINT32) + ((lzo_max_outlen(LINUX_PAGE_SIZE) + (2 * sizeof(UINT32))) * num_pages);
comp_data_len = sizeof(uint32_t) + ((lzo_max_outlen(LZO_PAGE_SIZE) + (2 * sizeof(uint32_t))) * num_pages);
comp_data = ExAllocatePoolWithTag(PagedPool, comp_data_len, ALLOC_TAG);
if (!comp_data) {
@ -808,34 +808,34 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
return Status;
}
out_size = (UINT32*)comp_data;
*out_size = sizeof(UINT32);
out_size = (uint32_t*)comp_data;
*out_size = sizeof(uint32_t);
stream.in = data;
stream.out = comp_data + (2 * sizeof(UINT32));
stream.out = comp_data + (2 * sizeof(uint32_t));
for (i = 0; i < num_pages; i++) {
UINT32* pagelen = (UINT32*)(stream.out - sizeof(UINT32));
uint32_t* pagelen = (uint32_t*)(stream.out - sizeof(uint32_t));
stream.inlen = (UINT32)min(LINUX_PAGE_SIZE, end_data - start_data - (i * LINUX_PAGE_SIZE));
stream.inlen = (uint32_t)min(LZO_PAGE_SIZE, end_data - start_data - (i * LZO_PAGE_SIZE));
Status = lzo1x_1_compress(&stream);
if (!NT_SUCCESS(Status)) {
ERR("lzo1x_1_compress returned %08x\n", Status);
skip_compression = TRUE;
skip_compression = true;
break;
}
*pagelen = stream.outlen;
*out_size += stream.outlen + sizeof(UINT32);
*out_size += stream.outlen + sizeof(uint32_t);
stream.in += LINUX_PAGE_SIZE;
stream.out += stream.outlen + sizeof(UINT32);
stream.in += LZO_PAGE_SIZE;
stream.out += stream.outlen + sizeof(uint32_t);
if (LINUX_PAGE_SIZE - (*out_size % LINUX_PAGE_SIZE) < sizeof(UINT32)) {
RtlZeroMemory(stream.out, LINUX_PAGE_SIZE - (*out_size % LINUX_PAGE_SIZE));
stream.out += LINUX_PAGE_SIZE - (*out_size % LINUX_PAGE_SIZE);
*out_size += LINUX_PAGE_SIZE - (*out_size % LINUX_PAGE_SIZE);
if (LZO_PAGE_SIZE - (*out_size % LZO_PAGE_SIZE) < sizeof(uint32_t)) {
RtlZeroMemory(stream.out, LZO_PAGE_SIZE - (*out_size % LZO_PAGE_SIZE));
stream.out += LZO_PAGE_SIZE - (*out_size % LZO_PAGE_SIZE);
*out_size += LZO_PAGE_SIZE - (*out_size % LZO_PAGE_SIZE);
}
}
@ -848,17 +848,17 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
comp_data = data;
compression = BTRFS_COMPRESSION_NONE;
*compressed = FALSE;
*compressed = false;
} else {
compression = BTRFS_COMPRESSION_LZO;
comp_length = sector_align(*out_size, fcb->Vcb->superblock.sector_size);
RtlZeroMemory(comp_data + *out_size, (ULONG)(comp_length - *out_size));
*compressed = TRUE;
*compressed = true;
}
ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, TRUE);
ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, true);
le = fcb->Vcb->chunks.Flink;
while (le != &fcb->Vcb->chunks) {
@ -868,7 +868,7 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
if (compression != BTRFS_COMPRESSION_NONE)
@ -886,9 +886,9 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, TRUE);
ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, true);
Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, FALSE);
Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, false);
ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
@ -905,7 +905,7 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
if (compression != BTRFS_COMPRESSION_NONE)
ExFreePool(comp_data);
@ -916,7 +916,7 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
release_chunk_lock(c, fcb->Vcb);
}
WARN("couldn't find any data chunks with %llx bytes free\n", comp_length);
WARN("couldn't find any data chunks with %I64x bytes free\n", comp_length);
if (compression != BTRFS_COMPRESSION_NONE)
ExFreePool(comp_data);
@ -924,12 +924,12 @@ static NTSTATUS lzo_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end
return STATUS_DISK_FULL;
}
static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback) {
static NTSTATUS zstd_write_compressed_bit(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, bool* compressed, PIRP Irp, LIST_ENTRY* rollback) {
NTSTATUS Status;
UINT8 compression;
UINT32 comp_length;
UINT8* comp_data;
UINT32 out_left;
uint8_t compression;
uint32_t comp_length;
uint8_t* comp_data;
uint32_t out_left;
LIST_ENTRY* le;
chunk* c;
ZSTD_CStream* stream;
@ -938,7 +938,7 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
ZSTD_outBuffer output;
ZSTD_parameters params;
comp_data = ExAllocatePoolWithTag(PagedPool, (UINT32)(end_data - start_data), ALLOC_TAG);
comp_data = ExAllocatePoolWithTag(PagedPool, (uint32_t)(end_data - start_data), ALLOC_TAG);
if (!comp_data) {
ERR("out of memory\n");
return STATUS_INSUFFICIENT_RESOURCES;
@ -959,12 +959,12 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
return STATUS_INTERNAL_ERROR;
}
params = ZSTD_getParams(fcb->Vcb->options.zstd_level, (UINT32)(end_data - start_data), 0);
params = ZSTD_getParams(fcb->Vcb->options.zstd_level, (uint32_t)(end_data - start_data), 0);
if (params.cParams.windowLog > ZSTD_BTRFS_MAX_WINDOWLOG)
params.cParams.windowLog = ZSTD_BTRFS_MAX_WINDOWLOG;
init_res = ZSTD_initCStream_advanced(stream, NULL, 0, params, (UINT32)(end_data - start_data));
init_res = ZSTD_initCStream_advanced(stream, NULL, 0, params, (uint32_t)(end_data - start_data));
if (ZSTD_isError(init_res)) {
ERR("ZSTD_initCStream_advanced failed: %s\n", ZSTD_getErrorName(init_res));
@ -974,11 +974,11 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
}
input.src = data;
input.size = (UINT32)(end_data - start_data);
input.size = (uint32_t)(end_data - start_data);
input.pos = 0;
output.dst = comp_data;
output.size = (UINT32)(end_data - start_data);
output.size = (uint32_t)(end_data - start_data);
output.pos = 0;
while (input.pos < input.size && output.pos < output.size) {
@ -1007,24 +1007,24 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
if (out_left < fcb->Vcb->superblock.sector_size) { // compressed extent would be larger than or same size as uncompressed extent
ExFreePool(comp_data);
comp_length = (UINT32)(end_data - start_data);
comp_length = (uint32_t)(end_data - start_data);
comp_data = data;
compression = BTRFS_COMPRESSION_NONE;
*compressed = FALSE;
*compressed = false;
} else {
UINT32 cl;
uint32_t cl;
compression = BTRFS_COMPRESSION_ZSTD;
cl = (UINT32)(end_data - start_data - out_left);
comp_length = (UINT32)sector_align(cl, fcb->Vcb->superblock.sector_size);
cl = (uint32_t)(end_data - start_data - out_left);
comp_length = (uint32_t)sector_align(cl, fcb->Vcb->superblock.sector_size);
RtlZeroMemory(comp_data + cl, comp_length - cl);
*compressed = TRUE;
*compressed = true;
}
ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, TRUE);
ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, true);
le = fcb->Vcb->chunks.Flink;
while (le != &fcb->Vcb->chunks) {
@ -1034,7 +1034,7 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
if (compression != BTRFS_COMPRESSION_NONE)
@ -1052,9 +1052,9 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, TRUE);
ExAcquireResourceExclusiveLite(&fcb->Vcb->chunk_lock, true);
Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, FALSE);
Status = alloc_chunk(fcb->Vcb, fcb->Vcb->data_flags, &c, false);
ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
@ -1071,7 +1071,7 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
acquire_chunk_lock(c, fcb->Vcb);
if (c->chunk_item->type == fcb->Vcb->data_flags && (c->chunk_item->size - c->used) >= comp_length) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, FALSE, comp_data, Irp, rollback, compression, end_data - start_data, FALSE, 0)) {
if (insert_extent_chunk(fcb->Vcb, fcb, c, start_data, comp_length, false, comp_data, Irp, rollback, compression, end_data - start_data, false, 0)) {
if (compression != BTRFS_COMPRESSION_NONE)
ExFreePool(comp_data);
@ -1082,7 +1082,7 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
release_chunk_lock(c, fcb->Vcb);
}
WARN("couldn't find any data chunks with %llx bytes free\n", comp_length);
WARN("couldn't find any data chunks with %I64x bytes free\n", comp_length);
if (compression != BTRFS_COMPRESSION_NONE)
ExFreePool(comp_data);
@ -1090,8 +1090,8 @@ static NTSTATUS zstd_write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 en
return STATUS_DISK_FULL;
}
NTSTATUS write_compressed_bit(fcb* fcb, UINT64 start_data, UINT64 end_data, void* data, BOOL* compressed, PIRP Irp, LIST_ENTRY* rollback) {
UINT8 type;
NTSTATUS write_compressed_bit(fcb* fcb, uint64_t start_data, uint64_t end_data, void* data, bool* compressed, PIRP Irp, LIST_ENTRY* rollback) {
uint8_t type;
if (fcb->Vcb->options.compress_type != 0 && fcb->prop_compression == PropCompression_None)
type = fcb->Vcb->options.compress_type;
@ -1130,7 +1130,7 @@ static void zstd_free(void* opaque, void* address) {
ExFreePool(address);
}
NTSTATUS zstd_decompress(UINT8* inbuf, UINT32 inlen, UINT8* outbuf, UINT32 outlen) {
NTSTATUS zstd_decompress(uint8_t* inbuf, uint32_t inlen, uint8_t* outbuf, uint32_t outlen) {
NTSTATUS Status;
ZSTD_DStream* stream;
size_t init_res, read;

24
drivers/filesystems/btrfs/crc32c.c
View file

@ -18,11 +18,15 @@
#include <windef.h>
#ifndef __REACTOS__
#include <smmintrin.h>
#endif /* __REACTOS__ */
#include <stdint.h>
#include <stdbool.h>
extern BOOL have_sse42;
#ifndef __REACTOS__
extern bool have_sse42;
#endif /* __REACTOS__ */
static const UINT32 crctable[] = {
static const uint32_t crctable[] = {
0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24,
0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
@ -68,7 +72,7 @@ static const UINT32 crctable[] = {
} \
} while(0)
static UINT32 crc32c_hw(const void *input, ULONG len, UINT32 crc) {
static uint32_t crc32c_hw(const void *input, ULONG len, uint32_t crc) {
const char* buf = (const char*)input;
// Annoyingly, the CRC32 intrinsics don't work properly in modern versions of MSVC -
@ -86,31 +90,31 @@ static UINT32 crc32c_hw(const void *input, ULONG len, UINT32 crc) {
#ifdef _AMD64_
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4244) // _mm_crc32_u64 wants to return UINT64(!)
#pragma warning(disable:4244) // _mm_crc32_u64 wants to return uint64_t(!)
#pragma warning(disable:4242)
#endif
CALC_CRC(_mm_crc32_u64, crc, UINT64, buf, len);
CALC_CRC(_mm_crc32_u64, crc, uint64_t, buf, len);
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif
CALC_CRC(_mm_crc32_u32, crc, UINT32, buf, len);
CALC_CRC(_mm_crc32_u32, crc, uint32_t, buf, len);
#ifdef _MSC_VER
for (; len > 0; len--, buf++) {
crc = crctable[(crc ^ *buf) & 0xff] ^ (crc >> 8);
}
#else
CALC_CRC(_mm_crc32_u16, crc, UINT16, buf, len);
CALC_CRC(_mm_crc32_u8, crc, UINT8, buf, len);
CALC_CRC(_mm_crc32_u16, crc, uint16_t, buf, len);
CALC_CRC(_mm_crc32_u8, crc, uint8_t, buf, len);
#endif
return crc;
}
#endif
UINT32 calc_crc32c(_In_ UINT32 seed, _In_reads_bytes_(msglen) UINT8* msg, _In_ ULONG msglen) {
UINT32 rem;
uint32_t calc_crc32c(_In_ uint32_t seed, _In_reads_bytes_(msglen) uint8_t* msg, _In_ ULONG msglen) {
uint32_t rem;
ULONG i;
#ifndef __REACTOS__

722
drivers/filesystems/btrfs/create.c
View file

File diff suppressed because it is too large Load diff

22
drivers/filesystems/btrfs/devctrl.c
View file

@ -52,7 +52,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
btrfs_filesystem* bfs = NULL;
ULONG itemsize;
ExAcquireResourceSharedLite(&global_loading_lock, TRUE);
ExAcquireResourceSharedLite(&global_loading_lock, true);
if (IsListEmpty(&VcbList)) {
if (length < sizeof(btrfs_filesystem)) {
@ -73,7 +73,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
if (bfs) {
bfs->next_entry = itemsize;
bfs = (btrfs_filesystem*)((UINT8*)bfs + itemsize);
bfs = (btrfs_filesystem*)((uint8_t*)bfs + itemsize);
} else
bfs = data;
@ -88,9 +88,9 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
bfs->next_entry = 0;
RtlCopyMemory(&bfs->uuid, &Vcb->superblock.uuid, sizeof(BTRFS_UUID));
ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
bfs->num_devices = (UINT32)Vcb->superblock.num_devices;
bfs->num_devices = (uint32_t)Vcb->superblock.num_devices;
bfd = NULL;
@ -100,7 +100,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
MOUNTDEV_NAME mdn;
if (bfd)
bfd = (btrfs_filesystem_device*)((UINT8*)bfd + offsetof(btrfs_filesystem_device, name[0]) + bfd->name_length);
bfd = (btrfs_filesystem_device*)((uint8_t*)bfd + offsetof(btrfs_filesystem_device, name[0]) + bfd->name_length);
else
bfd = &bfs->device;
@ -116,7 +116,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
RtlCopyMemory(&bfd->uuid, &dev->devitem.device_uuid, sizeof(BTRFS_UUID));
if (dev->devobj) {
Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), TRUE, NULL);
Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), true, NULL);
if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
ExReleaseResourceLite(&Vcb->tree_lock);
ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
@ -129,7 +129,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
goto end;
}
Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &bfd->name_length, (ULONG)offsetof(MOUNTDEV_NAME, Name[0]) + mdn.NameLength, TRUE, NULL);
Status = dev_ioctl(dev->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &bfd->name_length, (ULONG)offsetof(MOUNTDEV_NAME, Name[0]) + mdn.NameLength, true, NULL);
if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
ExReleaseResourceLite(&Vcb->tree_lock);
ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
@ -139,7 +139,7 @@ static NTSTATUS query_filesystems(void* data, ULONG length) {
itemsize += bfd->name_length;
length -= bfd->name_length;
} else {
bfd->missing = TRUE;
bfd->missing = true;
bfd->name_length = 0;
}
@ -195,7 +195,7 @@ static NTSTATUS probe_volume(void* data, ULONG length, KPROCESSOR_MODE processor
}
if (RtlCompareMemory(guid, &GUID_DEVINTERFACE_DISK, sizeof(GUID)) == sizeof(GUID)) {
Status = dev_ioctl(DeviceObject, IOCTL_DISK_UPDATE_PROPERTIES, NULL, 0, NULL, 0, TRUE, NULL);
Status = dev_ioctl(DeviceObject, IOCTL_DISK_UPDATE_PROPERTIES, NULL, 0, NULL, 0, true, NULL);
if (!NT_SUCCESS(Status))
WARN("IOCTL_DISK_UPDATE_PROPERTIES returned %08x\n", Status);
}
@ -236,11 +236,11 @@ static NTSTATUS control_ioctl(PIRP Irp) {
_Dispatch_type_(IRP_MJ_DEVICE_CONTROL)
_Function_class_(DRIVER_DISPATCH)
NTSTATUS NTAPI drv_device_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
NTSTATUS __stdcall drv_device_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
device_extension* Vcb = DeviceObject->DeviceExtension;
BOOL top_level;
bool top_level;
FsRtlEnterFileSystem();

106
drivers/filesystems/btrfs/dirctrl.c
View file

@ -18,7 +18,7 @@
#include "btrfs_drv.h"
// not currently in mingw
//#ifndef _MSC_VER
#ifndef _MSC_VER
#define FileIdExtdDirectoryInformation (enum _FILE_INFORMATION_CLASS)60
#define FileIdExtdBothDirectoryInformation (enum _FILE_INFORMATION_CLASS)63
@ -58,7 +58,7 @@ typedef struct _FILE_ID_EXTD_BOTH_DIR_INFORMATION {
WCHAR FileName[1];
} FILE_ID_EXTD_BOTH_DIR_INFORMATION, *PFILE_ID_EXTD_BOTH_DIR_INFORMATION;
//#endif
#endif
enum DirEntryType {
DirEntryType_File,
@ -69,7 +69,7 @@ enum DirEntryType {
typedef struct {
KEY key;
UNICODE_STRING name;
UINT8 type;
uint8_t type;
enum DirEntryType dir_entry_type;
dir_child* dc;
} dir_entry;
@ -88,7 +88,7 @@ ULONG get_reparse_tag_fcb(fcb* fcb) {
NTSTATUS Status;
ULONG br;
Status = read_file(fcb, (UINT8*)&tag, 0, sizeof(ULONG), &br, NULL);
Status = read_file(fcb, (uint8_t*)&tag, 0, sizeof(ULONG), &br, NULL);
if (!NT_SUCCESS(Status)) {
ERR("read_file returned %08x\n", Status);
return 0;
@ -98,7 +98,7 @@ ULONG get_reparse_tag_fcb(fcb* fcb) {
return tag;
}
ULONG get_reparse_tag(device_extension* Vcb, root* subvol, UINT64 inode, UINT8 type, ULONG atts, BOOL lxss, PIRP Irp) {
ULONG get_reparse_tag(device_extension* Vcb, root* subvol, uint64_t inode, uint8_t type, ULONG atts, bool lxss, PIRP Irp) {
fcb* fcb;
ULONG tag = 0;
NTSTATUS Status;
@ -122,13 +122,13 @@ ULONG get_reparse_tag(device_extension* Vcb, root* subvol, UINT64 inode, UINT8 t
if (!(atts & FILE_ATTRIBUTE_REPARSE_POINT))
return 0;
Status = open_fcb(Vcb, subvol, inode, type, NULL, FALSE, NULL, &fcb, PagedPool, Irp);
Status = open_fcb(Vcb, subvol, inode, type, NULL, false, NULL, &fcb, PagedPool, Irp);
if (!NT_SUCCESS(Status)) {
ERR("open_fcb returned %08x\n", Status);
return 0;
}
ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
ExAcquireResourceSharedLite(fcb->Header.Resource, true);
tag = get_reparse_tag_fcb(fcb);
@ -139,9 +139,9 @@ ULONG get_reparse_tag(device_extension* Vcb, root* subvol, UINT64 inode, UINT8 t
return tag;
}
static ULONG get_ea_len(device_extension* Vcb, root* subvol, UINT64 inode, PIRP Irp) {
UINT8* eadata;
UINT16 len;
static ULONG get_ea_len(device_extension* Vcb, root* subvol, uint64_t inode, PIRP Irp) {
uint8_t* eadata;
uint16_t len;
if (get_xattr(Vcb, subvol, inode, EA_EA, EA_EA_HASH, &eadata, &len, Irp)) {
ULONG offset;
@ -165,8 +165,8 @@ static ULONG get_ea_len(device_extension* Vcb, root* subvol, UINT64 inode, PIRP
if (eainfo->NextEntryOffset == 0)
break;
eainfo = (FILE_FULL_EA_INFORMATION*)(((UINT8*)eainfo) + eainfo->NextEntryOffset);
} while (TRUE);
eainfo = (FILE_FULL_EA_INFORMATION*)(((uint8_t*)eainfo) + eainfo->NextEntryOffset);
} while (true);
ExFreePool(eadata);
@ -179,7 +179,7 @@ static ULONG get_ea_len(device_extension* Vcb, root* subvol, UINT64 inode, PIRP
static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Irp, dir_entry* de, root* r) {
PIO_STACK_LOCATION IrpSp;
LONG needed;
UINT64 inode;
uint64_t inode;
INODE_ITEM ii;
NTSTATUS Status;
ULONG atts = 0, ealen = 0;
@ -227,13 +227,13 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
win_time_to_unix(time, &ii.otime);
ii.st_atime = ii.st_mtime = ii.st_ctime = ii.otime;
} else {
BOOL found = FALSE;
bool found = false;
if (de->dc && de->dc->fileref && de->dc->fileref->fcb) {
ii = de->dc->fileref->fcb->inode_item;
atts = de->dc->fileref->fcb->atts;
ealen = de->dc->fileref->fcb->ealen;
found = TRUE;
found = true;
}
if (!found) {
@ -244,14 +244,14 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
searchkey.obj_type = TYPE_INODE_ITEM;
searchkey.offset = 0xffffffffffffffff;
Status = find_item(fcb->Vcb, r, &tp, &searchkey, FALSE, Irp);
Status = find_item(fcb->Vcb, r, &tp, &searchkey, false, Irp);
if (!NT_SUCCESS(Status)) {
ERR("error - find_item returned %08x\n", Status);
return Status;
}
if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
ERR("could not find inode item for inode %llx in root %llx\n", inode, r->id);
ERR("could not find inode item for inode %I64x in root %I64x\n", inode, r->id);
return STATUS_INTERNAL_ERROR;
}
@ -268,9 +268,9 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
IrpSp->Parameters.QueryDirectory.FileInformationClass == FileIdExtdDirectoryInformation ||
IrpSp->Parameters.QueryDirectory.FileInformationClass == FileIdExtdBothDirectoryInformation) {
BOOL dotfile = de->name.Length > sizeof(WCHAR) && de->name.Buffer[0] == '.';
bool dotfile = de->name.Length > sizeof(WCHAR) && de->name.Buffer[0] == '.';
atts = get_file_attributes(fcb->Vcb, r, inode, de->type, dotfile, FALSE, Irp);
atts = get_file_attributes(fcb->Vcb, r, inode, de->type, dotfile, false, Irp);
}
if (IrpSp->Parameters.QueryDirectory.FileInformationClass == FileBothDirectoryInformation ||
@ -549,8 +549,8 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
fiedi->EaSize = ealen;
fiedi->ReparsePointTag = get_reparse_tag(fcb->Vcb, r, inode, de->type, atts, ccb->lxss, Irp);
RtlCopyMemory(&fiedi->FileId.Identifier[0], &fcb->inode, sizeof(UINT64));
RtlCopyMemory(&fiedi->FileId.Identifier[sizeof(UINT64)], &fcb->subvol->id, sizeof(UINT64));
RtlCopyMemory(&fiedi->FileId.Identifier[0], &fcb->inode, sizeof(uint64_t));
RtlCopyMemory(&fiedi->FileId.Identifier[sizeof(uint64_t)], &fcb->subvol->id, sizeof(uint64_t));
RtlCopyMemory(fiedi->FileName, de->name.Buffer, de->name.Length);
@ -592,8 +592,8 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
fiebdi->EaSize = ealen;
fiebdi->ReparsePointTag = get_reparse_tag(fcb->Vcb, r, inode, de->type, atts, ccb->lxss, Irp);
RtlCopyMemory(&fiebdi->FileId.Identifier[0], &fcb->inode, sizeof(UINT64));
RtlCopyMemory(&fiebdi->FileId.Identifier[sizeof(UINT64)], &fcb->subvol->id, sizeof(UINT64));
RtlCopyMemory(&fiebdi->FileId.Identifier[0], &fcb->inode, sizeof(uint64_t));
RtlCopyMemory(&fiebdi->FileId.Identifier[sizeof(uint64_t)], &fcb->subvol->id, sizeof(uint64_t));
fiebdi->ShortNameLength = 0;
@ -652,7 +652,7 @@ static NTSTATUS query_dir_item(fcb* fcb, ccb* ccb, void* buf, LONG* len, PIRP Ir
return STATUS_NO_MORE_FILES;
}
static NTSTATUS next_dir_entry(file_ref* fileref, UINT64* offset, dir_entry* de, dir_child** pdc) {
static NTSTATUS next_dir_entry(file_ref* fileref, uint64_t* offset, dir_entry* de, dir_child** pdc) {
LIST_ENTRY* le;
dir_child* dc;
@ -739,12 +739,12 @@ static NTSTATUS query_directory(PIRP Irp) {
file_ref* fileref;
device_extension* Vcb;
void* buf;
UINT8 *curitem, *lastitem;
uint8_t *curitem, *lastitem;
LONG length;
ULONG count;
BOOL has_wildcard = FALSE, specific_file = FALSE, initial;
bool has_wildcard = false, specific_file = false, initial;
dir_entry de;
UINT64 newoffset;
uint64_t newoffset;
dir_child* dc = NULL;
TRACE("query directory\n");
@ -816,8 +816,8 @@ static NTSTATUS query_directory(PIRP Irp) {
ccb->query_string.Buffer = NULL;
}
ccb->has_wildcard = FALSE;
ccb->specific_file = FALSE;
ccb->has_wildcard = false;
ccb->specific_file = false;
}
initial = !ccb->query_string.Buffer;
@ -826,11 +826,11 @@ static NTSTATUS query_directory(PIRP Irp) {
TRACE("QD filename: %.*S\n", IrpSp->Parameters.QueryDirectory.FileName->Length / sizeof(WCHAR), IrpSp->Parameters.QueryDirectory.FileName->Buffer);
if (IrpSp->Parameters.QueryDirectory.FileName->Length > sizeof(WCHAR) || IrpSp->Parameters.QueryDirectory.FileName->Buffer[0] != L'*') {
specific_file = TRUE;
specific_file = true;
if (FsRtlDoesNameContainWildCards(IrpSp->Parameters.QueryDirectory.FileName)) {
has_wildcard = TRUE;
specific_file = FALSE;
has_wildcard = true;
specific_file = false;
}
}
@ -838,7 +838,7 @@ static NTSTATUS query_directory(PIRP Irp) {
RtlFreeUnicodeString(&ccb->query_string);
if (has_wildcard)
RtlUpcaseUnicodeString(&ccb->query_string, IrpSp->Parameters.QueryDirectory.FileName, TRUE);
RtlUpcaseUnicodeString(&ccb->query_string, IrpSp->Parameters.QueryDirectory.FileName, true);
else {
ccb->query_string.Buffer = ExAllocatePoolWithTag(PagedPool, IrpSp->Parameters.QueryDirectory.FileName->Length, ALLOC_TAG);
if (!ccb->query_string.Buffer) {
@ -857,7 +857,7 @@ static NTSTATUS query_directory(PIRP Irp) {
specific_file = ccb->specific_file;
if (!(IrpSp->Flags & SL_RESTART_SCAN)) {
initial = FALSE;
initial = false;
if (specific_file)
return STATUS_NO_MORE_FILES;
@ -870,9 +870,9 @@ static NTSTATUS query_directory(PIRP Irp) {
newoffset = ccb->query_dir_offset;
ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
ExAcquireResourceSharedLite(&fileref->fcb->nonpaged->dir_children_lock, TRUE);
ExAcquireResourceSharedLite(&fileref->fcb->nonpaged->dir_children_lock, true);
Status = next_dir_entry(fileref, &newoffset, &de, &dc);
@ -895,24 +895,24 @@ static NTSTATUS query_directory(PIRP Irp) {
length = IrpSp->Parameters.QueryDirectory.Length;
if (specific_file) {
BOOL found = FALSE;
bool found = false;
UNICODE_STRING us;
LIST_ENTRY* le;
UINT32 hash;
UINT8 c;
uint32_t hash;
uint8_t c;
us.Buffer = NULL;
if (!ccb->case_sensitive) {
Status = RtlUpcaseUnicodeString(&us, &ccb->query_string, TRUE);
Status = RtlUpcaseUnicodeString(&us, &ccb->query_string, true);
if (!NT_SUCCESS(Status)) {
ERR("RtlUpcaseUnicodeString returned %08x\n", Status);
goto end;
}
hash = calc_crc32c(0xffffffff, (UINT8*)us.Buffer, us.Length);
hash = calc_crc32c(0xffffffff, (uint8_t*)us.Buffer, us.Length);
} else
hash = calc_crc32c(0xffffffff, (UINT8*)ccb->query_string.Buffer, ccb->query_string.Length);
hash = calc_crc32c(0xffffffff, (uint8_t*)ccb->query_string.Buffer, ccb->query_string.Length);
c = hash >> 24;
@ -924,7 +924,7 @@ static NTSTATUS query_directory(PIRP Irp) {
if (dc2->hash == hash) {
if (dc2->name.Length == ccb->query_string.Length && RtlCompareMemory(dc2->name.Buffer, ccb->query_string.Buffer, ccb->query_string.Length) == ccb->query_string.Length) {
found = TRUE;
found = true;
de.key = dc2->key;
de.name = dc2->name;
@ -948,7 +948,7 @@ static NTSTATUS query_directory(PIRP Irp) {
if (dc2->hash_uc == hash) {
if (dc2->name_uc.Length == us.Length && RtlCompareMemory(dc2->name_uc.Buffer, us.Buffer, us.Length) == us.Length) {
found = TRUE;
found = true;
de.key = dc2->key;
de.name = dc2->name;
@ -996,7 +996,7 @@ static NTSTATUS query_directory(PIRP Irp) {
count = 0;
if (NT_SUCCESS(Status) && !(IrpSp->Flags & SL_RETURN_SINGLE_ENTRY) && !specific_file) {
lastitem = (UINT8*)buf;
lastitem = (uint8_t*)buf;
while (length > 0) {
switch (IrpSp->Parameters.QueryDirectory.FileInformationClass) {
@ -1031,10 +1031,10 @@ static NTSTATUS query_directory(PIRP Irp) {
Status = next_dir_entry(fileref, &newoffset, &de, &dc);
if (NT_SUCCESS(Status)) {
if (!has_wildcard || FsRtlIsNameInExpression(&ccb->query_string, &de.name, !ccb->case_sensitive, NULL)) {
curitem = (UINT8*)buf + IrpSp->Parameters.QueryDirectory.Length - length;
curitem = (uint8_t*)buf + IrpSp->Parameters.QueryDirectory.Length - length;
count++;
TRACE("file(%u) %u = %.*S\n", count, curitem - (UINT8*)buf, de.name.Length / sizeof(WCHAR), de.name.Buffer);
TRACE("file(%u) %u = %.*S\n", count, curitem - (uint8_t*)buf, de.name.Length / sizeof(WCHAR), de.name.Buffer);
TRACE("offset = %u\n", ccb->query_dir_offset - 1);
status2 = query_dir_item(fcb, ccb, curitem, &length, Irp, &de, fcb->subvol);
@ -1098,8 +1098,8 @@ static NTSTATUS notify_change_directory(device_extension* Vcb, PIRP Irp) {
return STATUS_ACCESS_DENIED;
}
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
if (fcb->type != BTRFS_TYPE_DIRECTORY) {
Status = STATUS_INVALID_PARAMETER;
@ -1124,7 +1124,7 @@ static NTSTATUS notify_change_directory(device_extension* Vcb, PIRP Irp) {
goto end;
}
ccb->filename.MaximumLength = (UINT16)reqlen;
ccb->filename.MaximumLength = (uint16_t)reqlen;
Status = fileref_get_filename(fileref, &ccb->filename, NULL, &reqlen);
if (!NT_SUCCESS(Status)) {
@ -1138,7 +1138,7 @@ static NTSTATUS notify_change_directory(device_extension* Vcb, PIRP Irp) {
}
FsRtlNotifyFilterChangeDirectory(Vcb->NotifySync, &Vcb->DirNotifyList, FileObject->FsContext2, (PSTRING)&ccb->filename,
IrpSp->Flags & SL_WATCH_TREE, FALSE, IrpSp->Parameters.NotifyDirectory.CompletionFilter, Irp,
IrpSp->Flags & SL_WATCH_TREE, false, IrpSp->Parameters.NotifyDirectory.CompletionFilter, Irp,
NULL, NULL, NULL);
Status = STATUS_PENDING;
@ -1152,11 +1152,11 @@ end:
_Dispatch_type_(IRP_MJ_DIRECTORY_CONTROL)
_Function_class_(DRIVER_DISPATCH)
NTSTATUS NTAPI drv_directory_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
NTSTATUS __stdcall drv_directory_control(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
PIO_STACK_LOCATION IrpSp;
NTSTATUS Status;
ULONG func;
BOOL top_level;
bool top_level;
device_extension* Vcb = DeviceObject->DeviceExtension;
FsRtlEnterFileSystem();

490
drivers/filesystems/btrfs/extent-tree.c
View file

File diff suppressed because it is too large Load diff

260
drivers/filesystems/btrfs/fastio.c
View file

@ -20,13 +20,8 @@
FAST_IO_DISPATCH FastIoDispatch;
_Function_class_(FAST_IO_QUERY_BASIC_INFO)
#ifdef __REACTOS__
static BOOLEAN NTAPI fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_BASIC_INFORMATION fbi,
static BOOLEAN __stdcall fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_BASIC_INFORMATION fbi,
PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
#else
static BOOLEAN fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_BASIC_INFORMATION fbi,
PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
#endif
fcb* fcb;
ccb* ccb;
@ -36,32 +31,32 @@ static BOOLEAN fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFIL
if (!FileObject) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
fcb = FileObject->FsContext;
if (!fcb) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
ccb = FileObject->FsContext2;
if (!ccb) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
if (!(ccb->access & (FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES))) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
if (fcb->ads) {
if (!ccb->fileref || !ccb->fileref->parent || !ccb->fileref->parent->fcb) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
fcb = ccb->fileref->parent->fcb;
@ -69,7 +64,7 @@ static BOOLEAN fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFIL
if (!ExAcquireResourceSharedLite(fcb->Header.Resource, wait)) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
if (fcb == fcb->Vcb->dummy_fcb) {
@ -93,20 +88,15 @@ static BOOLEAN fast_query_basic_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFIL
FsRtlExitFileSystem();
return TRUE;
return true;
}
_Function_class_(FAST_IO_QUERY_STANDARD_INFO)
#ifdef __REACTOS__
static BOOLEAN NTAPI fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_STANDARD_INFORMATION fsi,
static BOOLEAN __stdcall fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_STANDARD_INFORMATION fsi,
PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
#else
static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, PFILE_STANDARD_INFORMATION fsi,
PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
#endif
fcb* fcb;
ccb* ccb;
BOOL ads;
bool ads;
ULONG adssize;
FsRtlEnterFileSystem();
@ -115,7 +105,7 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
if (!FileObject) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
fcb = FileObject->FsContext;
@ -123,12 +113,12 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
if (!fcb) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
if (!ExAcquireResourceSharedLite(fcb->Header.Resource, wait)) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
ads = fcb->ads;
@ -139,7 +129,7 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
if (!ccb || !ccb->fileref || !ccb->fileref->parent || !ccb->fileref->parent->fcb) {
ExReleaseResourceLite(fcb->Header.Resource);
FsRtlExitFileSystem();
return FALSE;
return false;
}
adssize = fcb->adsdata.Length;
@ -152,12 +142,12 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
if (!ExAcquireResourceSharedLite(fcb->Header.Resource, wait)) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
fsi->AllocationSize.QuadPart = fsi->EndOfFile.QuadPart = adssize;
fsi->NumberOfLinks = fcb->inode_item.st_nlink;
fsi->Directory = FALSE;
fsi->Directory = false;
} else {
fsi->AllocationSize.QuadPart = fcb_alloc_size(fcb);
fsi->EndOfFile.QuadPart = S_ISDIR(fcb->inode_item.st_mode) ? 0 : fcb->inode_item.st_size;
@ -165,7 +155,7 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
fsi->Directory = S_ISDIR(fcb->inode_item.st_mode);
}
fsi->DeletePending = ccb->fileref ? ccb->fileref->delete_on_close : FALSE;
fsi->DeletePending = ccb->fileref ? ccb->fileref->delete_on_close : false;
IoStatus->Status = STATUS_SUCCESS;
IoStatus->Information = sizeof(FILE_STANDARD_INFORMATION);
@ -174,19 +164,13 @@ static BOOLEAN fast_query_standard_info(PFILE_OBJECT FileObject, BOOLEAN wait, P
FsRtlExitFileSystem();
return TRUE;
return true;
}
_Function_class_(FAST_IO_CHECK_IF_POSSIBLE)
#ifdef __REACTOS__
static BOOLEAN NTAPI fast_io_check_if_possible(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait,
static BOOLEAN __stdcall fast_io_check_if_possible(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait,
ULONG LockKey, BOOLEAN CheckForReadOperation, PIO_STATUS_BLOCK IoStatus,
PDEVICE_OBJECT DeviceObject) {
#else
static BOOLEAN fast_io_check_if_possible(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait,
ULONG LockKey, BOOLEAN CheckForReadOperation, PIO_STATUS_BLOCK IoStatus,
PDEVICE_OBJECT DeviceObject) {
#endif
fcb* fcb = FileObject->FsContext;
LARGE_INTEGER len2;
@ -198,23 +182,18 @@ static BOOLEAN fast_io_check_if_possible(PFILE_OBJECT FileObject, PLARGE_INTEGER
if (CheckForReadOperation) {
if (FsRtlFastCheckLockForRead(&fcb->lock, FileOffset, &len2, LockKey, FileObject, PsGetCurrentProcess()))
return TRUE;
return true;
} else {
if (!fcb->Vcb->readonly && !is_subvol_readonly(fcb->subvol, NULL) && FsRtlFastCheckLockForWrite(&fcb->lock, FileOffset, &len2, LockKey, FileObject, PsGetCurrentProcess()))
return TRUE;
return true;
}
return FALSE;
return false;
}
_Function_class_(FAST_IO_QUERY_NETWORK_OPEN_INFO)
#ifdef __REACTOS__
static BOOLEAN NTAPI fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN Wait, FILE_NETWORK_OPEN_INFORMATION* fnoi,
static BOOLEAN __stdcall fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN Wait, FILE_NETWORK_OPEN_INFORMATION* fnoi,
PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
#else
static BOOLEAN fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN Wait, FILE_NETWORK_OPEN_INFORMATION* fnoi,
PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
#endif
fcb* fcb;
ccb* ccb;
file_ref* fileref;
@ -229,14 +208,14 @@ static BOOLEAN fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN
if (!fcb || fcb == fcb->Vcb->volume_fcb) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
ccb = FileObject->FsContext2;
if (!ccb) {
FsRtlExitFileSystem();
return FALSE;
return false;
}
fileref = ccb->fileref;
@ -253,7 +232,7 @@ static BOOLEAN fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN
if (!fileref || !fileref->parent) {
ERR("no fileref for stream\n");
FsRtlExitFileSystem();
return FALSE;
return false;
}
ii = &fileref->parent->fcb->inode_item;
@ -277,17 +256,16 @@ static BOOLEAN fast_io_query_network_open_info(PFILE_OBJECT FileObject, BOOLEAN
FsRtlExitFileSystem();
return TRUE;
return true;
}
_Function_class_(FAST_IO_ACQUIRE_FOR_MOD_WRITE)
#ifdef __REACTOS__
static NTSTATUS NTAPI fast_io_acquire_for_mod_write(PFILE_OBJECT FileObject, PLARGE_INTEGER EndingOffset, struct _ERESOURCE **ResourceToRelease, PDEVICE_OBJECT DeviceObject) {
#else
static NTSTATUS fast_io_acquire_for_mod_write(PFILE_OBJECT FileObject, PLARGE_INTEGER EndingOffset, struct _ERESOURCE **ResourceToRelease, PDEVICE_OBJECT DeviceObject) {
#endif
static NTSTATUS __stdcall fast_io_acquire_for_mod_write(PFILE_OBJECT FileObject, PLARGE_INTEGER EndingOffset,
struct _ERESOURCE **ResourceToRelease, PDEVICE_OBJECT DeviceObject) {
fcb* fcb;
TRACE("(%p, %I64x, %p, %p)\n", FileObject, EndingOffset ? EndingOffset->QuadPart : 0, ResourceToRelease, DeviceObject);
UNUSED(EndingOffset);
UNUSED(DeviceObject);
@ -298,30 +276,32 @@ static NTSTATUS fast_io_acquire_for_mod_write(PFILE_OBJECT FileObject, PLARGE_IN
// Make sure we don't get interrupted by the flush thread, which can cause a deadlock
if (!ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, FALSE))
if (!ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, false))
return STATUS_CANT_WAIT;
if (!ExAcquireResourceExclusiveLite(fcb->Header.Resource, false)) {
ExReleaseResourceLite(&fcb->Vcb->tree_lock);
TRACE("returning STATUS_CANT_WAIT\n");
return STATUS_CANT_WAIT;
}
// Ideally this would be PagingIoResource, but that doesn't play well with copy-on-write,
// as we can't guarantee that we won't need to do any reallocations.
*ResourceToRelease = fcb->Header.Resource;
if (!ExAcquireResourceExclusiveLite(*ResourceToRelease, FALSE)) {
ExReleaseResourceLite(&fcb->Vcb->tree_lock);
return STATUS_CANT_WAIT;
}
TRACE("returning STATUS_SUCCESS\n");
return STATUS_SUCCESS;
}
_Function_class_(FAST_IO_RELEASE_FOR_MOD_WRITE)
#ifdef __REACTOS__
static NTSTATUS NTAPI fast_io_release_for_mod_write(PFILE_OBJECT FileObject, struct _ERESOURCE *ResourceToRelease, PDEVICE_OBJECT DeviceObject) {
#else
static NTSTATUS fast_io_release_for_mod_write(PFILE_OBJECT FileObject, struct _ERESOURCE *ResourceToRelease, PDEVICE_OBJECT DeviceObject) {
#endif
static NTSTATUS __stdcall fast_io_release_for_mod_write(PFILE_OBJECT FileObject, struct _ERESOURCE *ResourceToRelease,
PDEVICE_OBJECT DeviceObject) {
fcb* fcb;
TRACE("(%p, %p, %p)\n", FileObject, ResourceToRelease, DeviceObject);
UNUSED(DeviceObject);
fcb = FileObject->FsContext;
@ -334,11 +314,7 @@ static NTSTATUS fast_io_release_for_mod_write(PFILE_OBJECT FileObject, struct _E
}
_Function_class_(FAST_IO_ACQUIRE_FOR_CCFLUSH)
#ifdef __REACTOS__
static NTSTATUS NTAPI fast_io_acquire_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
#else
static NTSTATUS fast_io_acquire_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
#endif
static NTSTATUS __stdcall fast_io_acquire_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
UNUSED(FileObject);
UNUSED(DeviceObject);
@ -348,11 +324,7 @@ static NTSTATUS fast_io_acquire_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJ
}
_Function_class_(FAST_IO_RELEASE_FOR_CCFLUSH)
#ifdef __REACTOS__
static NTSTATUS NTAPI fast_io_release_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
#else
static NTSTATUS fast_io_release_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
#endif
static NTSTATUS __stdcall fast_io_release_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJECT DeviceObject) {
UNUSED(FileObject);
UNUSED(DeviceObject);
@ -363,20 +335,134 @@ static NTSTATUS fast_io_release_for_ccflush(PFILE_OBJECT FileObject, PDEVICE_OBJ
}
_Function_class_(FAST_IO_WRITE)
#ifdef __REACTOS__
static BOOLEAN NTAPI fast_io_write(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
#else
static BOOLEAN fast_io_write(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
#endif
static BOOLEAN __stdcall fast_io_write(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
if (FsRtlCopyWrite(FileObject, FileOffset, Length, Wait, LockKey, Buffer, IoStatus, DeviceObject)) {
fcb* fcb = FileObject->FsContext;
fcb->inode_item.st_size = fcb->Header.FileSize.QuadPart;
return TRUE;
return true;
}
return FALSE;
return false;
}
_Function_class_(FAST_IO_LOCK)
static BOOLEAN __stdcall fast_io_lock(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PLARGE_INTEGER Length, PEPROCESS ProcessId,
ULONG Key, BOOLEAN FailImmediately, BOOLEAN ExclusiveLock, PIO_STATUS_BLOCK IoStatus,
PDEVICE_OBJECT DeviceObject) {
BOOLEAN ret;
fcb* fcb = FileObject->FsContext;
TRACE("(%p, %I64x, %I64x, %p, %x, %u, %u, %p, %p)\n", FileObject, FileOffset ? FileOffset->QuadPart : 0, Length ? Length->QuadPart : 0,
ProcessId, Key, FailImmediately, ExclusiveLock, IoStatus, DeviceObject);
if (fcb->type != BTRFS_TYPE_FILE) {
WARN("can only lock files\n");
IoStatus->Status = STATUS_INVALID_PARAMETER;
IoStatus->Information = 0;
return true;
}
FsRtlEnterFileSystem();
ExAcquireResourceSharedLite(fcb->Header.Resource, true);
ret = FsRtlFastLock(&fcb->lock, FileObject, FileOffset, Length, ProcessId, Key, FailImmediately,
ExclusiveLock, IoStatus, NULL, false);
if (ret)
fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
ExReleaseResourceLite(fcb->Header.Resource);
FsRtlExitFileSystem();
return ret;
}
_Function_class_(FAST_IO_UNLOCK_SINGLE)
static BOOLEAN __stdcall fast_io_unlock_single(PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, PLARGE_INTEGER Length, PEPROCESS ProcessId,
ULONG Key, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
fcb* fcb = FileObject->FsContext;
TRACE("(%p, %I64x, %I64x, %p, %x, %p, %p)\n", FileObject, FileOffset ? FileOffset->QuadPart : 0, Length ? Length->QuadPart : 0,
ProcessId, Key, IoStatus, DeviceObject);
IoStatus->Information = 0;
if (fcb->type != BTRFS_TYPE_FILE) {
WARN("can only lock files\n");
IoStatus->Status = STATUS_INVALID_PARAMETER;
return true;
}
FsRtlEnterFileSystem();
IoStatus->Status = FsRtlFastUnlockSingle(&fcb->lock, FileObject, FileOffset, Length, ProcessId, Key, NULL, false);
fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
FsRtlExitFileSystem();
return true;
}
_Function_class_(FAST_IO_UNLOCK_ALL)
static BOOLEAN __stdcall fast_io_unlock_all(PFILE_OBJECT FileObject, PEPROCESS ProcessId, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
fcb* fcb = FileObject->FsContext;
TRACE("(%p, %p, %p, %p)\n", FileObject, ProcessId, IoStatus, DeviceObject);
IoStatus->Information = 0;
if (fcb->type != BTRFS_TYPE_FILE) {
WARN("can only lock files\n");
IoStatus->Status = STATUS_INVALID_PARAMETER;
return true;
}
FsRtlEnterFileSystem();
ExAcquireResourceSharedLite(fcb->Header.Resource, true);
IoStatus->Status = FsRtlFastUnlockAll(&fcb->lock, FileObject, ProcessId, NULL);
fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
ExReleaseResourceLite(fcb->Header.Resource);
FsRtlExitFileSystem();
return true;
}
_Function_class_(FAST_IO_UNLOCK_ALL_BY_KEY)
static BOOLEAN __stdcall fast_io_unlock_all_by_key(PFILE_OBJECT FileObject, PVOID ProcessId, ULONG Key,
PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject) {
fcb* fcb = FileObject->FsContext;
TRACE("(%p, %p, %x, %p, %p)\n", FileObject, ProcessId, Key, IoStatus, DeviceObject);
IoStatus->Information = 0;
if (fcb->type != BTRFS_TYPE_FILE) {
WARN("can only lock files\n");
IoStatus->Status = STATUS_INVALID_PARAMETER;
return true;
}
FsRtlEnterFileSystem();
ExAcquireResourceSharedLite(fcb->Header.Resource, true);
IoStatus->Status = FsRtlFastUnlockAllByKey(&fcb->lock, FileObject, ProcessId, Key, NULL);
fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
ExReleaseResourceLite(fcb->Header.Resource);
FsRtlExitFileSystem();
return true;
}
void init_fast_io_dispatch(FAST_IO_DISPATCH** fiod) {
@ -385,19 +471,23 @@ void init_fast_io_dispatch(FAST_IO_DISPATCH** fiod) {
FastIoDispatch.SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
FastIoDispatch.FastIoCheckIfPossible = fast_io_check_if_possible;
FastIoDispatch.FastIoRead = FsRtlCopyRead;
FastIoDispatch.FastIoWrite = fast_io_write;
FastIoDispatch.FastIoQueryBasicInfo = fast_query_basic_info;
FastIoDispatch.FastIoQueryStandardInfo = fast_query_standard_info;
FastIoDispatch.FastIoLock = fast_io_lock;
FastIoDispatch.FastIoUnlockSingle = fast_io_unlock_single;
FastIoDispatch.FastIoUnlockAll = fast_io_unlock_all;
FastIoDispatch.FastIoUnlockAllByKey = fast_io_unlock_all_by_key;
FastIoDispatch.FastIoQueryNetworkOpenInfo = fast_io_query_network_open_info;
FastIoDispatch.AcquireForModWrite = fast_io_acquire_for_mod_write;
FastIoDispatch.ReleaseForModWrite = fast_io_release_for_mod_write;
FastIoDispatch.AcquireForCcFlush = fast_io_acquire_for_ccflush;
FastIoDispatch.ReleaseForCcFlush = fast_io_release_for_ccflush;
FastIoDispatch.FastIoWrite = fast_io_write;
FastIoDispatch.FastIoRead = FsRtlCopyRead;
FastIoDispatch.MdlRead = FsRtlMdlReadDev;
FastIoDispatch.MdlReadComplete = FsRtlMdlReadCompleteDev;
FastIoDispatch.PrepareMdlWrite = FsRtlPrepareMdlWriteDev;
FastIoDispatch.MdlWriteComplete = FsRtlMdlWriteCompleteDev;
FastIoDispatch.ReleaseForModWrite = fast_io_release_for_mod_write;
FastIoDispatch.AcquireForCcFlush = fast_io_acquire_for_ccflush;
FastIoDispatch.ReleaseForCcFlush = fast_io_release_for_ccflush;
*fiod = &FastIoDispatch;
}

612
drivers/filesystems/btrfs/fileinfo.c
View file

File diff suppressed because it is too large Load diff

1388
drivers/filesystems/btrfs/flushthread.c
View file

File diff suppressed because it is too large Load diff

351
drivers/filesystems/btrfs/free-space.c
View file

File diff suppressed because it is too large Load diff

681
drivers/filesystems/btrfs/fsctl.c
View file

File diff suppressed because it is too large Load diff

126
drivers/filesystems/btrfs/fsrtl.c Normal file
View file

@ -0,0 +1,126 @@
/*
* PROJECT: ReactOS Kernel - Vista+ APIs
* LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
* FILE: lib/drivers/ntoskrnl_vista/fsrtl.c
* PURPOSE: FsRtl functions of Vista+
* PROGRAMMERS: Pierre Schweitzer <pierre@reactos.org>
*/
#include <ntifs.h>
#include <ntdef.h>
FORCEINLINE
BOOLEAN
IsNullGuid(IN PGUID Guid)
{
if (Guid->Data1 == 0 && Guid->Data2 == 0 && Guid->Data3 == 0 &&
((ULONG *)Guid->Data4)[0] == 0 && ((ULONG *)Guid->Data4)[1] == 0)
{
return TRUE;
}
return FALSE;
}
FORCEINLINE
BOOLEAN
IsEven(IN USHORT Digit)
{
return ((Digit & 1) != 1);
}
NTSTATUS compat_FsRtlValidateReparsePointBuffer(IN ULONG BufferLength, IN PREPARSE_DATA_BUFFER ReparseBuffer)
{
USHORT DataLength;
ULONG ReparseTag;
PREPARSE_GUID_DATA_BUFFER GuidBuffer;
/* Validate data size range */
if (BufferLength < REPARSE_DATA_BUFFER_HEADER_SIZE || BufferLength > MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
{
return STATUS_IO_REPARSE_DATA_INVALID;
}
GuidBuffer = (PREPARSE_GUID_DATA_BUFFER)ReparseBuffer;
DataLength = ReparseBuffer->ReparseDataLength;
ReparseTag = ReparseBuffer->ReparseTag;
/* Validate size consistency */
if (DataLength + REPARSE_DATA_BUFFER_HEADER_SIZE != BufferLength && DataLength + REPARSE_GUID_DATA_BUFFER_HEADER_SIZE != BufferLength)
{
return STATUS_IO_REPARSE_DATA_INVALID;
}
/* REPARSE_DATA_BUFFER is reserved for MS tags */
if (DataLength + REPARSE_DATA_BUFFER_HEADER_SIZE == BufferLength && !IsReparseTagMicrosoft(ReparseTag))
{
return STATUS_IO_REPARSE_DATA_INVALID;
}
/* If that a GUID data buffer, its GUID cannot be null, and it cannot contain a MS tag */
if (DataLength + REPARSE_GUID_DATA_BUFFER_HEADER_SIZE == BufferLength && ((!IsReparseTagMicrosoft(ReparseTag)
&& IsNullGuid(&GuidBuffer->ReparseGuid)) || (ReparseTag == IO_REPARSE_TAG_MOUNT_POINT || ReparseTag == IO_REPARSE_TAG_SYMLINK)))
{
return STATUS_IO_REPARSE_DATA_INVALID;
}
/* Check the data for MS non reserved tags */
if (!(ReparseTag & 0xFFF0000) && ReparseTag != IO_REPARSE_TAG_RESERVED_ZERO && ReparseTag != IO_REPARSE_TAG_RESERVED_ONE)
{
/* If that's a mount point, validate the MountPointReparseBuffer branch */
if (ReparseTag == IO_REPARSE_TAG_MOUNT_POINT)
{
/* We need information */
if (DataLength >= REPARSE_DATA_BUFFER_HEADER_SIZE)
{
/* Substitue must be the first in row */
if (!ReparseBuffer->MountPointReparseBuffer.SubstituteNameOffset)
{
/* Substitude must be null-terminated */
if (ReparseBuffer->MountPointReparseBuffer.PrintNameOffset == ReparseBuffer->MountPointReparseBuffer.SubstituteNameLength + sizeof(UNICODE_NULL))
{
/* There must just be the Offset/Length fields + buffer + 2 null chars */
if (DataLength == ReparseBuffer->MountPointReparseBuffer.PrintNameLength + ReparseBuffer->MountPointReparseBuffer.SubstituteNameLength + (FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer.PathBuffer) - FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer.SubstituteNameOffset)) + 2 * sizeof(UNICODE_NULL))
{
return STATUS_SUCCESS;
}
}
}
}
}
else
{
#define FIELDS_SIZE (FIELD_OFFSET(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) - FIELD_OFFSET(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.SubstituteNameOffset))
/* If that's not a symlink, accept the MS tag as it */
if (ReparseTag != IO_REPARSE_TAG_SYMLINK)
{
return STATUS_SUCCESS;
}
/* We need information */
if (DataLength >= FIELDS_SIZE)
{
/* Validate lengths */
if (ReparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength && ReparseBuffer->SymbolicLinkReparseBuffer.PrintNameLength)
{
/* Validate unicode strings */
if (IsEven(ReparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength) && IsEven(ReparseBuffer->SymbolicLinkReparseBuffer.PrintNameLength) &&
IsEven(ReparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameOffset) && IsEven(ReparseBuffer->SymbolicLinkReparseBuffer.PrintNameOffset))
{
if ((DataLength + REPARSE_DATA_BUFFER_HEADER_SIZE >= ReparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameOffset + ReparseBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength + FIELDS_SIZE + REPARSE_DATA_BUFFER_HEADER_SIZE)
&& (DataLength + REPARSE_DATA_BUFFER_HEADER_SIZE >= ReparseBuffer->SymbolicLinkReparseBuffer.PrintNameLength + ReparseBuffer->SymbolicLinkReparseBuffer.PrintNameOffset + FIELDS_SIZE + REPARSE_DATA_BUFFER_HEADER_SIZE))
{
return STATUS_SUCCESS;
}
}
}
}
#undef FIELDS_SIZE
}
return STATUS_IO_REPARSE_DATA_INVALID;
}
return STATUS_IO_REPARSE_TAG_INVALID;
}

38
drivers/filesystems/btrfs/galois.c
View file

@ -17,7 +17,7 @@
#include "btrfs_drv.h"
static const UINT8 glog[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
static const uint8_t glog[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9, 0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35, 0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0, 0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
@ -34,7 +34,7 @@ static const UINT8 glog[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1
0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5, 0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83, 0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01};
static const UINT8 gilog[] = {0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
static const uint8_t gilog[] = {0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81, 0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21, 0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9, 0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
@ -52,7 +52,7 @@ static const UINT8 gilog[] = {0x00, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x
0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8, 0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf};
// divides the bytes in data by 2^div
void galois_divpower(UINT8* data, UINT8 div, UINT32 len) {
void galois_divpower(uint8_t* data, uint8_t div, uint32_t len) {
while (len > 0) {
if (data[0] != 0) {
if (gilog[data[0]] <= div)
@ -66,18 +66,18 @@ void galois_divpower(UINT8* data, UINT8 div, UINT32 len) {
}
}
UINT8 gpow2(UINT8 e) {
uint8_t gpow2(uint8_t e) {
return glog[e%255];
}
UINT8 gmul(UINT8 a, UINT8 b) {
uint8_t gmul(uint8_t a, uint8_t b) {
if (a == 0 || b == 0)
return 0;
else
return glog[(gilog[a] + gilog[b]) % 255];
}
UINT8 gdiv(UINT8 a, UINT8 b) {
uint8_t gdiv(uint8_t a, uint8_t b) {
if (b == 0) {
return 0xff; // shouldn't happen
} else if (a == 0) {
@ -95,41 +95,41 @@ UINT8 gdiv(UINT8 a, UINT8 b) {
// https://www.kernel.org/pub/linux/kernel/people/hpa/raid6.pdf
#ifdef _AMD64_
__inline static UINT64 galois_double_mask64(UINT64 v) {
__inline static uint64_t galois_double_mask64(uint64_t v) {
v &= 0x8080808080808080;
return (v << 1) - (v >> 7);
}
#else
__inline static UINT32 galois_double_mask32(UINT32 v) {
__inline static uint32_t galois_double_mask32(uint32_t v) {
v &= 0x80808080;
return (v << 1) - (v >> 7);
}
#endif
void galois_double(UINT8* data, UINT32 len) {
void galois_double(uint8_t* data, uint32_t len) {
// FIXME - SIMD?
#ifdef _AMD64_
while (len > sizeof(UINT64)) {
UINT64 v = *((UINT64*)data), vv;
while (len > sizeof(uint64_t)) {
uint64_t v = *((uint64_t*)data), vv;
vv = (v << 1) & 0xfefefefefefefefe;
vv ^= galois_double_mask64(v) & 0x1d1d1d1d1d1d1d1d;
*((UINT64*)data) = vv;
*((uint64_t*)data) = vv;
data += sizeof(UINT64);
len -= sizeof(UINT64);
data += sizeof(uint64_t);
len -= sizeof(uint64_t);
}
#else
while (len > sizeof(UINT32)) {
UINT32 v = *((UINT32*)data), vv;
while (len > sizeof(uint32_t)) {
uint32_t v = *((uint32_t*)data), vv;
vv = (v << 1) & 0xfefefefe;
vv ^= galois_double_mask32(v) & 0x1d1d1d1d;
*((UINT32*)data) = vv;
*((uint32_t*)data) = vv;
data += sizeof(UINT32);
len -= sizeof(UINT32);
data += sizeof(uint32_t);
len -= sizeof(uint32_t);
}
#endif

188
drivers/filesystems/btrfs/pnp.c
View file

@ -38,11 +38,7 @@ extern ERESOURCE pdo_list_lock;
extern LIST_ENTRY pdo_list;
_Function_class_(IO_COMPLETION_ROUTINE)
#ifdef __REACTOS__
static NTSTATUS NTAPI pnp_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
#else
static NTSTATUS pnp_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
#endif
static NTSTATUS __stdcall pnp_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
pnp_stripe* stripe = conptr;
pnp_context* context = (pnp_context*)stripe->context;
@ -53,7 +49,7 @@ static NTSTATUS pnp_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conp
InterlockedDecrement(&context->left);
if (context->left == 0)
KeSetEvent(&context->Event, 0, FALSE);
KeSetEvent(&context->Event, 0, false);
return STATUS_MORE_PROCESSING_REQUIRED;
}
@ -65,7 +61,7 @@ static NTSTATUS send_disks_pnp_message(device_extension* Vcb, UCHAR minor) {
LIST_ENTRY* le;
RtlZeroMemory(&context, sizeof(pnp_context));
KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
KeInitializeEvent(&context.Event, NotificationEvent, false);
num_devices = (ULONG)min(0xffffffff, Vcb->superblock.num_devices);
@ -87,10 +83,10 @@ static NTSTATUS send_disks_pnp_message(device_extension* Vcb, UCHAR minor) {
if (dev->devobj) {
context.stripes[i].context = (struct pnp_context*)&context;
context.stripes[i].Irp = IoAllocateIrp(dev->devobj->StackSize, FALSE);
context.stripes[i].Irp = IoAllocateIrp(dev->devobj->StackSize, false);
if (!context.stripes[i].Irp) {
UINT64 j;
uint64_t j;
ERR("IoAllocateIrp failed\n");
@ -107,10 +103,11 @@ static NTSTATUS send_disks_pnp_message(device_extension* Vcb, UCHAR minor) {
IrpSp = IoGetNextIrpStackLocation(context.stripes[i].Irp);
IrpSp->MajorFunction = IRP_MJ_PNP;
IrpSp->MinorFunction = minor;
IrpSp->FileObject = dev->fileobj;
context.stripes[i].Irp->UserIosb = &context.stripes[i].iosb;
IoSetCompletionRoutine(context.stripes[i].Irp, pnp_completion, &context.stripes[i], TRUE, TRUE, TRUE);
IoSetCompletionRoutine(context.stripes[i].Irp, pnp_completion, &context.stripes[i], true, true, true);
context.stripes[i].Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
context.stripes[i].dev = dev;
@ -132,7 +129,7 @@ static NTSTATUS send_disks_pnp_message(device_extension* Vcb, UCHAR minor) {
}
}
KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
Status = STATUS_SUCCESS;
@ -159,9 +156,9 @@ static NTSTATUS pnp_cancel_remove_device(PDEVICE_OBJECT DeviceObject) {
device_extension* Vcb = DeviceObject->DeviceExtension;
NTSTATUS Status;
ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, TRUE);
ExAcquireResourceExclusiveLite(&Vcb->fileref_lock, true);
if (Vcb->root_fileref && Vcb->root_fileref->fcb && (Vcb->root_fileref->open_count > 0 || has_open_children(Vcb->root_fileref))) {
Status = STATUS_ACCESS_DENIED;
@ -185,7 +182,7 @@ NTSTATUS pnp_query_remove_device(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
device_extension* Vcb = DeviceObject->DeviceExtension;
NTSTATUS Status;
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
if (Vcb->root_fileref && Vcb->root_fileref->fcb && (Vcb->root_fileref->open_count > 0 || has_open_children(Vcb->root_fileref))) {
Status = STATUS_ACCESS_DENIED;
@ -198,7 +195,7 @@ NTSTATUS pnp_query_remove_device(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
goto end;
}
Vcb->removing = TRUE;
Vcb->removing = true;
if (Vcb->need_write && !Vcb->readonly) {
Status = do_write(Vcb, Irp);
@ -223,7 +220,7 @@ static NTSTATUS pnp_remove_device(PDEVICE_OBJECT DeviceObject) {
device_extension* Vcb = DeviceObject->DeviceExtension;
NTSTATUS Status;
ExAcquireResourceSharedLite(&Vcb->tree_lock, TRUE);
ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
Status = send_disks_pnp_message(Vcb, IRP_MN_REMOVE_DEVICE);
@ -241,8 +238,8 @@ static NTSTATUS pnp_remove_device(PDEVICE_OBJECT DeviceObject) {
if (Vcb->vde)
Vcb->vde->mounted_device = NULL;
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
Vcb->removing = TRUE;
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
Vcb->removing = true;
ExReleaseResourceLite(&Vcb->tree_lock);
if (Vcb->open_files == 0)
@ -258,12 +255,12 @@ NTSTATUS pnp_surprise_removal(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
TRACE("(%p, %p)\n", DeviceObject, Irp);
if (DeviceObject->Vpb->Flags & VPB_MOUNTED) {
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
if (Vcb->vde)
Vcb->vde->mounted_device = NULL;
Vcb->removing = TRUE;
Vcb->removing = true;
ExReleaseResourceLite(&Vcb->tree_lock);
@ -274,14 +271,14 @@ NTSTATUS pnp_surprise_removal(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
return STATUS_SUCCESS;
}
static void bus_query_capabilities(PIRP Irp) {
static NTSTATUS bus_query_capabilities(PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PDEVICE_CAPABILITIES dc = IrpSp->Parameters.DeviceCapabilities.Capabilities;
dc->UniqueID = TRUE;
dc->SilentInstall = TRUE;
dc->UniqueID = true;
dc->SilentInstall = true;
Irp->IoStatus.Status = STATUS_SUCCESS;
return STATUS_SUCCESS;
}
static NTSTATUS bus_query_device_relations(PIRP Irp) {
@ -291,7 +288,7 @@ static NTSTATUS bus_query_device_relations(PIRP Irp) {
ULONG drsize, i;
DEVICE_RELATIONS* dr;
ExAcquireResourceSharedLite(&pdo_list_lock, TRUE);
ExAcquireResourceSharedLite(&pdo_list_lock, true);
num_children = 0;
@ -332,9 +329,6 @@ static NTSTATUS bus_query_device_relations(PIRP Irp) {
end:
ExReleaseResourceLite(&pdo_list_lock);
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
@ -356,38 +350,45 @@ static NTSTATUS bus_query_hardware_ids(PIRP Irp) {
return STATUS_SUCCESS;
}
static NTSTATUS bus_pnp(control_device_extension* cde, PIRP Irp) {
static NTSTATUS bus_pnp(bus_device_extension* bde, PIRP Irp) {
NTSTATUS Status = Irp->IoStatus.Status;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
bool handled = false;
switch (IrpSp->MinorFunction) {
case IRP_MN_QUERY_CAPABILITIES:
bus_query_capabilities(Irp);
Status = bus_query_capabilities(Irp);
handled = true;
break;
case IRP_MN_QUERY_DEVICE_RELATIONS:
if (IrpSp->Parameters.QueryDeviceRelations.Type != BusRelations || no_pnp)
break;
return bus_query_device_relations(Irp);
Status = bus_query_device_relations(Irp);
handled = true;
break;
case IRP_MN_QUERY_ID:
{
NTSTATUS Status;
if (IrpSp->Parameters.QueryId.IdType != BusQueryHardwareIDs)
break;
Status = bus_query_hardware_ids(Irp);
handled = true;
break;
}
if (!NT_SUCCESS(Status) && handled) {
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
}
Irp->IoStatus.Status = Status;
IoSkipCurrentIrpStackLocation(Irp);
return IoCallDriver(cde->attached_device, Irp);
return IoCallDriver(bde->attached_device, Irp);
}
static NTSTATUS pdo_query_device_id(pdo_device_extension* pdode, PIRP Irp) {
@ -460,6 +461,84 @@ static NTSTATUS pdo_query_id(pdo_device_extension* pdode, PIRP Irp) {
return Irp->IoStatus.Status;
}
typedef struct {
IO_STATUS_BLOCK iosb;
KEVENT Event;
NTSTATUS Status;
} device_usage_context;
_Function_class_(IO_COMPLETION_ROUTINE)
static NTSTATUS __stdcall device_usage_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
device_usage_context* context = conptr;
UNUSED(DeviceObject);
context->Status = Irp->IoStatus.Status;
KeSetEvent(&context->Event, 0, false);
return STATUS_MORE_PROCESSING_REQUIRED;
}
static NTSTATUS pdo_device_usage_notification(pdo_device_extension* pdode, PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
LIST_ENTRY* le;
TRACE("(%p, %p)\n", pdode, Irp);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
le = pdode->children.Flink;
while (le != &pdode->children) {
volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
if (vc->devobj) {
PIRP Irp2;
PIO_STACK_LOCATION IrpSp2;
device_usage_context context;
Irp2 = IoAllocateIrp(vc->devobj->StackSize, false);
if (!Irp2) {
ERR("out of memory\n");
ExReleaseResourceLite(&pdode->child_lock);
return STATUS_INSUFFICIENT_RESOURCES;
}
IrpSp2 = IoGetNextIrpStackLocation(Irp2);
IrpSp2->MajorFunction = IRP_MJ_PNP;
IrpSp2->MinorFunction = IRP_MN_DEVICE_USAGE_NOTIFICATION;
IrpSp2->Parameters.UsageNotification = IrpSp->Parameters.UsageNotification;
IrpSp2->FileObject = vc->fileobj;
context.iosb.Status = STATUS_SUCCESS;
Irp2->UserIosb = &context.iosb;
KeInitializeEvent(&context.Event, NotificationEvent, false);
Irp2->UserEvent = &context.Event;
IoSetCompletionRoutine(Irp2, device_usage_completion, &context, true, true, true);
context.Status = IoCallDriver(vc->devobj, Irp2);
if (context.Status == STATUS_PENDING)
KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
if (!NT_SUCCESS(context.Status)) {
ERR("IoCallDriver returned %08x\n", context.Status);
ExReleaseResourceLite(&pdode->child_lock);
return context.Status;
}
}
le = le->Flink;
}
ExReleaseResourceLite(&pdode->child_lock);
return STATUS_SUCCESS;
}
static NTSTATUS pdo_pnp(PDEVICE_OBJECT pdo, PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
pdo_device_extension* pdode = pdo->DeviceExtension;
@ -476,30 +555,55 @@ static NTSTATUS pdo_pnp(PDEVICE_OBJECT pdo, PIRP Irp) {
case IRP_MN_QUERY_REMOVE_DEVICE:
return STATUS_UNSUCCESSFUL;
case IRP_MN_DEVICE_USAGE_NOTIFICATION:
return pdo_device_usage_notification(pdode, Irp);
}
return Irp->IoStatus.Status;
}
static NTSTATUS pnp_device_usage_notification(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
device_extension* Vcb = DeviceObject->DeviceExtension;
if (IrpSp->Parameters.UsageNotification.InPath) {
switch (IrpSp->Parameters.UsageNotification.Type) {
case DeviceUsageTypePaging:
case DeviceUsageTypeHibernation:
case DeviceUsageTypeDumpFile:
IoAdjustPagingPathCount(&Vcb->page_file_count, IrpSp->Parameters.UsageNotification.InPath);
break;
default:
break;
}
}
IoSkipCurrentIrpStackLocation(Irp);
return IoCallDriver(Vcb->Vpb->RealDevice, Irp);
}
_Dispatch_type_(IRP_MJ_PNP)
_Function_class_(DRIVER_DISPATCH)
NTSTATUS NTAPI drv_pnp(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
NTSTATUS __stdcall drv_pnp(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
device_extension* Vcb = DeviceObject->DeviceExtension;
NTSTATUS Status;
BOOL top_level;
bool top_level;
FsRtlEnterFileSystem();
top_level = is_top_level(Irp);
if (Vcb && Vcb->type == VCB_TYPE_CONTROL) {
if (Vcb && Vcb->type == VCB_TYPE_BUS) {
Status = bus_pnp(DeviceObject->DeviceExtension, Irp);
goto exit;
} else if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
volume_device_extension* vde = DeviceObject->DeviceExtension;
IoSkipCurrentIrpStackLocation(Irp);
Status = IoCallDriver(vde->pdo, Irp);
Status = IoCallDriver(vde->attached_device, Irp);
goto exit;
} else if (Vcb && Vcb->type == VCB_TYPE_PDO) {
Status = pdo_pnp(DeviceObject, Irp);
@ -528,6 +632,10 @@ NTSTATUS NTAPI drv_pnp(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
Status = pnp_surprise_removal(DeviceObject, Irp);
break;
case IRP_MN_DEVICE_USAGE_NOTIFICATION:
Status = pnp_device_usage_notification(DeviceObject, Irp);
goto exit;
default:
TRACE("passing minor function 0x%x on\n", IrpSp->MinorFunction);

980
drivers/filesystems/btrfs/read.c
View file

File diff suppressed because it is too large Load diff

128
drivers/filesystems/btrfs/registry.c
View file

@ -133,64 +133,64 @@ NTSTATUS registry_load_volume_options(device_extension* Vcb) {
us.Length = us.MaximumLength = (USHORT)kvfi->NameLength;
us.Buffer = kvfi->Name;
if (FsRtlAreNamesEqual(&ignoreus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
if (FsRtlAreNamesEqual(&ignoreus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->ignore = *val != 0 ? TRUE : FALSE;
} else if (FsRtlAreNamesEqual(&compressus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
options->ignore = *val != 0 ? true : false;
} else if (FsRtlAreNamesEqual(&compressus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->compress = *val != 0 ? TRUE : FALSE;
} else if (FsRtlAreNamesEqual(&compressforceus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
options->compress = *val != 0 ? true : false;
} else if (FsRtlAreNamesEqual(&compressforceus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->compress_force = *val != 0 ? TRUE : FALSE;
} else if (FsRtlAreNamesEqual(&compresstypeus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
options->compress_force = *val != 0 ? true : false;
} else if (FsRtlAreNamesEqual(&compresstypeus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->compress_type = (UINT8)(*val > BTRFS_COMPRESSION_ZSTD ? 0 : *val);
} else if (FsRtlAreNamesEqual(&readonlyus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
options->compress_type = (uint8_t)(*val > BTRFS_COMPRESSION_ZSTD ? 0 : *val);
} else if (FsRtlAreNamesEqual(&readonlyus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->readonly = *val != 0 ? TRUE : FALSE;
} else if (FsRtlAreNamesEqual(&zliblevelus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
options->readonly = *val != 0 ? true : false;
} else if (FsRtlAreNamesEqual(&zliblevelus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->zlib_level = *val;
} else if (FsRtlAreNamesEqual(&flushintervalus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
} else if (FsRtlAreNamesEqual(&flushintervalus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->flush_interval = *val;
} else if (FsRtlAreNamesEqual(&maxinlineus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
} else if (FsRtlAreNamesEqual(&maxinlineus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->max_inline = min(*val, Vcb->superblock.node_size - sizeof(tree_header) - sizeof(leaf_node) - sizeof(EXTENT_DATA) + 1);
} else if (FsRtlAreNamesEqual(&subvolidus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_QWORD) {
UINT64* val = (UINT64*)((UINT8*)kvfi + kvfi->DataOffset);
} else if (FsRtlAreNamesEqual(&subvolidus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_QWORD) {
uint64_t* val = (uint64_t*)((uint8_t*)kvfi + kvfi->DataOffset);
options->subvol_id = *val;
} else if (FsRtlAreNamesEqual(&skipbalanceus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
} else if (FsRtlAreNamesEqual(&skipbalanceus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->skip_balance = *val;
} else if (FsRtlAreNamesEqual(&nobarrierus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
} else if (FsRtlAreNamesEqual(&nobarrierus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->no_barrier = *val;
} else if (FsRtlAreNamesEqual(&notrimus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
} else if (FsRtlAreNamesEqual(&notrimus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->no_trim = *val;
} else if (FsRtlAreNamesEqual(&clearcacheus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
} else if (FsRtlAreNamesEqual(&clearcacheus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->clear_cache = *val;
} else if (FsRtlAreNamesEqual(&allowdegradedus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
} else if (FsRtlAreNamesEqual(&allowdegradedus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->allow_degraded = *val;
} else if (FsRtlAreNamesEqual(&zstdlevelus, &us, TRUE, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((UINT8*)kvfi + kvfi->DataOffset);
} else if (FsRtlAreNamesEqual(&zstdlevelus, &us, true, NULL) && kvfi->DataOffset > 0 && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
DWORD* val = (DWORD*)((uint8_t*)kvfi + kvfi->DataOffset);
options->zstd_level = *val;
}
@ -201,12 +201,12 @@ NTSTATUS registry_load_volume_options(device_extension* Vcb) {
} while (NT_SUCCESS(Status));
if (!options->compress && options->compress_force)
options->compress = TRUE;
options->compress = true;
if (options->zlib_level > 9)
options->zlib_level = 9;
if (options->zstd_level > (UINT32)ZSTD_maxCLevel())
if (options->zstd_level > (uint32_t)ZSTD_maxCLevel())
options->zstd_level = ZSTD_maxCLevel();
if (options->flush_interval == 0)
@ -296,7 +296,7 @@ static NTSTATUS registry_mark_volume_unmounted_path(PUNICODE_STRING path) {
NTSTATUS Status;
ULONG index, kvbilen = sizeof(KEY_VALUE_BASIC_INFORMATION) - sizeof(WCHAR) + (255 * sizeof(WCHAR)), retlen;
KEY_VALUE_BASIC_INFORMATION* kvbi;
BOOL has_options = FALSE;
bool has_options = false;
UNICODE_STRING mountedus;
// If a volume key has any options in it, we set Mounted to 0 and return. Otherwise,
@ -332,8 +332,8 @@ static NTSTATUS registry_mark_volume_unmounted_path(PUNICODE_STRING path) {
us.Length = us.MaximumLength = (USHORT)kvbi->NameLength;
us.Buffer = kvbi->Name;
if (!FsRtlAreNamesEqual(&mountedus, &us, TRUE, NULL)) {
has_options = TRUE;
if (!FsRtlAreNamesEqual(&mountedus, &us, true, NULL)) {
has_options = true;
break;
}
} else if (Status != STATUS_NO_MORE_ENTRIES) {
@ -416,21 +416,21 @@ end:
#define is_hex(c) ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
static BOOL is_uuid(ULONG namelen, WCHAR* name) {
static bool is_uuid(ULONG namelen, WCHAR* name) {
ULONG i;
if (namelen != 36 * sizeof(WCHAR))
return FALSE;
return false;
for (i = 0; i < 36; i++) {
if (i == 8 || i == 13 || i == 18 || i == 23) {
if (name[i] != '-')
return FALSE;
return false;
} else if (!is_hex(name[i]))
return FALSE;
return false;
}
return TRUE;
return true;
}
typedef struct {
@ -552,7 +552,7 @@ static void read_mappings(PUNICODE_STRING regpath) {
}
RtlCopyMemory(path, regpath->Buffer, regpath->Length);
RtlCopyMemory((UINT8*)path + regpath->Length, mappings, sizeof(mappings) - sizeof(WCHAR));
RtlCopyMemory((uint8_t*)path + regpath->Length, mappings, sizeof(mappings) - sizeof(WCHAR));
us.Buffer = path;
us.Length = us.MaximumLength = regpath->Length + sizeof(mappings) - sizeof(WCHAR);
@ -586,9 +586,9 @@ static void read_mappings(PUNICODE_STRING regpath) {
Status = ZwEnumerateValueKey(h, i, KeyValueFullInformation, kvfi, kvfilen, &retlen);
if (NT_SUCCESS(Status) && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
UINT32 val = 0;
uint32_t val = 0;
RtlCopyMemory(&val, (UINT8*)kvfi + kvfi->DataOffset, min(kvfi->DataLength, sizeof(UINT32)));
RtlCopyMemory(&val, (uint8_t*)kvfi + kvfi->DataOffset, min(kvfi->DataLength, sizeof(uint32_t)));
TRACE("entry %u = %.*S = %u\n", i, kvfi->NameLength / sizeof(WCHAR), kvfi->Name, val);
@ -630,7 +630,7 @@ static void read_group_mappings(PUNICODE_STRING regpath) {
}
RtlCopyMemory(path, regpath->Buffer, regpath->Length);
RtlCopyMemory((UINT8*)path + regpath->Length, mappings, sizeof(mappings) - sizeof(WCHAR));
RtlCopyMemory((uint8_t*)path + regpath->Length, mappings, sizeof(mappings) - sizeof(WCHAR));
us.Buffer = path;
us.Length = us.MaximumLength = regpath->Length + sizeof(mappings) - sizeof(WCHAR);
@ -665,9 +665,9 @@ static void read_group_mappings(PUNICODE_STRING regpath) {
Status = ZwEnumerateValueKey(h, i, KeyValueFullInformation, kvfi, kvfilen, &retlen);
if (NT_SUCCESS(Status) && kvfi->DataLength > 0 && kvfi->Type == REG_DWORD) {
UINT32 val = 0;
uint32_t val = 0;
RtlCopyMemory(&val, (UINT8*)kvfi + kvfi->DataOffset, min(kvfi->DataLength, sizeof(UINT32)));
RtlCopyMemory(&val, (uint8_t*)kvfi + kvfi->DataOffset, min(kvfi->DataLength, sizeof(uint32_t)));
TRACE("entry %u = %.*S = %u\n", i, kvfi->NameLength / sizeof(WCHAR), kvfi->Name, val);
@ -734,7 +734,7 @@ static void get_registry_value(HANDLE h, WCHAR* string, ULONG type, void* val, U
if (NT_SUCCESS(Status)) {
if (kvfi->Type == type && kvfi->DataLength >= size) {
RtlCopyMemory(val, ((UINT8*)kvfi) + kvfi->DataOffset, size);
RtlCopyMemory(val, ((uint8_t*)kvfi) + kvfi->DataOffset, size);
} else {
Status = ZwDeleteValueKey(h, &us);
if (!NT_SUCCESS(Status)) {
@ -760,7 +760,7 @@ static void get_registry_value(HANDLE h, WCHAR* string, ULONG type, void* val, U
}
}
void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
void read_registry(PUNICODE_STRING regpath, bool refresh) {
OBJECT_ATTRIBUTES oa;
NTSTATUS Status;
HANDLE h;
@ -773,7 +773,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
static const WCHAR def_log_file[] = L"\\??\\C:\\btrfs.log";
#endif
ExAcquireResourceExclusiveLite(&mapping_lock, TRUE);
ExAcquireResourceExclusiveLite(&mapping_lock, true);
read_mappings(regpath);
read_group_mappings(regpath);
@ -849,7 +849,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
return;
}
RtlCopyMemory(log_device.Buffer, ((UINT8*)kvfi) + kvfi->DataOffset, log_device.Length);
RtlCopyMemory(log_device.Buffer, ((uint8_t*)kvfi) + kvfi->DataOffset, log_device.Length);
if (log_device.Buffer[(log_device.Length / sizeof(WCHAR)) - 1] == 0)
log_device.Length -= sizeof(WCHAR);
@ -868,7 +868,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
ERR("ZwQueryValueKey returned %08x\n", Status);
}
ExAcquireResourceExclusiveLite(&log_lock, TRUE);
ExAcquireResourceExclusiveLite(&log_lock, true);
if (refresh && (log_device.Length != old_log_device.Length || RtlCompareMemory(log_device.Buffer, old_log_device.Buffer, log_device.Length) != log_device.Length ||
(!comfo && log_device.Length > 0) || (old_debug_log_level == 0 && debug_log_level > 0) || (old_debug_log_level > 0 && debug_log_level == 0))) {
@ -926,7 +926,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
return;
}
RtlCopyMemory(log_file.Buffer, ((UINT8*)kvfi) + kvfi->DataOffset, log_file.Length);
RtlCopyMemory(log_file.Buffer, ((uint8_t*)kvfi) + kvfi->DataOffset, log_file.Length);
if (log_file.Buffer[(log_file.Length / sizeof(WCHAR)) - 1] == 0)
log_file.Length -= sizeof(WCHAR);
@ -970,7 +970,7 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
RtlCopyMemory(log_file.Buffer, def_log_file, log_file.Length);
}
ExAcquireResourceExclusiveLite(&log_lock, TRUE);
ExAcquireResourceExclusiveLite(&log_lock, true);
if (refresh && (log_file.Length != old_log_file.Length || RtlCompareMemory(log_file.Buffer, old_log_file.Buffer, log_file.Length) != log_file.Length ||
(!log_handle && log_file.Length > 0) || (old_debug_log_level == 0 && debug_log_level > 0) || (old_debug_log_level > 0 && debug_log_level == 0))) {
@ -1003,20 +1003,16 @@ void read_registry(PUNICODE_STRING regpath, BOOL refresh) {
}
_Function_class_(WORKER_THREAD_ROUTINE)
#ifdef __REACTOS__
static void NTAPI registry_work_item(PVOID Parameter) {
#else
static void registry_work_item(PVOID Parameter) {
#endif
static void __stdcall registry_work_item(PVOID Parameter) {
NTSTATUS Status;
HANDLE regh = (HANDLE)Parameter;
IO_STATUS_BLOCK iosb;
TRACE("registry changed\n");
read_registry(&registry_path, TRUE);
read_registry(&registry_path, true);
Status = ZwNotifyChangeKey(regh, NULL, (PVOID)&wqi, (PVOID)DelayedWorkQueue, &iosb, REG_NOTIFY_CHANGE_LAST_SET, TRUE, NULL, 0, TRUE);
Status = ZwNotifyChangeKey(regh, NULL, (PVOID)&wqi, (PVOID)DelayedWorkQueue, &iosb, REG_NOTIFY_CHANGE_LAST_SET, true, NULL, 0, true);
if (!NT_SUCCESS(Status))
ERR("ZwNotifyChangeKey returned %08x\n", Status);
}
@ -1027,7 +1023,7 @@ void watch_registry(HANDLE regh) {
ExInitializeWorkItem(&wqi, registry_work_item, regh);
Status = ZwNotifyChangeKey(regh, NULL, (PVOID)&wqi, (PVOID)DelayedWorkQueue, &iosb, REG_NOTIFY_CHANGE_LAST_SET, TRUE, NULL, 0, TRUE);
Status = ZwNotifyChangeKey(regh, NULL, (PVOID)&wqi, (PVOID)DelayedWorkQueue, &iosb, REG_NOTIFY_CHANGE_LAST_SET, true, NULL, 0, true);
if (!NT_SUCCESS(Status))
ERR("ZwNotifyChangeKey returned %08x\n", Status);
}

74
drivers/filesystems/btrfs/reparse.c
View file

@ -17,6 +17,8 @@
#include "btrfs_drv.h"
extern tFsRtlValidateReparsePointBuffer fFsRtlValidateReparsePointBuffer;
NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject, void* buffer, DWORD buflen, ULONG_PTR* retlen) {
USHORT subnamelen, printnamelen, i;
ULONG stringlen;
@ -31,12 +33,12 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
if (!ccb)
return STATUS_INVALID_PARAMETER;
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
ExAcquireResourceSharedLite(fcb->Header.Resource, true);
if (fcb->type == BTRFS_TYPE_SYMLINK) {
if (ccb->lxss) {
reqlen = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(UINT32);
reqlen = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(uint32_t);
if (buflen < reqlen) {
Status = STATUS_BUFFER_OVERFLOW;
@ -44,10 +46,10 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
}
rdb->ReparseTag = IO_REPARSE_TAG_LXSS_SYMLINK;
rdb->ReparseDataLength = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(UINT32);
rdb->ReparseDataLength = offsetof(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) + sizeof(uint32_t);
rdb->Reserved = 0;
*((UINT32*)rdb->GenericReparseBuffer.DataBuffer) = 1;
*((uint32_t*)rdb->GenericReparseBuffer.DataBuffer) = 1;
*retlen = reqlen;
} else {
@ -66,7 +68,7 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
}
TRACE("data = %p, size = %x\n", data, fcb->inode_item.st_size);
Status = read_file(fcb, (UINT8*)data, 0, fcb->inode_item.st_size, NULL, NULL);
Status = read_file(fcb, (uint8_t*)data, 0, fcb->inode_item.st_size, NULL, NULL);
if (!NT_SUCCESS(Status)) {
ERR("read_file returned %08x\n", Status);
@ -74,15 +76,15 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
goto end;
}
Status = RtlUTF8ToUnicodeN(NULL, 0, &stringlen, data, (ULONG)fcb->inode_item.st_size);
Status = utf8_to_utf16(NULL, 0, &stringlen, data, (ULONG)fcb->inode_item.st_size);
if (!NT_SUCCESS(Status)) {
ERR("RtlUTF8ToUnicodeN 1 returned %08x\n", Status);
ERR("utf8_to_utf16 1 returned %08x\n", Status);
ExFreePool(data);
goto end;
}
subnamelen = (UINT16)stringlen;
printnamelen = (UINT16)stringlen;
subnamelen = (uint16_t)stringlen;
printnamelen = (uint16_t)stringlen;
reqlen = offsetof(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) + subnamelen + printnamelen;
@ -108,11 +110,11 @@ NTSTATUS get_reparse_point(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
rdb->SymbolicLinkReparseBuffer.PrintNameLength = printnamelen;
rdb->SymbolicLinkReparseBuffer.Flags = SYMLINK_FLAG_RELATIVE;
Status = RtlUTF8ToUnicodeN(&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
Status = utf8_to_utf16(&rdb->SymbolicLinkReparseBuffer.PathBuffer[rdb->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)],
stringlen, &stringlen, data, (ULONG)fcb->inode_item.st_size);
if (!NT_SUCCESS(Status)) {
ERR("RtlUTF8ToUnicodeN 2 returned %08x\n", Status);
ERR("utf8_to_utf16 2 returned %08x\n", Status);
ExFreePool(data);
goto end;
}
@ -169,7 +171,7 @@ end:
return Status;
}
static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, BOOL write, LIST_ENTRY* rollback) {
static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, bool write, LIST_ENTRY* rollback) {
NTSTATUS Status;
ULONG minlen;
ULONG tlength;
@ -211,9 +213,9 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REP
return Status;
}
Status = RtlUnicodeToUTF8N(NULL, 0, (PULONG)&target.Length, subname.Buffer, subname.Length);
Status = utf16_to_utf8(NULL, 0, (PULONG)&target.Length, subname.Buffer, subname.Length);
if (!NT_SUCCESS(Status)) {
ERR("RtlUnicodeToUTF8N 1 failed with error %08x\n", Status);
ERR("utf16_to_utf8 1 failed with error %08x\n", Status);
return Status;
}
@ -224,9 +226,9 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REP
return STATUS_INSUFFICIENT_RESOURCES;
}
Status = RtlUnicodeToUTF8N(target.Buffer, target.Length, (PULONG)&target.Length, subname.Buffer, subname.Length);
Status = utf16_to_utf8(target.Buffer, target.Length, (PULONG)&target.Length, subname.Buffer, subname.Length);
if (!NT_SUCCESS(Status)) {
ERR("RtlUnicodeToUTF8N 2 failed with error %08x\n", Status);
ERR("utf16_to_utf8 2 failed with error %08x\n", Status);
ExFreePool(target.Buffer);
return Status;
}
@ -238,8 +240,8 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REP
offset.QuadPart = 0;
tlength = target.Length;
Status = write_file2(fcb->Vcb, Irp, offset, target.Buffer, &tlength, FALSE, TRUE,
TRUE, FALSE, FALSE, rollback);
Status = write_file2(fcb->Vcb, Irp, offset, target.Buffer, &tlength, false, true,
true, false, false, rollback);
ExFreePool(target.Buffer);
} else
Status = STATUS_SUCCESS;
@ -259,7 +261,7 @@ static NTSTATUS set_symlink(PIRP Irp, file_ref* fileref, fcb* fcb, ccb* ccb, REP
fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
fcb->subvol->root_item.ctime = now;
fcb->inode_item_changed = TRUE;
fcb->inode_item_changed = true;
mark_fcb_dirty(fcb);
if (fileref)
@ -286,7 +288,7 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, cc
return STATUS_INVALID_BUFFER_SIZE;
}
Status = FsRtlValidateReparsePointBuffer(buflen, rdb);
Status = fFsRtlValidateReparsePointBuffer(buflen, rdb);
if (!NT_SUCCESS(Status)) {
ERR("FsRtlValidateReparsePointBuffer returned %08x\n", Status);
return Status;
@ -310,7 +312,7 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, cc
ERR("out of memory\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
buf.Length = buf.MaximumLength = (UINT16)buflen;
buf.Length = buf.MaximumLength = (uint16_t)buflen;
if (fcb->reparse_xattr.Buffer)
ExFreePool(fcb->reparse_xattr.Buffer);
@ -318,7 +320,7 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, cc
fcb->reparse_xattr = buf;
RtlCopyMemory(buf.Buffer, rdb, buflen);
fcb->reparse_xattr_changed = TRUE;
fcb->reparse_xattr_changed = true;
Status = STATUS_SUCCESS;
} else { // otherwise, store as file data
@ -330,7 +332,7 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, cc
offset.QuadPart = 0;
Status = write_file2(fcb->Vcb, Irp, offset, rdb, &buflen, FALSE, TRUE, TRUE, FALSE, FALSE, rollback);
Status = write_file2(fcb->Vcb, Irp, offset, rdb, &buflen, false, true, true, false, false, rollback);
if (!NT_SUCCESS(Status)) {
ERR("write_file2 returned %08x\n", Status);
return Status;
@ -350,12 +352,12 @@ NTSTATUS set_reparse_point2(fcb* fcb, REPARSE_DATA_BUFFER* rdb, ULONG buflen, cc
fcb->inode_item.st_mtime = now;
fcb->atts |= FILE_ATTRIBUTE_REPARSE_POINT;
fcb->atts_changed = TRUE;
fcb->atts_changed = true;
fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
fcb->subvol->root_item.ctime = now;
fcb->inode_item_changed = TRUE;
fcb->inode_item_changed = true;
mark_fcb_dirty(fcb);
}
@ -414,8 +416,8 @@ NTSTATUS set_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
TRACE("%S\n", file_desc(FileObject));
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
Status = set_reparse_point2(fcb, rdb, buflen, ccb, fileref, Irp, &rollback);
if (!NT_SUCCESS(Status)) {
@ -483,8 +485,8 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
return STATUS_INVALID_PARAMETER;
}
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, TRUE);
ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
TRACE("%S\n", file_desc(FileObject));
@ -539,7 +541,7 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
mark_fileref_dirty(fileref);
fileref->fcb->inode_item_changed = TRUE;
fileref->fcb->inode_item_changed = true;
mark_fcb_dirty(fileref->fcb);
fileref->fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
@ -557,7 +559,7 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
}
fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
fcb->atts_changed = TRUE;
fcb->atts_changed = true;
KeQuerySystemTime(&time);
win_time_to_unix(time, &now);
@ -571,7 +573,7 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
if (!ccb->user_set_write_time)
fcb->inode_item.st_mtime = now;
fcb->inode_item_changed = TRUE;
fcb->inode_item_changed = true;
mark_fcb_dirty(fcb);
fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;
@ -583,14 +585,14 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
// FIXME - do we need to check that the reparse tags match?
fcb->atts &= ~FILE_ATTRIBUTE_REPARSE_POINT;
fcb->atts_changed = TRUE;
fcb->atts_changed = true;
if (fcb->reparse_xattr.Buffer) {
ExFreePool(fcb->reparse_xattr.Buffer);
fcb->reparse_xattr.Buffer = NULL;
}
fcb->reparse_xattr_changed = TRUE;
fcb->reparse_xattr_changed = true;
KeQuerySystemTime(&time);
win_time_to_unix(time, &now);
@ -604,7 +606,7 @@ NTSTATUS delete_reparse_point(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
if (!ccb->user_set_write_time)
fcb->inode_item.st_mtime = now;
fcb->inode_item_changed = TRUE;
fcb->inode_item_changed = true;
mark_fcb_dirty(fcb);
fcb->subvol->root_item.ctransid = fcb->Vcb->superblock.generation;

878
drivers/filesystems/btrfs/scrub.c
View file

File diff suppressed because it is too large Load diff

218
drivers/filesystems/btrfs/search.c
View file

@ -17,12 +17,10 @@
#include "btrfs_drv.h"
#ifndef __REACTOS__
#include <ntddk.h>
#include <ntifs.h>
#include <mountmgr.h>
#include <windef.h>
#endif
#include <ntddstor.h>
#include <ntdddisk.h>
@ -34,27 +32,29 @@ extern LIST_ENTRY pdo_list;
extern UNICODE_STRING registry_path;
extern KEVENT mountmgr_thread_event;
extern HANDLE mountmgr_thread_handle;
extern BOOL shutting_down;
extern bool shutting_down;
extern PDEVICE_OBJECT busobj;
extern tIoUnregisterPlugPlayNotificationEx fIoUnregisterPlugPlayNotificationEx;
typedef void (*pnp_callback)(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath);
extern PDEVICE_OBJECT master_devobj;
static BOOL fs_ignored(BTRFS_UUID* uuid) {
static bool fs_ignored(BTRFS_UUID* uuid) {
UNICODE_STRING path, ignoreus;
NTSTATUS Status;
OBJECT_ATTRIBUTES oa;
KEY_VALUE_FULL_INFORMATION* kvfi;
ULONG dispos, retlen, kvfilen, i, j;
HANDLE h;
BOOL ret = FALSE;
bool ret = false;
path.Length = path.MaximumLength = registry_path.Length + (37 * sizeof(WCHAR));
path.Buffer = ExAllocatePoolWithTag(PagedPool, path.Length, ALLOC_TAG);
if (!path.Buffer) {
ERR("out of memory\n");
return FALSE;
return false;
}
RtlCopyMemory(path.Buffer, registry_path.Buffer, registry_path.Length);
@ -83,7 +83,7 @@ static BOOL fs_ignored(BTRFS_UUID* uuid) {
if (!NT_SUCCESS(Status)) {
TRACE("ZwCreateKey returned %08x\n", Status);
ExFreePool(path.Buffer);
return FALSE;
return false;
}
RtlInitUnicodeString(&ignoreus, L"Ignore");
@ -94,13 +94,13 @@ static BOOL fs_ignored(BTRFS_UUID* uuid) {
ERR("out of memory\n");
ZwClose(h);
ExFreePool(path.Buffer);
return FALSE;
return false;
}
Status = ZwQueryValueKey(h, &ignoreus, KeyValueFullInformation, kvfi, kvfilen, &retlen);
if (NT_SUCCESS(Status)) {
if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(UINT32)) {
UINT32* pr = (UINT32*)((UINT8*)kvfi + kvfi->DataOffset);
if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(uint32_t)) {
uint32_t* pr = (uint32_t*)((uint8_t*)kvfi + kvfi->DataOffset);
ret = *pr;
}
@ -113,12 +113,12 @@ static BOOL fs_ignored(BTRFS_UUID* uuid) {
return ret;
}
static void test_vol(PDEVICE_OBJECT mountmgr, PDEVICE_OBJECT DeviceObject, PUNICODE_STRING devpath,
DWORD disk_num, DWORD part_num, UINT64 length) {
static void test_vol(PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject,
PUNICODE_STRING devpath, DWORD disk_num, DWORD part_num, uint64_t length) {
NTSTATUS Status;
ULONG toread;
UINT8* data = NULL;
UINT32 sector_size;
uint8_t* data = NULL;
uint32_t sector_size;
TRACE("%.*S\n", devpath->Length / sizeof(WCHAR), devpath->Buffer);
@ -129,7 +129,7 @@ static void test_vol(PDEVICE_OBJECT mountmgr, PDEVICE_OBJECT DeviceObject, PUNIC
IO_STATUS_BLOCK iosb;
Status = dev_ioctl(DeviceObject, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
&geometry, sizeof(DISK_GEOMETRY), TRUE, &iosb);
&geometry, sizeof(DISK_GEOMETRY), true, &iosb);
if (!NT_SUCCESS(Status)) {
ERR("%.*S had a sector size of 0, and IOCTL_DISK_GET_DRIVE_GEOMETRY returned %08x\n",
@ -157,13 +157,13 @@ static void test_vol(PDEVICE_OBJECT mountmgr, PDEVICE_OBJECT DeviceObject, PUNIC
goto deref;
}
Status = sync_read_phys(DeviceObject, superblock_addrs[0], toread, data, TRUE);
Status = sync_read_phys(DeviceObject, FileObject, superblock_addrs[0], toread, data, true);
if (NT_SUCCESS(Status) && ((superblock*)data)->magic == BTRFS_MAGIC) {
superblock* sb = (superblock*)data;
UINT32 crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
if (crc32 != *((UINT32*)sb->checksum))
if (crc32 != *((uint32_t*)sb->checksum))
ERR("checksum error on superblock\n");
else {
TRACE("volume found\n");
@ -178,12 +178,12 @@ static void test_vol(PDEVICE_OBJECT mountmgr, PDEVICE_OBJECT DeviceObject, PUNIC
}
while (superblock_addrs[i] > 0 && length >= superblock_addrs[i] + toread) {
Status = sync_read_phys(DeviceObject, superblock_addrs[i], toread, (PUCHAR)sb2, TRUE);
Status = sync_read_phys(DeviceObject, FileObject, superblock_addrs[i], toread, (PUCHAR)sb2, true);
if (NT_SUCCESS(Status) && sb2->magic == BTRFS_MAGIC) {
crc32 = ~calc_crc32c(0xffffffff, (UINT8*)&sb2->uuid, (ULONG)sizeof(superblock) - sizeof(sb2->checksum));
crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb2->uuid, (ULONG)sizeof(superblock) - sizeof(sb2->checksum));
if (crc32 == *((UINT32*)sb2->checksum) && sb2->generation > sb->generation)
if (crc32 == *((uint32_t*)sb2->checksum) && sb2->generation > sb->generation)
RtlCopyMemory(sb, sb2, toread);
}
@ -195,7 +195,7 @@ static void test_vol(PDEVICE_OBJECT mountmgr, PDEVICE_OBJECT DeviceObject, PUNIC
if (!fs_ignored(&sb->uuid)) {
DeviceObject->Flags &= ~DO_VERIFY_VOLUME;
add_volume_device(sb, mountmgr, devpath, length, disk_num, part_num);
add_volume_device(sb, devpath, length, disk_num, part_num);
}
}
}
@ -227,7 +227,7 @@ NTSTATUS remove_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath) {
mmp->DeviceNameLength = devpath->Length;
RtlCopyMemory(&mmp[1], devpath->Buffer, devpath->Length);
Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_DELETE_POINTS, mmp, mmpsize, &mmps1, sizeof(MOUNTMGR_MOUNT_POINTS), FALSE, NULL);
Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_DELETE_POINTS, mmp, mmpsize, &mmps1, sizeof(MOUNTMGR_MOUNT_POINTS), false, NULL);
if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
ERR("IOCTL_MOUNTMGR_DELETE_POINTS 1 returned %08x\n", Status);
@ -247,7 +247,7 @@ NTSTATUS remove_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath) {
return STATUS_INSUFFICIENT_RESOURCES;
}
Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_DELETE_POINTS, mmp, mmpsize, mmps2, mmps1.Size, FALSE, NULL);
Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_DELETE_POINTS, mmp, mmpsize, mmps2, mmps1.Size, false, NULL);
if (!NT_SUCCESS(Status))
ERR("IOCTL_MOUNTMGR_DELETE_POINTS 2 returned %08x\n", Status);
@ -259,32 +259,23 @@ NTSTATUS remove_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath) {
}
void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
PFILE_OBJECT FileObject, mountmgrfo;
PDEVICE_OBJECT devobj, mountmgr;
PFILE_OBJECT fileobj;
PDEVICE_OBJECT devobj;
NTSTATUS Status;
STORAGE_DEVICE_NUMBER sdn;
ULONG dlisize;
DRIVE_LAYOUT_INFORMATION_EX* dli = NULL;
IO_STATUS_BLOCK iosb;
GET_LENGTH_INFORMATION gli;
UNICODE_STRING mmdevpath;
UNUSED(DriverObject);
Status = IoGetDeviceObjectPointer(devpath, FILE_READ_ATTRIBUTES, &FileObject, &devobj);
Status = IoGetDeviceObjectPointer(devpath, FILE_READ_ATTRIBUTES, &fileobj, &devobj);
if (!NT_SUCCESS(Status)) {
ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
return;
}
RtlInitUnicodeString(&mmdevpath, MOUNTMGR_DEVICE_NAME);
Status = IoGetDeviceObjectPointer(&mmdevpath, FILE_READ_ATTRIBUTES, &mountmgrfo, &mountmgr);
if (!NT_SUCCESS(Status)) {
ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
ObDereferenceObject(FileObject);
return;
}
dlisize = 0;
do {
@ -300,7 +291,7 @@ void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
}
Status = dev_ioctl(devobj, IOCTL_DISK_GET_DRIVE_LAYOUT_EX, NULL, 0,
dli, dlisize, TRUE, &iosb);
dli, dlisize, true, &iosb);
} while (Status == STATUS_BUFFER_TOO_SMALL);
// only consider disk as a potential filesystem if it has no partitions
@ -312,7 +303,7 @@ void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
ExFreePool(dli);
Status = dev_ioctl(devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
&gli, sizeof(gli), TRUE, NULL);
&gli, sizeof(gli), true, NULL);
if (!NT_SUCCESS(Status)) {
ERR("error reading length information: %08x\n", Status);
@ -320,7 +311,7 @@ void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
}
Status = dev_ioctl(devobj, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0,
&sdn, sizeof(STORAGE_DEVICE_NUMBER), TRUE, NULL);
&sdn, sizeof(STORAGE_DEVICE_NUMBER), true, NULL);
if (!NT_SUCCESS(Status)) {
TRACE("IOCTL_STORAGE_GET_DEVICE_NUMBER returned %08x\n", Status);
sdn.DeviceNumber = 0xffffffff;
@ -328,25 +319,24 @@ void disk_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
} else
TRACE("DeviceType = %u, DeviceNumber = %u, PartitionNumber = %u\n", sdn.DeviceType, sdn.DeviceNumber, sdn.PartitionNumber);
test_vol(mountmgr, devobj, devpath, sdn.DeviceNumber, sdn.PartitionNumber, gli.Length.QuadPart);
test_vol(devobj, fileobj, devpath, sdn.DeviceNumber, sdn.PartitionNumber, gli.Length.QuadPart);
end:
ObDereferenceObject(FileObject);
ObDereferenceObject(mountmgrfo);
ObDereferenceObject(fileobj);
}
void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lock) _Releases_exclusive_lock_(_Curr_->child_lock) _In_ volume_device_extension* vde,
_In_ volume_child* vc, _In_ BOOL skip_dev) {
_In_ volume_child* vc, _In_ bool skip_dev) {
NTSTATUS Status;
pdo_device_extension* pdode = vde->pdode;
device_extension* Vcb = vde->mounted_device ? vde->mounted_device->DeviceExtension : NULL;
if (vc->notification_entry)
#ifdef __REACTOS__
if (vc->notification_entry) {
if (fIoUnregisterPlugPlayNotificationEx)
fIoUnregisterPlugPlayNotificationEx(vc->notification_entry);
else
IoUnregisterPlugPlayNotification(vc->notification_entry);
#else
IoUnregisterPlugPlayNotificationEx(vc->notification_entry);
#endif
}
if (vde->mounted_device && (!Vcb || !Vcb->options.allow_degraded)) {
Status = pnp_surprise_removal(vde->mounted_device, NULL);
@ -355,7 +345,7 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
}
if (!Vcb || !Vcb->options.allow_degraded) {
Status = IoSetDeviceInterfaceState(&vde->bus_name, FALSE);
Status = IoSetDeviceInterfaceState(&vde->bus_name, false);
if (!NT_SUCCESS(Status))
WARN("IoSetDeviceInterfaceState returned %08x\n", Status);
}
@ -380,7 +370,7 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
if (vc2->had_drive_letter) { // re-add entry to mountmgr
MOUNTDEV_NAME mdn;
Status = dev_ioctl(vc2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), TRUE, NULL);
Status = dev_ioctl(vc2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), true, NULL);
if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
else {
@ -391,7 +381,7 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
if (!mdn2)
ERR("out of memory\n");
else {
Status = dev_ioctl(vc2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, TRUE, NULL);
Status = dev_ioctl(vc2->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, true, NULL);
if (!NT_SUCCESS(Status))
ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
else {
@ -416,7 +406,7 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
ObDereferenceObject(FileObject);
}
} else if (!skip_dev) {
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
le = Vcb->devices.Flink;
while (le != &Vcb->devices) {
@ -458,13 +448,13 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
pdode->children_loaded--;
if (pdode->children_loaded == 0) { // remove volume device
BOOL remove = FALSE;
bool remove = false;
RemoveEntryList(&pdode->list_entry);
vde->removing = TRUE;
vde->removing = true;
Status = IoSetDeviceInterfaceState(&vde->bus_name, FALSE);
Status = IoSetDeviceInterfaceState(&vde->bus_name, false);
if (!NT_SUCCESS(Status))
WARN("IoSetDeviceInterfaceState returned %08x\n", Status);
@ -472,14 +462,14 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
IoDetachDevice(vde->pdo);
if (vde->open_count == 0)
remove = TRUE;
remove = true;
ExReleaseResourceLite(&pdode->child_lock);
if (!no_pnp) {
control_device_extension* cde = master_devobj->DeviceExtension;
bus_device_extension* bde = busobj->DeviceExtension;
IoInvalidateDeviceRelations(cde->buspdo, BusRelations);
IoInvalidateDeviceRelations(bde->buspdo, BusRelations);
}
if (remove) {
@ -499,15 +489,14 @@ void remove_volume_child(_Inout_ _Requires_exclusive_lock_held_(_Curr_->child_lo
void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
STORAGE_DEVICE_NUMBER sdn;
PFILE_OBJECT FileObject, mountmgrfo;
UNICODE_STRING mmdevpath;
PDEVICE_OBJECT devobj, mountmgr;
PFILE_OBJECT fileobj;
PDEVICE_OBJECT devobj;
GET_LENGTH_INFORMATION gli;
NTSTATUS Status;
TRACE("%.*S\n", devpath->Length / sizeof(WCHAR), devpath->Buffer);
Status = IoGetDeviceObjectPointer(devpath, FILE_READ_ATTRIBUTES, &FileObject, &devobj);
Status = IoGetDeviceObjectPointer(devpath, FILE_READ_ATTRIBUTES, &fileobj, &devobj);
if (!NT_SUCCESS(Status)) {
ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
return;
@ -518,14 +507,14 @@ void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
if (devobj->DriverObject == DriverObject)
goto end;
Status = dev_ioctl(devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli), TRUE, NULL);
Status = dev_ioctl(devobj, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli), true, NULL);
if (!NT_SUCCESS(Status)) {
ERR("IOCTL_DISK_GET_LENGTH_INFO returned %08x\n", Status);
goto end;
}
Status = dev_ioctl(devobj, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0,
&sdn, sizeof(STORAGE_DEVICE_NUMBER), TRUE, NULL);
&sdn, sizeof(STORAGE_DEVICE_NUMBER), true, NULL);
if (!NT_SUCCESS(Status)) {
TRACE("IOCTL_STORAGE_GET_DEVICE_NUMBER returned %08x\n", Status);
sdn.DeviceNumber = 0xffffffff;
@ -537,16 +526,16 @@ void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
if (sdn.DeviceNumber != 0xffffffff && sdn.PartitionNumber != 0) {
LIST_ENTRY* le;
ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE);
ExAcquireResourceExclusiveLite(&pdo_list_lock, true);
le = pdo_list.Flink;
while (le != &pdo_list) {
pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
LIST_ENTRY* le2;
BOOL changed = FALSE;
bool changed = false;
if (pdode->vde) {
ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
le2 = pdode->children.Flink;
while (le2 != &pdode->children) {
@ -556,8 +545,8 @@ void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
if (vc->disk_num == sdn.DeviceNumber && vc->part_num == 0) {
TRACE("removing device\n");
remove_volume_child(pdode->vde, vc, FALSE);
changed = TRUE;
remove_volume_child(pdode->vde, vc, false);
changed = true;
break;
}
@ -577,19 +566,10 @@ void volume_arrival(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
ExReleaseResourceLite(&pdo_list_lock);
}
RtlInitUnicodeString(&mmdevpath, MOUNTMGR_DEVICE_NAME);
Status = IoGetDeviceObjectPointer(&mmdevpath, FILE_READ_ATTRIBUTES, &mountmgrfo, &mountmgr);
if (!NT_SUCCESS(Status)) {
ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
goto end;
}
test_vol(mountmgr, devobj, devpath, sdn.DeviceNumber, sdn.PartitionNumber, gli.Length.QuadPart);
ObDereferenceObject(mountmgrfo);
test_vol(devobj, fileobj, devpath, sdn.DeviceNumber, sdn.PartitionNumber, gli.Length.QuadPart);
end:
ObDereferenceObject(FileObject);
ObDereferenceObject(fileobj);
}
void volume_removal(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
@ -609,16 +589,16 @@ void volume_removal(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
devpath2.MaximumLength -= 3 * sizeof(WCHAR);
}
ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE);
ExAcquireResourceExclusiveLite(&pdo_list_lock, true);
le = pdo_list.Flink;
while (le != &pdo_list) {
pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
LIST_ENTRY* le2;
BOOL changed = FALSE;
bool changed = false;
if (pdode->vde) {
ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
le2 = pdode->children.Flink;
while (le2 != &pdode->children) {
@ -628,8 +608,8 @@ void volume_removal(PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath) {
if (vc->pnp_name.Length == devpath2.Length && RtlCompareMemory(vc->pnp_name.Buffer, devpath2.Buffer, devpath2.Length) == devpath2.Length) {
TRACE("removing device\n");
remove_volume_child(pdode->vde, vc, FALSE);
changed = TRUE;
remove_volume_child(pdode->vde, vc, false);
changed = true;
break;
}
@ -657,11 +637,7 @@ typedef struct {
} pnp_callback_context;
_Function_class_(IO_WORKITEM_ROUTINE)
#ifdef __REACTOS__
static void NTAPI do_pnp_callback(PDEVICE_OBJECT DeviceObject, PVOID con) {
#else
static void do_pnp_callback(PDEVICE_OBJECT DeviceObject, PVOID con) {
#endif
static void __stdcall do_pnp_callback(PDEVICE_OBJECT DeviceObject, PVOID con) {
pnp_callback_context* context = con;
UNUSED(DeviceObject);
@ -713,11 +689,7 @@ static void enqueue_pnp_callback(PDRIVER_OBJECT DriverObject, PUNICODE_STRING na
}
_Function_class_(DRIVER_NOTIFICATION_CALLBACK_ROUTINE)
#ifdef __REACTOS__
NTSTATUS NTAPI volume_notification(PVOID NotificationStructure, PVOID Context) {
#else
NTSTATUS volume_notification(PVOID NotificationStructure, PVOID Context) {
#endif
NTSTATUS __stdcall volume_notification(PVOID NotificationStructure, PVOID Context) {
DEVICE_INTERFACE_CHANGE_NOTIFICATION* dicn = (DEVICE_INTERFACE_CHANGE_NOTIFICATION*)NotificationStructure;
PDRIVER_OBJECT DriverObject = (PDRIVER_OBJECT)Context;
@ -730,11 +702,7 @@ NTSTATUS volume_notification(PVOID NotificationStructure, PVOID Context) {
}
_Function_class_(DRIVER_NOTIFICATION_CALLBACK_ROUTINE)
#ifdef __REACTOS__
NTSTATUS NTAPI pnp_notification(PVOID NotificationStructure, PVOID Context) {
#else
NTSTATUS pnp_notification(PVOID NotificationStructure, PVOID Context) {
#endif
NTSTATUS __stdcall pnp_notification(PVOID NotificationStructure, PVOID Context) {
DEVICE_INTERFACE_CHANGE_NOTIFICATION* dicn = (DEVICE_INTERFACE_CHANGE_NOTIFICATION*)NotificationStructure;
PDRIVER_OBJECT DriverObject = (PDRIVER_OBJECT)Context;
@ -749,16 +717,17 @@ NTSTATUS pnp_notification(PVOID NotificationStructure, PVOID Context) {
static void mountmgr_process_drive(PDEVICE_OBJECT mountmgr, PUNICODE_STRING device_name) {
NTSTATUS Status;
LIST_ENTRY* le;
BOOL done = FALSE;
bool need_remove = false;
volume_child* vc2 = NULL;
ExAcquireResourceSharedLite(&pdo_list_lock, TRUE);
ExAcquireResourceSharedLite(&pdo_list_lock, true);
le = pdo_list.Flink;
while (le != &pdo_list) {
pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
LIST_ENTRY* le2;
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
le2 = pdode->children.Flink;
@ -768,7 +737,7 @@ static void mountmgr_process_drive(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devi
if (vc->devobj) {
MOUNTDEV_NAME mdn;
Status = dev_ioctl(vc->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), TRUE, NULL);
Status = dev_ioctl(vc->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &mdn, sizeof(MOUNTDEV_NAME), true, NULL);
if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
else {
@ -779,18 +748,13 @@ static void mountmgr_process_drive(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devi
if (!mdn2)
ERR("out of memory\n");
else {
Status = dev_ioctl(vc->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, TRUE, NULL);
Status = dev_ioctl(vc->devobj, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, mdn2, mdnsize, true, NULL);
if (!NT_SUCCESS(Status))
ERR("IOCTL_MOUNTDEV_QUERY_DEVICE_NAME returned %08x\n", Status);
else {
if (mdn2->NameLength == device_name->Length && RtlCompareMemory(mdn2->Name, device_name->Buffer, device_name->Length) == device_name->Length) {
Status = remove_drive_letter(mountmgr, device_name);
if (!NT_SUCCESS(Status))
ERR("remove_drive_letter returned %08x\n", Status);
else
vc->had_drive_letter = TRUE;
done = TRUE;
vc2 = vc;
need_remove = true;
break;
}
}
@ -805,13 +769,21 @@ static void mountmgr_process_drive(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devi
ExReleaseResourceLite(&pdode->child_lock);
if (done)
if (need_remove)
break;
le = le->Flink;
}
ExReleaseResourceLite(&pdo_list_lock);
if (need_remove) {
Status = remove_drive_letter(mountmgr, device_name);
if (!NT_SUCCESS(Status))
ERR("remove_drive_letter returned %08x\n", Status);
else
vc2->had_drive_letter = true;
}
}
static void mountmgr_updated(PDEVICE_OBJECT mountmgr, MOUNTMGR_MOUNT_POINTS* mmps) {
@ -823,7 +795,7 @@ static void mountmgr_updated(PDEVICE_OBJECT mountmgr, MOUNTMGR_MOUNT_POINTS* mmp
UNICODE_STRING symlink, device_name;
if (mmps->MountPoints[i].SymbolicLinkNameOffset != 0) {
symlink.Buffer = (WCHAR*)(((UINT8*)mmps) + mmps->MountPoints[i].SymbolicLinkNameOffset);
symlink.Buffer = (WCHAR*)(((uint8_t*)mmps) + mmps->MountPoints[i].SymbolicLinkNameOffset);
symlink.Length = symlink.MaximumLength = mmps->MountPoints[i].SymbolicLinkNameLength;
} else {
symlink.Buffer = NULL;
@ -831,7 +803,7 @@ static void mountmgr_updated(PDEVICE_OBJECT mountmgr, MOUNTMGR_MOUNT_POINTS* mmp
}
if (mmps->MountPoints[i].DeviceNameOffset != 0) {
device_name.Buffer = (WCHAR*)(((UINT8*)mmps) + mmps->MountPoints[i].DeviceNameOffset);
device_name.Buffer = (WCHAR*)(((uint8_t*)mmps) + mmps->MountPoints[i].DeviceNameOffset);
device_name.Length = device_name.MaximumLength = mmps->MountPoints[i].DeviceNameLength;
} else {
device_name.Buffer = NULL;
@ -845,11 +817,7 @@ static void mountmgr_updated(PDEVICE_OBJECT mountmgr, MOUNTMGR_MOUNT_POINTS* mmp
}
_Function_class_(KSTART_ROUTINE)
#ifdef __REACTOS__
void NTAPI mountmgr_thread(_In_ void* context) {
#else
void mountmgr_thread(_In_ void* context) {
#endif
void __stdcall mountmgr_thread(_In_ void* context) {
UNICODE_STRING mmdevpath;
NTSTATUS Status;
PFILE_OBJECT FileObject;
@ -867,7 +835,7 @@ void mountmgr_thread(_In_ void* context) {
mcni.EpicNumber = 0;
while (TRUE) {
while (true) {
PIRP Irp;
MOUNTMGR_MOUNT_POINT mmp;
MOUNTMGR_MOUNT_POINTS mmps;
@ -876,7 +844,7 @@ void mountmgr_thread(_In_ void* context) {
KeClearEvent(&mountmgr_thread_event);
Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTMGR_CHANGE_NOTIFY, mountmgr, &mcni, sizeof(MOUNTMGR_CHANGE_NOTIFY_INFO),
&mcni, sizeof(MOUNTMGR_CHANGE_NOTIFY_INFO), FALSE, &mountmgr_thread_event, &iosb);
&mcni, sizeof(MOUNTMGR_CHANGE_NOTIFY_INFO), false, &mountmgr_thread_event, &iosb);
if (!Irp) {
ERR("out of memory\n");
@ -886,7 +854,7 @@ void mountmgr_thread(_In_ void* context) {
Status = IoCallDriver(mountmgr, Irp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject(&mountmgr_thread_event, Executive, KernelMode, FALSE, NULL);
KeWaitForSingleObject(&mountmgr_thread_event, Executive, KernelMode, false, NULL);
Status = iosb.Status;
}
@ -903,7 +871,7 @@ void mountmgr_thread(_In_ void* context) {
RtlZeroMemory(&mmp, sizeof(MOUNTMGR_MOUNT_POINT));
Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_QUERY_POINTS, &mmp, sizeof(MOUNTMGR_MOUNT_POINT), &mmps, sizeof(MOUNTMGR_MOUNT_POINTS),
FALSE, NULL);
false, NULL);
if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
ERR("IOCTL_MOUNTMGR_QUERY_POINTS 1 returned %08x\n", Status);
@ -917,7 +885,7 @@ void mountmgr_thread(_In_ void* context) {
}
Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_QUERY_POINTS, &mmp, sizeof(MOUNTMGR_MOUNT_POINTS), mmps2, mmps.Size,
FALSE, NULL);
false, NULL);
if (!NT_SUCCESS(Status))
ERR("IOCTL_MOUNTMGR_QUERY_POINTS returned %08x\n", Status);
else

104
drivers/filesystems/btrfs/security.c
View file

@ -24,7 +24,7 @@ typedef struct {
UCHAR revision;
UCHAR elements;
UCHAR auth[6];
UINT32 nums[8];
uint32_t nums[8];
} sid_header;
static sid_header sid_BA = { 1, 2, SECURITY_NT_AUTHORITY, {32, 544}}; // BUILTIN\Administrators
@ -53,10 +53,10 @@ static dacl def_dacls[] = {
extern LIST_ENTRY uid_map_list, gid_map_list;
extern ERESOURCE mapping_lock;
void add_user_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 uid) {
void add_user_mapping(WCHAR* sidstring, ULONG sidstringlength, uint32_t uid) {
unsigned int i, np;
UINT8 numdashes;
UINT64 val;
uint8_t numdashes;
uint64_t val;
ULONG sidsize;
sid_header* sid;
uid_map* um;
@ -106,17 +106,17 @@ void add_user_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 uid) {
}
i++;
TRACE("val = %u, i = %u, ssl = %u\n", (UINT32)val, i, sidstringlength);
TRACE("val = %u, i = %u, ssl = %u\n", (uint32_t)val, i, sidstringlength);
if (np == 0) {
sid->auth[0] = (UINT8)((val & 0xff0000000000) >> 40);
sid->auth[1] = (UINT8)((val & 0xff00000000) >> 32);
sid->auth[2] = (UINT8)((val & 0xff000000) >> 24);
sid->auth[3] = (UINT8)((val & 0xff0000) >> 16);
sid->auth[4] = (UINT8)((val & 0xff00) >> 8);
sid->auth[0] = (uint8_t)((val & 0xff0000000000) >> 40);
sid->auth[1] = (uint8_t)((val & 0xff00000000) >> 32);
sid->auth[2] = (uint8_t)((val & 0xff000000) >> 24);
sid->auth[3] = (uint8_t)((val & 0xff0000) >> 16);
sid->auth[4] = (uint8_t)((val & 0xff00) >> 8);
sid->auth[5] = val & 0xff;
} else {
sid->nums[np-1] = (UINT32)val;
sid->nums[np-1] = (uint32_t)val;
}
np++;
@ -142,10 +142,10 @@ void add_user_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 uid) {
InsertTailList(&uid_map_list, &um->listentry);
}
void add_group_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 gid) {
void add_group_mapping(WCHAR* sidstring, ULONG sidstringlength, uint32_t gid) {
unsigned int i, np;
UINT8 numdashes;
UINT64 val;
uint8_t numdashes;
uint64_t val;
ULONG sidsize;
sid_header* sid;
gid_map* gm;
@ -191,17 +191,17 @@ void add_group_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 gid) {
}
i++;
TRACE("val = %u, i = %u, ssl = %u\n", (UINT32)val, i, sidstringlength);
TRACE("val = %u, i = %u, ssl = %u\n", (uint32_t)val, i, sidstringlength);
if (np == 0) {
sid->auth[0] = (UINT8)((val & 0xff0000000000) >> 40);
sid->auth[1] = (UINT8)((val & 0xff00000000) >> 32);
sid->auth[2] = (UINT8)((val & 0xff000000) >> 24);
sid->auth[3] = (UINT8)((val & 0xff0000) >> 16);
sid->auth[4] = (UINT8)((val & 0xff00) >> 8);
sid->auth[0] = (uint8_t)((val & 0xff0000000000) >> 40);
sid->auth[1] = (uint8_t)((val & 0xff00000000) >> 32);
sid->auth[2] = (uint8_t)((val & 0xff000000) >> 24);
sid->auth[3] = (uint8_t)((val & 0xff0000) >> 16);
sid->auth[4] = (uint8_t)((val & 0xff00) >> 8);
sid->auth[5] = val & 0xff;
} else
sid->nums[np-1] = (UINT32)val;
sid->nums[np-1] = (uint32_t)val;
np++;
@ -226,12 +226,12 @@ void add_group_mapping(WCHAR* sidstring, ULONG sidstringlength, UINT32 gid) {
InsertTailList(&gid_map_list, &gm->listentry);
}
NTSTATUS uid_to_sid(UINT32 uid, PSID* sid) {
NTSTATUS uid_to_sid(uint32_t uid, PSID* sid) {
LIST_ENTRY* le;
sid_header* sh;
UCHAR els;
ExAcquireResourceSharedLite(&mapping_lock, TRUE);
ExAcquireResourceSharedLite(&mapping_lock, true);
le = uid_map_list.Flink;
while (le != &uid_map_list) {
@ -261,7 +261,7 @@ NTSTATUS uid_to_sid(UINT32 uid, PSID* sid) {
els = 1;
sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header) + ((els - 1) * sizeof(UINT32)), ALLOC_TAG);
sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header) + ((els - 1) * sizeof(uint32_t)), ALLOC_TAG);
if (!sh) {
ERR("out of memory\n");
*sid = NULL;
@ -307,11 +307,11 @@ NTSTATUS uid_to_sid(UINT32 uid, PSID* sid) {
return STATUS_SUCCESS;
}
UINT32 sid_to_uid(PSID sid) {
uint32_t sid_to_uid(PSID sid) {
LIST_ENTRY* le;
sid_header* sh = sid;
ExAcquireResourceSharedLite(&mapping_lock, TRUE);
ExAcquireResourceSharedLite(&mapping_lock, true);
le = uid_map_list.Flink;
while (le != &uid_map_list) {
@ -338,7 +338,7 @@ UINT32 sid_to_uid(PSID sid) {
return UID_NOBODY;
}
static void gid_to_sid(UINT32 gid, PSID* sid) {
static void gid_to_sid(uint32_t gid, PSID* sid) {
sid_header* sh;
UCHAR els;
@ -346,7 +346,7 @@ static void gid_to_sid(UINT32 gid, PSID* sid) {
// fallback to S-1-22-2-X, Samba's SID scheme
els = 2;
sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header) + ((els - 1) * sizeof(UINT32)), ALLOC_TAG);
sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header) + ((els - 1) * sizeof(uint32_t)), ALLOC_TAG);
if (!sh) {
ERR("out of memory\n");
*sid = NULL;
@ -370,7 +370,7 @@ static void gid_to_sid(UINT32 gid, PSID* sid) {
}
static ACL* load_default_acl() {
UINT16 size, i;
uint16_t size, i;
ACL* acl;
ACCESS_ALLOWED_ACE* aaa;
@ -378,7 +378,7 @@ static ACL* load_default_acl() {
i = 0;
while (def_dacls[i].sid) {
size += sizeof(ACCESS_ALLOWED_ACE);
size += 8 + (def_dacls[i].sid->elements * sizeof(UINT32)) - sizeof(ULONG);
size += 8 + (def_dacls[i].sid->elements * sizeof(uint32_t)) - sizeof(ULONG);
i++;
}
@ -399,12 +399,12 @@ static ACL* load_default_acl() {
while (def_dacls[i].sid) {
aaa->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
aaa->Header.AceFlags = def_dacls[i].flags;
aaa->Header.AceSize = sizeof(ACCESS_ALLOWED_ACE) - sizeof(ULONG) + 8 + (def_dacls[i].sid->elements * sizeof(UINT32));
aaa->Header.AceSize = sizeof(ACCESS_ALLOWED_ACE) - sizeof(ULONG) + 8 + (def_dacls[i].sid->elements * sizeof(uint32_t));
aaa->Mask = def_dacls[i].mask;
RtlCopyMemory(&aaa->SidStart, def_dacls[i].sid, 8 + (def_dacls[i].sid->elements * sizeof(UINT32)));
RtlCopyMemory(&aaa->SidStart, def_dacls[i].sid, 8 + (def_dacls[i].sid->elements * sizeof(uint32_t)));
aaa = (ACCESS_ALLOWED_ACE*)((UINT8*)aaa + aaa->Header.AceSize);
aaa = (ACCESS_ALLOWED_ACE*)((uint8_t*)aaa + aaa->Header.AceSize);
i++;
}
@ -432,7 +432,7 @@ static void get_top_level_sd(fcb* fcb) {
goto end;
}
RtlSetOwnerSecurityDescriptor(&sd, usersid, FALSE);
RtlSetOwnerSecurityDescriptor(&sd, usersid, false);
if (!NT_SUCCESS(Status)) {
ERR("RtlSetOwnerSecurityDescriptor returned %08x\n", Status);
@ -446,7 +446,7 @@ static void get_top_level_sd(fcb* fcb) {
goto end;
}
RtlSetGroupSecurityDescriptor(&sd, groupsid, FALSE);
RtlSetGroupSecurityDescriptor(&sd, groupsid, false);
if (!NT_SUCCESS(Status)) {
ERR("RtlSetGroupSecurityDescriptor returned %08x\n", Status);
@ -460,7 +460,7 @@ static void get_top_level_sd(fcb* fcb) {
goto end;
}
Status = RtlSetDaclSecurityDescriptor(&sd, TRUE, acl, FALSE);
Status = RtlSetDaclSecurityDescriptor(&sd, true, acl, false);
if (!NT_SUCCESS(Status)) {
ERR("RtlSetDaclSecurityDescriptor returned %08x\n", Status);
@ -508,13 +508,13 @@ end:
ExFreePool(groupsid);
}
void fcb_get_sd(fcb* fcb, struct _fcb* parent, BOOL look_for_xattr, PIRP Irp) {
void fcb_get_sd(fcb* fcb, struct _fcb* parent, bool look_for_xattr, PIRP Irp) {
NTSTATUS Status;
PSID usersid = NULL, groupsid = NULL;
SECURITY_SUBJECT_CONTEXT subjcont;
ULONG buflen;
if (look_for_xattr && get_xattr(fcb->Vcb, fcb->subvol, fcb->inode, EA_NTACL, EA_NTACL_HASH, (UINT8**)&fcb->sd, (UINT16*)&buflen, Irp))
if (look_for_xattr && get_xattr(fcb->Vcb, fcb->subvol, fcb->inode, EA_NTACL, EA_NTACL_HASH, (uint8_t**)&fcb->sd, (uint16_t*)&buflen, Irp))
return;
if (!parent) {
@ -536,7 +536,7 @@ void fcb_get_sd(fcb* fcb, struct _fcb* parent, BOOL look_for_xattr, PIRP Irp) {
return;
}
RtlSetOwnerSecurityDescriptor(&fcb->sd, usersid, FALSE);
RtlSetOwnerSecurityDescriptor(&fcb->sd, usersid, false);
gid_to_sid(fcb->inode_item.st_gid, &groupsid);
if (!groupsid) {
@ -544,7 +544,7 @@ void fcb_get_sd(fcb* fcb, struct _fcb* parent, BOOL look_for_xattr, PIRP Irp) {
return;
}
RtlSetGroupSecurityDescriptor(&fcb->sd, groupsid, FALSE);
RtlSetGroupSecurityDescriptor(&fcb->sd, groupsid, false);
ExFreePool(usersid);
ExFreePool(groupsid);
@ -578,13 +578,13 @@ static NTSTATUS get_file_security(PFILE_OBJECT FileObject, SECURITY_DESCRIPTOR*
_Dispatch_type_(IRP_MJ_QUERY_SECURITY)
_Function_class_(DRIVER_DISPATCH)
NTSTATUS NTAPI drv_query_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
NTSTATUS __stdcall drv_query_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
NTSTATUS Status;
SECURITY_DESCRIPTOR* sd;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
device_extension* Vcb = DeviceObject->DeviceExtension;
ULONG buflen;
BOOL top_level;
bool top_level;
PFILE_OBJECT FileObject = IrpSp->FileObject;
ccb* ccb = FileObject ? FileObject->FsContext2 : NULL;
@ -696,7 +696,7 @@ static NTSTATUS set_file_security(device_extension* Vcb, PFILE_OBJECT FileObject
if (!fcb || !ccb)
return STATUS_INVALID_PARAMETER;
ExAcquireResourceExclusiveLite(fcb->Header.Resource, TRUE);
ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
if (is_subvol_readonly(fcb->subvol, Irp)) {
Status = STATUS_ACCESS_DENIED;
@ -724,9 +724,9 @@ static NTSTATUS set_file_security(device_extension* Vcb, PFILE_OBJECT FileObject
fcb->inode_item.sequence++;
fcb->sd_dirty = TRUE;
fcb->sd_deleted = FALSE;
fcb->inode_item_changed = TRUE;
fcb->sd_dirty = true;
fcb->sd_deleted = false;
fcb->inode_item_changed = true;
fcb->subvol->root_item.ctransid = Vcb->superblock.generation;
fcb->subvol->root_item.ctime = now;
@ -743,14 +743,14 @@ end:
_Dispatch_type_(IRP_MJ_SET_SECURITY)
_Function_class_(DRIVER_DISPATCH)
NTSTATUS NTAPI drv_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
NTSTATUS __stdcall drv_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = IrpSp->FileObject;
ccb* ccb = FileObject ? FileObject->FsContext2 : NULL;
device_extension* Vcb = DeviceObject->DeviceExtension;
ULONG access_req = 0;
BOOL top_level;
bool top_level;
FsRtlEnterFileSystem();
@ -820,7 +820,7 @@ end:
return Status;
}
static BOOL search_for_gid(fcb* fcb, PSID sid) {
static bool search_for_gid(fcb* fcb, PSID sid) {
LIST_ENTRY* le;
le = gid_map_list.Flink;
@ -829,13 +829,13 @@ static BOOL search_for_gid(fcb* fcb, PSID sid) {
if (RtlEqualSid(sid, gm->sid)) {
fcb->inode_item.st_gid = gm->gid;
return TRUE;
return true;
}
le = le->Flink;
}
return FALSE;
return false;
}
void find_gid(struct _fcb* fcb, struct _fcb* parfcb, PSECURITY_SUBJECT_CONTEXT subjcont) {
@ -849,7 +849,7 @@ void find_gid(struct _fcb* fcb, struct _fcb* parfcb, PSECURITY_SUBJECT_CONTEXT s
return;
}
ExAcquireResourceSharedLite(&mapping_lock, TRUE);
ExAcquireResourceSharedLite(&mapping_lock, true);
if (!subjcont || !subjcont->PrimaryToken || IsListEmpty(&gid_map_list)) {
ExReleaseResourceLite(&mapping_lock);

712
drivers/filesystems/btrfs/send.c
View file

File diff suppressed because it is too large Load diff

422
drivers/filesystems/btrfs/treefuncs.c
View file

File diff suppressed because it is too large Load diff

314
drivers/filesystems/btrfs/volume.c
View file

@ -27,6 +27,7 @@
extern PDRIVER_OBJECT drvobj;
extern PDEVICE_OBJECT master_devobj;
extern PDEVICE_OBJECT busobj;
extern ERESOURCE pdo_list_lock;
extern LIST_ENTRY pdo_list;
extern UNICODE_STRING registry_path;
@ -53,9 +54,9 @@ NTSTATUS vol_close(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
Irp->IoStatus.Information = 0;
ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE);
ExAcquireResourceExclusiveLite(&pdo_list_lock, true);
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
if (InterlockedDecrement(&vde->open_count) == 0 && vde->removing) {
NTSTATUS Status;
@ -108,17 +109,13 @@ typedef struct {
} vol_read_context;
_Function_class_(IO_COMPLETION_ROUTINE)
#ifdef __REACTOS__
static NTSTATUS NTAPI vol_read_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
#else
static NTSTATUS vol_read_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
#endif
static NTSTATUS __stdcall vol_read_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
vol_read_context* context = conptr;
UNUSED(DeviceObject);
context->iosb = Irp->IoStatus;
KeSetEvent(&context->Event, 0, FALSE);
KeSetEvent(&context->Event, 0, false);
return STATUS_MORE_PROCESSING_REQUIRED;
}
@ -134,7 +131,7 @@ NTSTATUS vol_read(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
TRACE("(%p, %p)\n", DeviceObject, Irp);
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
if (IsListEmpty(&pdode->children)) {
ExReleaseResourceLite(&pdode->child_lock);
@ -146,7 +143,7 @@ NTSTATUS vol_read(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
// We can't use IoSkipCurrentIrpStackLocation as the device isn't in our stack
Irp2 = IoAllocateIrp(vc->devobj->StackSize, FALSE);
Irp2 = IoAllocateIrp(vc->devobj->StackSize, false);
if (!Irp2) {
ERR("IoAllocateIrp failed\n");
@ -159,6 +156,7 @@ NTSTATUS vol_read(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
IrpSp2 = IoGetNextIrpStackLocation(Irp2);
IrpSp2->MajorFunction = IRP_MJ_READ;
IrpSp2->FileObject = vc->fileobj;
if (vc->devobj->Flags & DO_BUFFERED_IO) {
Irp2->AssociatedIrp.SystemBuffer = ExAllocatePoolWithTag(NonPagedPool, IrpSp->Parameters.Read.Length, ALLOC_TAG);
@ -180,15 +178,15 @@ NTSTATUS vol_read(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
IrpSp2->Parameters.Read.Length = IrpSp->Parameters.Read.Length;
IrpSp2->Parameters.Read.ByteOffset.QuadPart = IrpSp->Parameters.Read.ByteOffset.QuadPart;
KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
KeInitializeEvent(&context.Event, NotificationEvent, false);
Irp2->UserIosb = &context.iosb;
IoSetCompletionRoutine(Irp2, vol_read_completion, &context, TRUE, TRUE, TRUE);
IoSetCompletionRoutine(Irp2, vol_read_completion, &context, true, true, true);
Status = IoCallDriver(vc->devobj, Irp2);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
Status = context.iosb.Status;
}
@ -214,7 +212,7 @@ NTSTATUS vol_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
TRACE("(%p, %p)\n", DeviceObject, Irp);
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
if (IsListEmpty(&pdode->children)) {
ExReleaseResourceLite(&pdode->child_lock);
@ -232,7 +230,7 @@ NTSTATUS vol_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
// We can't use IoSkipCurrentIrpStackLocation as the device isn't in our stack
Irp2 = IoAllocateIrp(vc->devobj->StackSize, FALSE);
Irp2 = IoAllocateIrp(vc->devobj->StackSize, false);
if (!Irp2) {
ERR("IoAllocateIrp failed\n");
@ -245,6 +243,7 @@ NTSTATUS vol_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
IrpSp2 = IoGetNextIrpStackLocation(Irp2);
IrpSp2->MajorFunction = IRP_MJ_WRITE;
IrpSp2->FileObject = vc->fileobj;
if (vc->devobj->Flags & DO_BUFFERED_IO) {
Irp2->AssociatedIrp.SystemBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
@ -260,15 +259,15 @@ NTSTATUS vol_write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
IrpSp2->Parameters.Write.Length = IrpSp->Parameters.Write.Length;
IrpSp2->Parameters.Write.ByteOffset.QuadPart = IrpSp->Parameters.Write.ByteOffset.QuadPart;
KeInitializeEvent(&context.Event, NotificationEvent, FALSE);
KeInitializeEvent(&context.Event, NotificationEvent, false);
Irp2->UserIosb = &context.iosb;
IoSetCompletionRoutine(Irp2, vol_read_completion, &context, TRUE, TRUE, TRUE);
IoSetCompletionRoutine(Irp2, vol_read_completion, &context, true, true, true);
Status = IoCallDriver(vc->devobj, Irp2);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject(&context.Event, Executive, KernelMode, FALSE, NULL);
KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
Status = context.iosb.Status;
}
@ -310,7 +309,7 @@ NTSTATUS vol_set_ea(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
NTSTATUS vol_flush_buffers(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
TRACE("(%p, %p)\n", DeviceObject, Irp);
return STATUS_INVALID_DEVICE_REQUEST;
return STATUS_SUCCESS;
}
NTSTATUS vol_query_volume_information(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
@ -407,12 +406,12 @@ static NTSTATUS vol_query_unique_id(volume_device_extension* vde, PIRP Irp) {
static NTSTATUS vol_is_dynamic(PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
UINT8* buf;
uint8_t* buf;
if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength == 0 || !Irp->AssociatedIrp.SystemBuffer)
return STATUS_INVALID_PARAMETER;
buf = (UINT8*)Irp->AssociatedIrp.SystemBuffer;
buf = (uint8_t*)Irp->AssociatedIrp.SystemBuffer;
*buf = 1;
@ -426,13 +425,13 @@ static NTSTATUS vol_check_verify(volume_device_extension* vde) {
NTSTATUS Status;
LIST_ENTRY* le;
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
le = pdode->children.Flink;
while (le != &pdode->children) {
volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
Status = dev_ioctl(vc->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, NULL, 0, FALSE, NULL);
Status = dev_ioctl(vc->devobj, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, NULL, 0, false, NULL);
if (!NT_SUCCESS(Status))
goto end;
@ -458,14 +457,14 @@ static NTSTATUS vol_get_disk_extents(volume_device_extension* vde, PIRP Irp) {
if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(VOLUME_DISK_EXTENTS))
return STATUS_BUFFER_TOO_SMALL;
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
le = pdode->children.Flink;
while (le != &pdode->children) {
volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
VOLUME_DISK_EXTENTS ext2;
Status = dev_ioctl(vc->devobj, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, &ext2, sizeof(VOLUME_DISK_EXTENTS), FALSE, NULL);
Status = dev_ioctl(vc->devobj, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, &ext2, sizeof(VOLUME_DISK_EXTENTS), false, NULL);
if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW) {
ERR("IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS returned %08x\n", Status);
goto end;
@ -503,7 +502,7 @@ static NTSTATUS vol_get_disk_extents(volume_device_extension* vde, PIRP Irp) {
volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
Status = dev_ioctl(vc->devobj, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, ext3,
(ULONG)offsetof(VOLUME_DISK_EXTENTS, Extents[0]) + (max_extents * sizeof(DISK_EXTENT)), FALSE, NULL);
(ULONG)offsetof(VOLUME_DISK_EXTENTS, Extents[0]) + (max_extents * sizeof(DISK_EXTENT)), false, NULL);
if (!NT_SUCCESS(Status)) {
ERR("IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS returned %08x\n", Status);
ExFreePool(ext3);
@ -541,18 +540,18 @@ static NTSTATUS vol_is_writable(volume_device_extension* vde) {
pdo_device_extension* pdode = vde->pdode;
NTSTATUS Status;
LIST_ENTRY* le;
BOOL writable = FALSE;
bool writable = false;
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
le = pdode->children.Flink;
while (le != &pdode->children) {
volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
Status = dev_ioctl(vc->devobj, IOCTL_DISK_IS_WRITABLE, NULL, 0, NULL, 0, TRUE, NULL);
Status = dev_ioctl(vc->devobj, IOCTL_DISK_IS_WRITABLE, NULL, 0, NULL, 0, true, NULL);
if (NT_SUCCESS(Status)) {
writable = TRUE;
writable = true;
break;
} else if (Status != STATUS_MEDIA_WRITE_PROTECTED)
goto end;
@ -581,7 +580,7 @@ static NTSTATUS vol_get_length(volume_device_extension* vde, PIRP Irp) {
gli->Length.QuadPart = 0;
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
le = pdode->children.Flink;
while (le != &pdode->children) {
@ -604,7 +603,7 @@ static NTSTATUS vol_get_drive_geometry(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
pdo_device_extension* pdode = vde->pdode;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
DISK_GEOMETRY* geom;
UINT64 length;
uint64_t length;
LIST_ENTRY* le;
if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DISK_GEOMETRY))
@ -612,7 +611,7 @@ static NTSTATUS vol_get_drive_geometry(PDEVICE_OBJECT DeviceObject, PIRP Irp) {
length = 0;
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
le = pdode->children.Flink;
while (le != &pdode->children) {
@ -664,7 +663,7 @@ static NTSTATUS vol_get_device_number(volume_device_extension* vde, PIRP Irp) {
if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_DEVICE_NUMBER))
return STATUS_BUFFER_TOO_SMALL;
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
if (IsListEmpty(&pdode->children) || pdode->num_children > 1) {
ExReleaseResourceLite(&pdode->child_lock);
@ -692,17 +691,13 @@ static NTSTATUS vol_get_device_number(volume_device_extension* vde, PIRP Irp) {
}
_Function_class_(IO_COMPLETION_ROUTINE)
#ifdef __REACTOS__
static NTSTATUS NTAPI vol_ioctl_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
#else
static NTSTATUS vol_ioctl_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
#endif
static NTSTATUS __stdcall vol_ioctl_completion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID conptr) {
KEVENT* event = conptr;
UNUSED(DeviceObject);
UNUSED(Irp);
KeSetEvent(event, 0, FALSE);
KeSetEvent(event, 0, false);
return STATUS_MORE_PROCESSING_REQUIRED;
}
@ -717,7 +712,7 @@ static NTSTATUS vol_ioctl_passthrough(volume_device_extension* vde, PIRP Irp) {
TRACE("(%p, %p)\n", vde, Irp);
ExAcquireResourceSharedLite(&pdode->child_lock, TRUE);
ExAcquireResourceSharedLite(&pdode->child_lock, true);
if (IsListEmpty(&pdode->children)) {
ExReleaseResourceLite(&pdode->child_lock);
@ -731,7 +726,7 @@ static NTSTATUS vol_ioctl_passthrough(volume_device_extension* vde, PIRP Irp) {
return STATUS_INVALID_DEVICE_REQUEST;
}
Irp2 = IoAllocateIrp(vc->devobj->StackSize, FALSE);
Irp2 = IoAllocateIrp(vc->devobj->StackSize, false);
if (!Irp2) {
ERR("IoAllocateIrp failed\n");
@ -744,6 +739,7 @@ static NTSTATUS vol_ioctl_passthrough(volume_device_extension* vde, PIRP Irp) {
IrpSp2->MajorFunction = IrpSp->MajorFunction;
IrpSp2->MinorFunction = IrpSp->MinorFunction;
IrpSp2->FileObject = vc->fileobj;
IrpSp2->Parameters.DeviceIoControl.OutputBufferLength = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
IrpSp2->Parameters.DeviceIoControl.InputBufferLength = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
@ -755,14 +751,14 @@ static NTSTATUS vol_ioctl_passthrough(volume_device_extension* vde, PIRP Irp) {
Irp2->UserBuffer = Irp->UserBuffer;
Irp2->Flags = Irp->Flags;
KeInitializeEvent(&Event, NotificationEvent, FALSE);
KeInitializeEvent(&Event, NotificationEvent, false);
IoSetCompletionRoutine(Irp2, vol_ioctl_completion, &Event, TRUE, TRUE, TRUE);
IoSetCompletionRoutine(Irp2, vol_ioctl_completion, &Event, true, true, true);
Status = IoCallDriver(vc->devobj, Irp2);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
KeWaitForSingleObject(&Event, Executive, KernelMode, false, NULL);
Status = Irp2->IoStatus.Status;
}
@ -882,21 +878,6 @@ NTSTATUS vol_set_security(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
return STATUS_INVALID_DEVICE_REQUEST;
}
NTSTATUS vol_power(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS Status;
TRACE("(%p, %p)\n", DeviceObject, Irp);
if (IrpSp->MinorFunction == IRP_MN_SET_POWER || IrpSp->MinorFunction == IRP_MN_QUERY_POWER)
Irp->IoStatus.Status = STATUS_SUCCESS;
Status = Irp->IoStatus.Status;
PoStartNextPowerIrp(Irp);
return Status;
}
NTSTATUS mountmgr_add_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath) {
NTSTATUS Status;
ULONG mmdltsize;
@ -915,7 +896,7 @@ NTSTATUS mountmgr_add_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devp
RtlCopyMemory(&mmdlt->DeviceName, devpath->Buffer, devpath->Length);
TRACE("mmdlt = %.*S\n", mmdlt->DeviceNameLength / sizeof(WCHAR), mmdlt->DeviceName);
Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER, mmdlt, mmdltsize, &mmdli, sizeof(MOUNTMGR_DRIVE_LETTER_INFORMATION), FALSE, NULL);
Status = dev_ioctl(mountmgr, IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER, mmdlt, mmdltsize, &mmdli, sizeof(MOUNTMGR_DRIVE_LETTER_INFORMATION), false, NULL);
if (!NT_SUCCESS(Status))
ERR("IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER returned %08x\n", Status);
@ -928,11 +909,7 @@ NTSTATUS mountmgr_add_drive_letter(PDEVICE_OBJECT mountmgr, PUNICODE_STRING devp
}
_Function_class_(DRIVER_NOTIFICATION_CALLBACK_ROUTINE)
#ifdef __REACTOS__
NTSTATUS NTAPI pnp_removal(PVOID NotificationStructure, PVOID Context) {
#else
NTSTATUS pnp_removal(PVOID NotificationStructure, PVOID Context) {
#endif
NTSTATUS __stdcall pnp_removal(PVOID NotificationStructure, PVOID Context) {
TARGET_DEVICE_REMOVAL_NOTIFICATION* tdrn = (TARGET_DEVICE_REMOVAL_NOTIFICATION*)NotificationStructure;
pdo_device_extension* pdode = (pdo_device_extension*)Context;
@ -946,12 +923,12 @@ NTSTATUS pnp_removal(PVOID NotificationStructure, PVOID Context) {
return STATUS_SUCCESS;
}
static BOOL allow_degraded_mount(BTRFS_UUID* uuid) {
static bool allow_degraded_mount(BTRFS_UUID* uuid) {
HANDLE h;
NTSTATUS Status;
OBJECT_ATTRIBUTES oa;
UNICODE_STRING path, adus;
UINT32 degraded = mount_allow_degraded;
uint32_t degraded = mount_allow_degraded;
ULONG i, j, kvfilen, retlen;
KEY_VALUE_FULL_INFORMATION* kvfi;
@ -960,7 +937,7 @@ static BOOL allow_degraded_mount(BTRFS_UUID* uuid) {
if (!path.Buffer) {
ERR("out of memory\n");
return FALSE;
return false;
}
RtlCopyMemory(path.Buffer, registry_path.Buffer, registry_path.Length);
@ -988,7 +965,7 @@ static BOOL allow_degraded_mount(BTRFS_UUID* uuid) {
if (!kvfi) {
ERR("out of memory\n");
ExFreePool(path.Buffer);
return FALSE;
return false;
}
Status = ZwOpenKey(&h, KEY_QUERY_VALUE, &oa);
@ -1003,8 +980,8 @@ static BOOL allow_degraded_mount(BTRFS_UUID* uuid) {
adus.Length = adus.MaximumLength = sizeof(adus.Buffer) - sizeof(WCHAR);
if (NT_SUCCESS(ZwQueryValueKey(h, &adus, KeyValueFullInformation, kvfi, kvfilen, &retlen))) {
if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(UINT32)) {
UINT32* val = (UINT32*)((UINT8*)kvfi + kvfi->DataOffset);
if (kvfi->Type == REG_DWORD && kvfi->DataLength >= sizeof(uint32_t)) {
uint32_t* val = (uint32_t*)((uint8_t*)kvfi + kvfi->DataOffset);
degraded = *val;
}
@ -1020,21 +997,126 @@ end:
return degraded;
}
void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath, UINT64 length, ULONG disk_num, ULONG part_num) {
typedef struct {
PIO_WORKITEM work_item;
pdo_device_extension* pdode;
} drive_letter_callback_context;
_Function_class_(IO_WORKITEM_ROUTINE)
static void __stdcall drive_letter_callback(PDEVICE_OBJECT DeviceObject, PVOID con) {
drive_letter_callback_context* context = con;
NTSTATUS Status;
UNICODE_STRING mmdevpath;
PDEVICE_OBJECT mountmgr;
PFILE_OBJECT mountmgrfo;
LIST_ENTRY* le;
UNUSED(DeviceObject);
RtlInitUnicodeString(&mmdevpath, MOUNTMGR_DEVICE_NAME);
Status = IoGetDeviceObjectPointer(&mmdevpath, FILE_READ_ATTRIBUTES, &mountmgrfo, &mountmgr);
if (!NT_SUCCESS(Status)) {
ERR("IoGetDeviceObjectPointer returned %08x\n", Status);
return;
}
ExAcquireResourceSharedLite(&pdo_list_lock, true);
le = pdo_list.Flink;
while (le != &pdo_list) {
pdo_device_extension* pdode = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
if (pdode == context->pdode) {
LIST_ENTRY* le2;
ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
le2 = pdode->children.Flink;
while (le2 != &pdode->children) {
UNICODE_STRING name;
volume_child* vc = CONTAINING_RECORD(le2, volume_child, list_entry);
name.Length = name.MaximumLength = vc->pnp_name.Length + (3 * sizeof(WCHAR));
name.Buffer = ExAllocatePoolWithTag(PagedPool, name.Length, ALLOC_TAG);
if (!name.Buffer) {
ERR("out of memory\n");
ExReleaseResourceLite(&pdode->child_lock);
ExReleaseResourceLite(&pdo_list_lock);
ObDereferenceObject(mountmgrfo);
IoFreeWorkItem(context->work_item);
return;
}
RtlCopyMemory(name.Buffer, L"\\??", 3 * sizeof(WCHAR));
RtlCopyMemory(&name.Buffer[3], vc->pnp_name.Buffer, vc->pnp_name.Length);
Status = remove_drive_letter(mountmgr, &name);
if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND)
WARN("remove_drive_letter returned %08x\n", Status);
ExFreePool(name.Buffer);
vc->had_drive_letter = NT_SUCCESS(Status);
le2 = le2->Flink;
}
ExReleaseResourceLite(&pdode->child_lock);
ExReleaseResourceLite(&pdo_list_lock);
ObDereferenceObject(mountmgrfo);
IoFreeWorkItem(context->work_item);
return;
}
le = le->Flink;
}
ExReleaseResourceLite(&pdo_list_lock);
ObDereferenceObject(mountmgrfo);
IoFreeWorkItem(context->work_item);
}
static void add_drive_letter_work_item(pdo_device_extension* pdode) {
PIO_WORKITEM work_item;
drive_letter_callback_context* context;
work_item = IoAllocateWorkItem(master_devobj);
context = ExAllocatePoolWithTag(PagedPool, sizeof(drive_letter_callback_context), ALLOC_TAG);
if (!context) {
ERR("out of memory\n");
IoFreeWorkItem(work_item);
return;
}
context->work_item = work_item;
context->pdode = pdode;
IoQueueWorkItem(work_item, drive_letter_callback, DelayedWorkQueue, context);
}
void add_volume_device(superblock* sb, PUNICODE_STRING devpath, uint64_t length, ULONG disk_num, ULONG part_num) {
NTSTATUS Status;
LIST_ENTRY* le;
PDEVICE_OBJECT DeviceObject;
volume_child* vc;
PFILE_OBJECT FileObject;
UNICODE_STRING devpath2;
BOOL inserted = FALSE, new_pdo = FALSE;
bool inserted = false, new_pdo = false;
pdo_device_extension* pdode = NULL;
PDEVICE_OBJECT pdo = NULL;
if (devpath->Length == 0)
return;
ExAcquireResourceExclusiveLite(&pdo_list_lock, TRUE);
ExAcquireResourceExclusiveLite(&pdo_list_lock, true);
le = pdo_list.Flink;
while (le != &pdo_list) {
@ -1074,7 +1156,7 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
}
} else {
Status = IoCreateDevice(drvobj, sizeof(pdo_device_extension), NULL, FILE_DEVICE_DISK,
FILE_AUTOGENERATED_DEVICE_NAME | FILE_DEVICE_SECURE_OPEN, FALSE, &pdo);
FILE_AUTOGENERATED_DEVICE_NAME | FILE_DEVICE_SECURE_OPEN, false, &pdo);
if (!NT_SUCCESS(Status)) {
ERR("IoCreateDevice returned %08x\n", Status);
ExReleaseResourceLite(&pdo_list_lock);
@ -1100,11 +1182,11 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
pdo->Flags &= ~DO_DEVICE_INITIALIZING;
pdo->SectorSize = (USHORT)sb->sector_size;
ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
new_pdo = TRUE;
new_pdo = true;
} else {
ExAcquireResourceExclusiveLite(&pdode->child_lock, TRUE);
ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
ExConvertExclusiveToSharedLite(&pdo_list_lock);
le = pdode->children.Flink;
@ -1167,10 +1249,10 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
}
vc->size = length;
vc->seeding = sb->flags & BTRFS_SUPERBLOCK_FLAGS_SEEDING ? TRUE : FALSE;
vc->seeding = sb->flags & BTRFS_SUPERBLOCK_FLAGS_SEEDING ? true : false;
vc->disk_num = disk_num;
vc->part_num = part_num;
vc->had_drive_letter = FALSE;
vc->had_drive_letter = false;
le = pdode->children.Flink;
while (le != &pdode->children) {
@ -1181,7 +1263,7 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
pdode->num_children = sb->num_devices;
InsertHeadList(vc2->list_entry.Blink, &vc->list_entry);
inserted = TRUE;
inserted = true;
break;
}
@ -1196,7 +1278,7 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
if (pdode->vde && pdode->vde->mounted_device) {
device_extension* Vcb = pdode->vde->mounted_device->DeviceExtension;
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, TRUE);
ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
le = Vcb->devices.Flink;
while (le != &Vcb->devices) {
@ -1206,7 +1288,7 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
dev->devobj = DeviceObject;
dev->disk_num = disk_num;
dev->part_num = part_num;
init_device(Vcb, dev, FALSE);
init_device(Vcb, dev, false);
break;
}
@ -1217,77 +1299,37 @@ void add_volume_device(superblock* sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING
}
if (DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) {
pdode->removable = TRUE;
pdode->removable = true;
if (pdode->vde && pdode->vde->device)
pdode->vde->device->Characteristics |= FILE_REMOVABLE_MEDIA;
}
if (pdode->num_children == pdode->children_loaded || (pdode->children_loaded == 1 && allow_degraded_mount(&sb->uuid))) {
if (pdode->num_children == 1) {
Status = remove_drive_letter(mountmgr, devpath);
if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND)
WARN("remove_drive_letter returned %08x\n", Status);
vc->had_drive_letter = NT_SUCCESS(Status);
} else {
le = pdode->children.Flink;
while (le != &pdode->children) {
UNICODE_STRING name;
vc = CONTAINING_RECORD(le, volume_child, list_entry);
name.Length = name.MaximumLength = vc->pnp_name.Length + (3 * sizeof(WCHAR));
name.Buffer = ExAllocatePoolWithTag(PagedPool, name.Length, ALLOC_TAG);
if (!name.Buffer) {
ERR("out of memory\n");
ExReleaseResourceLite(&pdode->child_lock);
ExReleaseResourceLite(&pdo_list_lock);
goto fail;
}
RtlCopyMemory(name.Buffer, L"\\??", 3 * sizeof(WCHAR));
RtlCopyMemory(&name.Buffer[3], vc->pnp_name.Buffer, vc->pnp_name.Length);
Status = remove_drive_letter(mountmgr, &name);
if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND)
WARN("remove_drive_letter returned %08x\n", Status);
ExFreePool(name.Buffer);
vc->had_drive_letter = NT_SUCCESS(Status);
le = le->Flink;
}
}
if ((!new_pdo || !no_pnp) && pdode->vde) {
Status = IoSetDeviceInterfaceState(&pdode->vde->bus_name, TRUE);
Status = IoSetDeviceInterfaceState(&pdode->vde->bus_name, true);
if (!NT_SUCCESS(Status))
WARN("IoSetDeviceInterfaceState returned %08x\n", Status);
}
add_drive_letter_work_item(pdode);
}
ExReleaseResourceLite(&pdode->child_lock);
if (new_pdo) {
control_device_extension* cde = master_devobj->DeviceExtension;
if (new_pdo)
InsertTailList(&pdo_list, &pdode->list_entry);
if (!no_pnp)
IoInvalidateDeviceRelations(cde->buspdo, BusRelations);
}
ExReleaseResourceLite(&pdo_list_lock);
if (new_pdo && no_pnp)
if (new_pdo) {
if (no_pnp)
AddDevice(drvobj, pdo);
else {
bus_device_extension* bde = busobj->DeviceExtension;
IoInvalidateDeviceRelations(bde->buspdo, BusRelations);
}
}
return;

42
drivers/filesystems/btrfs/worker-thread.c
View file

@ -23,29 +23,29 @@ typedef struct {
WORK_QUEUE_ITEM item;
} job_info;
void do_read_job(PIRP Irp) {
NTSTATUS do_read_job(PIRP Irp) {
NTSTATUS Status;
ULONG bytes_read;
BOOL top_level = is_top_level(Irp);
bool top_level = is_top_level(Irp);
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = IrpSp->FileObject;
fcb* fcb = FileObject->FsContext;
BOOL fcb_lock = FALSE;
bool acquired_fcb_lock = false;
Irp->IoStatus.Information = 0;
if (!ExIsResourceAcquiredSharedLite(fcb->Header.Resource)) {
ExAcquireResourceSharedLite(fcb->Header.Resource, TRUE);
fcb_lock = TRUE;
ExAcquireResourceSharedLite(fcb->Header.Resource, true);
acquired_fcb_lock = true;
}
_SEH2_TRY {
Status = do_read(Irp, TRUE, &bytes_read);
Status = do_read(Irp, true, &bytes_read);
} _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
Status = _SEH2_GetExceptionCode();
} _SEH2_END;
if (fcb_lock)
if (acquired_fcb_lock)
ExReleaseResourceLite(fcb->Header.Resource);
if (!NT_SUCCESS(Status))
@ -61,14 +61,16 @@ void do_read_job(PIRP Irp) {
IoSetTopLevelIrp(NULL);
TRACE("returning %08x\n", Status);
return Status;
}
void do_write_job(device_extension* Vcb, PIRP Irp) {
BOOL top_level = is_top_level(Irp);
NTSTATUS do_write_job(device_extension* Vcb, PIRP Irp) {
bool top_level = is_top_level(Irp);
NTSTATUS Status;
_SEH2_TRY {
Status = write_file(Vcb, Irp, TRUE, TRUE);
Status = write_file(Vcb, Irp, true, true);
} _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
Status = _SEH2_GetExceptionCode();
} _SEH2_END;
@ -86,14 +88,12 @@ void do_write_job(device_extension* Vcb, PIRP Irp) {
IoSetTopLevelIrp(NULL);
TRACE("returning %08x\n", Status);
return Status;
}
_Function_class_(WORKER_THREAD_ROUTINE)
#ifdef __REACTOS__
static void NTAPI do_job(void* context) {
#else
static void do_job(void* context) {
#endif
static void __stdcall do_job(void* context) {
job_info* ji = context;
PIO_STACK_LOCATION IrpSp = ji->Irp ? IoGetCurrentIrpStackLocation(ji->Irp) : NULL;
@ -106,13 +106,13 @@ static void do_job(void* context) {
ExFreePool(ji);
}
BOOL add_thread_job(device_extension* Vcb, PIRP Irp) {
bool add_thread_job(device_extension* Vcb, PIRP Irp) {
job_info* ji;
ji = ExAllocatePoolWithTag(NonPagedPool, sizeof(job_info), ALLOC_TAG);
if (!ji) {
ERR("out of memory\n");
return FALSE;
return false;
}
ji->Vcb = Vcb;
@ -133,15 +133,15 @@ BOOL add_thread_job(device_extension* Vcb, PIRP Irp) {
} else {
ERR("unexpected major function %u\n", IrpSp->MajorFunction);
ExFreePool(ji);
return FALSE;
return false;
}
Mdl = IoAllocateMdl(Irp->UserBuffer, len, FALSE, FALSE, Irp);
Mdl = IoAllocateMdl(Irp->UserBuffer, len, false, false, Irp);
if (!Mdl) {
ERR("out of memory\n");
ExFreePool(ji);
return FALSE;
return false;
}
_SEH2_TRY {
@ -160,5 +160,5 @@ BOOL add_thread_job(device_extension* Vcb, PIRP Irp) {
ExInitializeWorkItem(&ji->item, do_job, ji);
ExQueueWorkItem(&ji->item, DelayedWorkQueue);
return TRUE;
return true;
}

952
drivers/filesystems/btrfs/write.c
View file

File diff suppressed because it is too large Load diff

35
drivers/filesystems/btrfs/zstd/fse_compress.c
View file

@ -194,8 +194,17 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
{
FSE_FUNCTION_TYPE tableSymbol[FSE_MAX_TABLESIZE]; /* memset() is not necessary, even if static analyzer complain about it */
return FSE_buildCTable_wksp(ct, normalizedCounter, maxSymbolValue, tableLog, tableSymbol, sizeof(tableSymbol));
FSE_FUNCTION_TYPE* tableSymbol = ExAllocatePoolWithTag(NonPagedPool, sizeof(FSE_FUNCTION_TYPE) * FSE_MAX_TABLESIZE, FSEC_ALLOC_TAG);
size_t ret;
if (!tableSymbol)
return 0;
ret = FSE_buildCTable_wksp(ct, normalizedCounter, maxSymbolValue, tableLog, tableSymbol, sizeof(FSE_FUNCTION_TYPE) * FSE_MAX_TABLESIZE);
ExFreePool(tableSymbol);
return ret;
}
@ -709,10 +718,24 @@ typedef struct {
size_t FSE_compress2 (void* dst, size_t dstCapacity, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog)
{
fseWkspMax_t scratchBuffer;
DEBUG_STATIC_ASSERT(sizeof(scratchBuffer) >= FSE_WKSP_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)); /* compilation failures here means scratchBuffer is not large enough */
if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
return FSE_compress_wksp(dst, dstCapacity, src, srcSize, maxSymbolValue, tableLog, &scratchBuffer, sizeof(scratchBuffer));
fseWkspMax_t* scratchBuffer;
size_t ret;
DEBUG_STATIC_ASSERT(sizeof(fseWkspMax_t) >= FSE_WKSP_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)); /* compilation failures here means scratchBuffer is not large enough */
if (tableLog > FSE_MAX_TABLELOG)
return ERROR(tableLog_tooLarge);
scratchBuffer = ExAllocatePoolWithTag(NonPagedPool, sizeof(fseWkspMax_t), FSEC_ALLOC_TAG);
if (!scratchBuffer)
return 0;
ret = FSE_compress_wksp(dst, dstCapacity, src, srcSize, maxSymbolValue, tableLog, scratchBuffer, sizeof(fseWkspMax_t));
ExFreePool(scratchBuffer);
return ret;
}
size_t FSE_compress (void* dst, size_t dstCapacity, const void* src, size_t srcSize)

16
drivers/filesystems/btrfs/zstd/hist.c
View file

@ -38,7 +38,10 @@
#include "debug.h" /* assert, DEBUGLOG */
#include "error_private.h" /* ERROR */
#include "hist.h"
#include <ntifs.h>
#include <ntddk.h>
#define HIST_ALLOC_TAG 0x54534948 // "HIST"
/* --- Error management --- */
unsigned HIST_isError(size_t code) { return ERR_isError(code); }
@ -171,8 +174,17 @@ size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
const void* source, size_t sourceSize)
{
unsigned tmpCounters[HIST_WKSP_SIZE_U32];
return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters);
unsigned* tmpCounters = ExAllocatePoolWithTag(NonPagedPool, sizeof(unsigned) * HIST_WKSP_SIZE_U32, HIST_ALLOC_TAG);
size_t ret;
if (!tmpCounters)
return 0;
ret = HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters);
ExFreePool(tmpCounters);
return ret;
}
/* HIST_count_wksp() :

4
drivers/filesystems/btrfs/zstd/huf.h
View file

@ -163,10 +163,6 @@ HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity,
/* static allocation of HUF's DTable */
typedef U32 HUF_DTable;
#define HUF_DTABLE_SIZE(maxTableLog) (1 + (1<<(maxTableLog)))
#define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \
HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) }
#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }
/* ****************************************

43
drivers/filesystems/btrfs/zstd/huf_compress.c
View file

@ -53,6 +53,10 @@
#define HUF_STATIC_LINKING_ONLY
#include "huf.h"
#include "error_private.h"
#include <ntifs.h>
#include <ntddk.h>
#define HUFC_ALLOC_TAG 0x63465548 // "HUFc"
/* **************************************************************
@ -423,8 +427,17 @@ size_t HUF_buildCTable_wksp (HUF_CElt* tree, const U32* count, U32 maxSymbolValu
*/
size_t HUF_buildCTable (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits)
{
huffNodeTable nodeTable;
return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(nodeTable));
huffNodeTable* nodeTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(huffNodeTable), HUFC_ALLOC_TAG);
size_t ret;
if (!nodeTable)
return 0;
ret = HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(huffNodeTable));
ExFreePool(nodeTable);
return ret;
}
static size_t HUF_estimateCompressedSize(HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
@ -749,8 +762,17 @@ size_t HUF_compress1X (void* dst, size_t dstSize,
const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog)
{
unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
return HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
unsigned* workSpace = ExAllocatePoolWithTag(NonPagedPool, sizeof(unsigned) * HUF_WORKSPACE_SIZE_U32, HUFC_ALLOC_TAG);
size_t ret;
if (!workSpace)
return 0;
ret = HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(unsigned) * HUF_WORKSPACE_SIZE_U32);
ExFreePool(workSpace);
return ret;
}
/* HUF_compress4X_repeat():
@ -786,8 +808,17 @@ size_t HUF_compress2 (void* dst, size_t dstSize,
const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog)
{
unsigned workSpace[HUF_WORKSPACE_SIZE_U32];
return HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
unsigned* workSpace = ExAllocatePoolWithTag(NonPagedPool, sizeof(unsigned) * HUF_WORKSPACE_SIZE_U32, HUFC_ALLOC_TAG);
size_t ret;
if (!workSpace)
return 0;
ret = HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(unsigned) * HUF_WORKSPACE_SIZE_U32);
ExFreePool(workSpace);
return ret;
}
size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize)

72
drivers/filesystems/btrfs/zstd/huf_decompress.c
View file

@ -42,6 +42,10 @@
#define HUF_STATIC_LINKING_ONLY
#include "huf.h"
#include "error_private.h"
#include <ntifs.h>
#include <ntddk.h>
#define HUFD_ALLOC_TAG 0x64465548 // "HUFd"
/* **************************************************************
@ -388,8 +392,21 @@ size_t HUF_decompress1X1_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize,
size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{
HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
return HUF_decompress1X1_DCtx (DTable, dst, dstSize, cSrc, cSrcSize);
HUF_DTable* DTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX-1), HUFD_ALLOC_TAG);
size_t ret;
if (!DTable)
return 0;
RtlZeroMemory(DTable, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX-1));
DTable[0] = (U32)(HUF_TABLELOG_MAX-1) * 0x01000001;
ret = HUF_decompress1X1_DCtx (DTable, dst, dstSize, cSrc, cSrcSize);
ExFreePool(DTable);
return ret;
}
size_t HUF_decompress4X1_usingDTable(
@ -433,8 +450,21 @@ size_t HUF_decompress4X1_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, cons
}
size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{
HUF_CREATE_STATIC_DTABLEX1(DTable, HUF_TABLELOG_MAX);
return HUF_decompress4X1_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
HUF_DTable* DTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX-1), HUFD_ALLOC_TAG);
size_t ret;
if (!DTable)
return 0;
RtlZeroMemory(DTable, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX-1));
DTable[0] = (U32)(HUF_TABLELOG_MAX-1) * 0x01000001;
ret = HUF_decompress4X1_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
ExFreePool(DTable);
return ret;
}
@ -860,8 +890,21 @@ size_t HUF_decompress1X2_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize,
size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{
HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
return HUF_decompress1X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
HUF_DTable* DTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX), HUFD_ALLOC_TAG);
size_t ret;
if (!DTable)
return 0;
RtlZeroMemory(DTable, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX));
DTable[0] = (U32)(HUF_TABLELOG_MAX) * 0x01000001;
ret = HUF_decompress1X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
ExFreePool(DTable);
return ret;
}
size_t HUF_decompress4X2_usingDTable(
@ -907,8 +950,21 @@ size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize,
size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{
HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX);
return HUF_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
HUF_DTable* DTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX), HUFD_ALLOC_TAG);
size_t ret;
if (!DTable)
return 0;
RtlZeroMemory(DTable, sizeof(HUF_DTable) * HUF_DTABLE_SIZE(HUF_TABLELOG_MAX));
DTable[0] = (U32)(HUF_TABLELOG_MAX) * 0x01000001;
ret = HUF_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
ExFreePool(DTable);
return ret;
}

2
media/doc/README.FSD
View file

@ -3,7 +3,7 @@
The following FSD are shared with: https://github.com/maharmstone/btrfs.
reactos/drivers/filesystems/btrfs # Synced to 1.3
reactos/drivers/filesystems/btrfs # Synced to 1.4
reactos/dll/shellext/shellbtrfs # Synced to 1.1
reactos/sdk/lib/fslib/btrfslib # Synced to 1.3