#include <ntifs.h>
#include <ntddk.h>
#include <mountmgr.h>
#include <windef.h>
#include <wdm.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "btrfs.h"
#include "btrfsioctl.h"

Include dependency graph for btrfs_drv.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_FILE_ID_128

struct	_DUPLICATE_EXTENTS_DATA

struct	_FSCTL_GET_INTEGRITY_INFORMATION_BUFFER

struct	_FSCTL_SET_INTEGRITY_INFORMATION_BUFFER

struct	_fcb_nonpaged

struct	extent

struct	hardlink

struct	dir_child

struct	xattr

struct	_fcb

struct	_file_ref

struct	send_info

struct	_ccb

struct	tree_holder

struct	_tree_data

struct	tree_nonpaged

struct	_tree

struct	root_nonpaged

struct	_root

struct	batch_item

struct	batch_item_ind

struct	batch_root

struct	traverse_ptr

struct	_root_cache

struct	space

struct	device

struct	range_lock

struct	partial_stripe

struct	chunk

struct	changed_extent

struct	changed_extent_ref

struct	sys_chunk

struct	calc_job

struct	drv_calc_thread

struct	drv_calc_threads

struct	mount_options

struct	balance_info

struct	scrub_error

struct	scrub_info

struct	_device_extension

struct	control_device_extension

struct	bus_device_extension

struct	volume_child

struct	_volume_device_extension

struct	pdo_device_extension

struct	uid_map

struct	gid_map

struct	write_data_stripe

struct	_write_data_context

struct	tree_write

struct	name_bit

struct	rollback_space

struct	rollback_extent

struct	rollback_item

struct	ea_item

struct	FSRTL_ADVANCED_FCB_HEADER_NEW

struct	_LDR_DATA_TABLE_ENTRY

struct	_PEB_LDR_DATA

struct	_RTL_USER_PROCESS_PARAMETERS

struct	_PEB

Macros
#define	_WIN32_WINNT 0x0601

#define	NTDDI_VERSION 0x06020000

#define	_CRT_SECURE_NO_WARNINGS

#define	_NO_CRT_STDIO_INLINE

#define	UNUSED(x) (void)(x)

#define	BTRFS_NODE_TYPE_CCB 0x2295

#define	BTRFS_NODE_TYPE_FCB 0x2296

#define	ALLOC_TAG 0x7442484D

#define	ALLOC_TAG_ZLIB 0x7A42484D

#define	UID_NOBODY 65534

#define	GID_NOBODY 65534

#define	EA_NTACL "security.NTACL"

#define	EA_NTACL_HASH 0x45922146

#define	EA_DOSATTRIB "user.DOSATTRIB"

#define	EA_DOSATTRIB_HASH 0x914f9939

#define	EA_REPARSE "user.reparse"

#define	EA_REPARSE_HASH 0xfabad1fe

#define	EA_EA "user.EA"

#define	EA_EA_HASH 0x8270dd43

#define	EA_CASE_SENSITIVE "user.casesensitive"

#define	EA_CASE_SENSITIVE_HASH 0x1a9d97d4

#define	EA_PROP_COMPRESSION "btrfs.compression"

#define	EA_PROP_COMPRESSION_HASH 0x20ccdf69

#define	MAX_EXTENT_SIZE 0x8000000

#define	COMPRESSED_EXTENT_SIZE 0x20000

#define	READ_AHEAD_GRANULARITY COMPRESSED_EXTENT_SIZE

#define	IO_REPARSE_TAG_LX_SYMLINK 0xa000001d

#define	IO_REPARSE_TAG_AF_UNIX 0x80000023

#define	IO_REPARSE_TAG_LX_FIFO 0x80000024

#define	IO_REPARSE_TAG_LX_CHR 0x80000025

#define	IO_REPARSE_TAG_LX_BLK 0x80000026

#define	BTRFS_VOLUME_PREFIX L"\\Device\\Btrfs{"

#define	try if (1)

#define	except(x) if (0 && (x))

#define	finally if (1)

#define	leave

#define	InterlockedIncrement64(a) __sync_add_and_fetch(a, 1)

#define	FILE_SUPPORTS_BLOCK_REFCOUNTING 0x08000000

#define	FILE_SUPPORTS_POSIX_UNLINK_RENAME 0x00000400

#define	FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL 0x00020000

#define	FILE_CS_FLAG_CASE_SENSITIVE_DIR 1

#define	FSCTL_DUPLICATE_EXTENTS_TO_FILE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 209, METHOD_BUFFERED, FILE_WRITE_ACCESS)

#define	FSCTL_GET_INTEGRITY_INFORMATION CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 159, METHOD_BUFFERED, FILE_ANY_ACCESS)

#define	FSCTL_SET_INTEGRITY_INFORMATION CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 160, METHOD_BUFFERED, FILE_READ_DATA \| FILE_WRITE_DATA)

#define	__drv_aliasesMem

#define	_Dispatch_type_(a)

#define	_Lock_level_order_(a, b)

#define	MAX_HASH_SIZE 32

#define	VCB_TYPE_FS 1

#define	VCB_TYPE_CONTROL 2

#define	VCB_TYPE_VOLUME 3

#define	VCB_TYPE_PDO 4

#define	VCB_TYPE_BUS 5

#define	BALANCE_OPTS_DATA 0

#define	BALANCE_OPTS_METADATA 1

#define	BALANCE_OPTS_SYSTEM 2

#define	keycmp(key1, key2)

#define	acquire_chunk_lock(c, Vcb) ExAcquireResourceExclusiveLite(&(c)->lock, true)

#define	release_chunk_lock(c, Vcb) ExReleaseResourceLite(&(c)->lock)

#define	funcname __func__

#define	__attribute__(x)

#define	TRACE(s, ...) do { } while(0)

#define	WARN(s, ...) do { } while(0)

#define	FIXME(s, ...) DbgPrint("Btrfs FIXME : %s : " s, funcname, ##__VA_ARGS__)

#define	ERR(s, ...) DbgPrint("Btrfs ERR : %s : " s, funcname, ##__VA_ARGS__)

#define	SHA256_HASH_SIZE 32

#define	BLAKE2_HASH_SIZE 32

#define	makedev(major, minor) (((minor) & 0xFF) \| (((major) & 0xFFF) << 8) \| (((uint64_t)((minor) & ~0xFF)) << 12) \| (((uint64_t)((major) & ~0xFFF)) << 32))

#define	FSRTL_FCB_HEADER_V2 2

#define	increase_fileref_refcount(fileref) InterlockedIncrement(&fileref->refcount)

#define	int3 asm("int3;")

#define	hex_digit(c) ((c) <= 9) ? ((c) + '0') : ((c) - 10 + 'a')

#define	__S_IFMT 0170000 /* These bits determine file type. */

#define	__S_IFDIR 0040000 /* Directory. */

#define	__S_IFCHR 0020000 /* Character device. */

#define	__S_IFBLK 0060000 /* Block device. */

#define	__S_IFREG 0100000 /* Regular file. */

#define	__S_IFIFO 0010000 /* FIFO. */

#define	__S_IFLNK 0120000 /* Symbolic link. */

#define	__S_IFSOCK 0140000 /* Socket. */

#define	__S_ISTYPE(mode, mask) (((mode) & __S_IFMT) == (mask))

#define	S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR)

#define	S_IRUSR 0000400

#define	S_IWUSR 0000200

#define	S_IXUSR 0000100

#define	S_IRGRP (S_IRUSR >> 3)

#define	S_IWGRP (S_IWUSR >> 3)

#define	S_IXGRP (S_IXUSR >> 3)

#define	S_IROTH (S_IRGRP >> 3)

#define	S_IWOTH (S_IWGRP >> 3)

#define	S_IXOTH (S_IXGRP >> 3)

#define	S_ISUID 0004000

#define	S_ISGID 0002000

#define	S_ISVTX 0001000

#define	major(rdev) ((((rdev) >> 8) & 0xFFF) \| ((uint32_t)((rdev) >> 32) & ~0xFFF))

#define	minor(rdev) (((rdev) & 0xFF) \| ((uint32_t)((rdev) >> 12) & ~0xFF))

#define	CC_ENABLE_DISK_IO_ACCOUNTING 0x00000010

Typedefs
typedef struct _FILE_ID_128	FILE_ID_128

typedef struct _FILE_ID_128 *	PFILE_ID_128

typedef struct _DUPLICATE_EXTENTS_DATA	DUPLICATE_EXTENTS_DATA

typedef struct _DUPLICATE_EXTENTS_DATA *	PDUPLICATE_EXTENTS_DATA

typedef struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER	FSCTL_GET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER *	PFSCTL_GET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER	FSCTL_SET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER *	PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER

typedef struct _fcb_nonpaged	fcb_nonpaged

typedef struct _fcb	fcb

typedef struct _file_ref	file_ref

typedef struct _ccb	ccb

typedef struct _tree_data	tree_data

typedef struct _tree	tree

typedef struct _root	root

typedef struct _root_cache	root_cache

typedef struct _device_extension	device_extension

typedef struct _volume_device_extension	volume_device_extension

typedef struct pdo_device_extension	pdo_device_extension

typedef struct _write_data_context	write_data_context

typedef void(__stdcall *	xor_func) (uint8_t buf1, uint8_t buf2, uint32_t len)

typedef BOOLEAN(__stdcall *	tPsIsDiskCountersEnabled) ()

typedef VOID(__stdcall *	tPsUpdateDiskCounters) (PEPROCESS Process, ULONG64 BytesRead, ULONG64 BytesWritten, ULONG ReadOperationCount, ULONG WriteOperationCount, ULONG FlushOperationCount)

typedef BOOLEAN(__stdcall *	tCcCopyWriteEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PETHREAD IoIssuerThread)

typedef BOOLEAN(__stdcall *	tCcCopyReadEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PETHREAD IoIssuerThread)

typedef VOID(__stdcall *	tCcSetAdditionalCacheAttributesEx) (PFILE_OBJECT FileObject, ULONG Flags)

typedef VOID(__stdcall *	tFsRtlUpdateDiskCounters) (ULONG64 BytesRead, ULONG64 BytesWritten)

typedef NTSTATUS(__stdcall *	tIoUnregisterPlugPlayNotificationEx) (PVOID NotificationEntry)

typedef NTSTATUS(__stdcall *	tFsRtlGetEcpListFromIrp) (PIRP Irp, PECP_LIST *EcpList)

typedef NTSTATUS(__stdcall *	tFsRtlGetNextExtraCreateParameter) (PECP_LIST EcpList, PVOID CurrentEcpContext, LPGUID NextEcpType, PVOID NextEcpContext, ULONG NextEcpContextSize)

typedef NTSTATUS(__stdcall *	tFsRtlValidateReparsePointBuffer) (ULONG BufferLength, PREPARSE_DATA_BUFFER ReparseBuffer)

typedef BOOLEAN(__stdcall *	tFsRtlCheckLockForOplockRequest) (PFILE_LOCK FileLock, PLARGE_INTEGER AllocationSize)

typedef BOOLEAN(__stdcall *	tFsRtlAreThereCurrentOrInProgressFileLocks) (PFILE_LOCK FileLock)

typedef struct _LDR_DATA_TABLE_ENTRY	LDR_DATA_TABLE_ENTRY

typedef struct _LDR_DATA_TABLE_ENTRY *	PLDR_DATA_TABLE_ENTRY

typedef struct _PEB_LDR_DATA	PEB_LDR_DATA

typedef struct _PEB_LDR_DATA *	PPEB_LDR_DATA

typedef struct _RTL_USER_PROCESS_PARAMETERS	RTL_USER_PROCESS_PARAMETERS

typedef struct _RTL_USER_PROCESS_PARAMETERS *	PRTL_USER_PROCESS_PARAMETERS

typedef VOID(NTAPI *	PPS_POST_PROCESS_INIT_ROUTINE) (VOID)

typedef struct _PEB	PEB

typedef struct _PEB *	PPEB

Enumerations
enum	prop_compression_type { PropCompression_None , PropCompression_Zlib , PropCompression_LZO , PropCompression_ZSTD }

enum	batch_operation { Batch_Delete , Batch_DeleteInode , Batch_DeleteDirItem , Batch_DeleteInodeRef , Batch_DeleteInodeExtRef , Batch_DeleteXattr , Batch_DeleteExtentData , Batch_DeleteFreeSpace , Batch_Insert , Batch_SetXattr , Batch_DirItem , Batch_InodeRef , Batch_InodeExtRef }

enum	calc_thread_type { calc_thread_crc32c , calc_thread_xxhash , calc_thread_sha256 , calc_thread_blake2 , calc_thread_decomp_zlib , calc_thread_decomp_lzo , calc_thread_decomp_zstd , calc_thread_comp_zlib , calc_thread_comp_lzo , calc_thread_comp_zstd }

enum	write_data_status { WriteDataStatus_Pending , WriteDataStatus_Success , WriteDataStatus_Error , WriteDataStatus_Cancelling , WriteDataStatus_Cancelled , WriteDataStatus_Ignore }

enum	rollback_type { ROLLBACK_INSERT_EXTENT , ROLLBACK_DELETE_EXTENT , ROLLBACK_ADD_SPACE , ROLLBACK_SUBTRACT_SPACE }

Functions
	_Create_lock_level_ (tree_lock) _Create_lock_level_(fcb_lock) _Lock_level_order_(tree_lock

	_Requires_lock_not_held_ (Vcb->fcb_lock) _Acquires_shared_lock_(Vcb -> fcb_lock) static __inline void acquire_fcb_lock_shared(device_extension *Vcb)

	_Requires_lock_held_ (Vcb->fcb_lock) _Releases_lock_(Vcb -> fcb_lock) static __inline void release_fcb_lock(device_extension *Vcb)

static __inline void *	map_user_buffer (PIRP Irp, ULONG priority)

static __inline uint64_t	unix_time_to_win (BTRFS_TIME *t)

static __inline void	win_time_to_unix (LARGE_INTEGER t, BTRFS_TIME *out)

_Post_satisfies_ static stripe __inline void	get_raid0_offset (_In_ uint64_t off, _In_ uint64_t stripe_length, _In_ uint16_t num_stripes, _Out_ uint64_t stripeoff, _Out_ uint16_t stripe)

static __inline uint64_t	make_file_id (root *r, uint64_t inode)

	_Post_satisfies_ (return >=n) __inline static uint64_t sector_align(_In_ uint64_t n

static __inline bool	is_subvol_readonly (root *r, PIRP Irp)

static __inline uint16_t	get_extent_data_len (uint8_t type)

static __inline uint32_t	get_extent_data_refcount (uint8_t type, void *data)

_Ret_maybenull_ device *	find_device_from_uuid (_In_ device_extension Vcb, _In_ BTRFS_UUID uuid)

	_Success_ (return) bool get_file_attributes_from_xattr(_In_reads_bytes_(len) char *val

ULONG	get_file_attributes (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension Vcb, _In_ root r, _In_ uint64_t inode, _In_ uint8_t type, _In_ bool dotfile, _In_ bool ignore_xa, _In_opt_ PIRP Irp)

void	free_fcb (_Inout_ fcb *fcb)

void	free_fileref (_Inout_ file_ref *fr)

void	protect_superblocks (_Inout_ chunk *c)

bool	is_top_level (_In_ PIRP Irp)

NTSTATUS	create_root (_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension Vcb, _In_ uint64_t id, _Out_ root *rootptr, _In_ bool no_tree, _In_ uint64_t offset, _In_opt_ PIRP Irp)

void	uninit (_In_ device_extension *Vcb)

NTSTATUS	dev_ioctl (_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG ControlCode, _In_reads_bytes_opt_(InputBufferSize) PVOID InputBuffer, _In_ ULONG InputBufferSize, _Out_writes_bytes_opt_(OutputBufferSize) PVOID OutputBuffer, _In_ ULONG OutputBufferSize, _In_ bool Override, _Out_opt_ IO_STATUS_BLOCK *iosb)

NTSTATUS	check_file_name_valid (_In_ PUNICODE_STRING us, _In_ bool posix, _In_ bool stream)

void	send_notification_fileref (_In_ file_ref *fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream)

void	queue_notification_fcb (_In_ file_ref *fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream)

void	mark_fcb_dirty (_In_ fcb *fcb)

void	mark_fileref_dirty (_In_ file_ref *fileref)

NTSTATUS	delete_fileref (_In_ file_ref fileref, _In_opt_ PFILE_OBJECT FileObject, _In_ bool make_orphan, _In_opt_ PIRP Irp, _In_ LIST_ENTRY rollback)

void	chunk_lock_range (_In_ device_extension Vcb, _In_ chunk c, _In_ uint64_t start, _In_ uint64_t length)

void	chunk_unlock_range (_In_ device_extension Vcb, _In_ chunk c, _In_ uint64_t start, _In_ uint64_t length)

void	init_device (_In_ device_extension Vcb, _Inout_ device dev, _In_ bool get_nums)

void	init_file_cache (_In_ PFILE_OBJECT FileObject, _In_ CC_FILE_SIZES *ccfs)

NTSTATUS	sync_read_phys (_In_ PDEVICE_OBJECT DeviceObject, _In_ PFILE_OBJECT FileObject, _In_ uint64_t StartingOffset, _In_ ULONG Length, _Out_writes_bytes_(Length) PUCHAR Buffer, _In_ bool override)

NTSTATUS	get_device_pnp_name (_In_ PDEVICE_OBJECT DeviceObject, _Out_ PUNICODE_STRING pnp_name, _Out_ const GUID **guid)

void	log_device_error (_In_ device_extension Vcb, _Inout_ device dev, _In_ int error)

NTSTATUS	find_chunk_usage (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_opt_ PIRP Irp)

	_Function_class_ (DRIVER_ADD_DEVICE) NTSTATUS __stdcall AddDevice(PDRIVER_OBJECT DriverObject

void	reap_fcb (fcb *fcb)

void	reap_fcbs (device_extension *Vcb)

void	reap_fileref (device_extension Vcb, file_ref fr)

void	reap_filerefs (device_extension Vcb, file_ref fr)

NTSTATUS	utf8_to_utf16 (WCHAR dest, ULONG dest_max, ULONG dest_len, char *src, ULONG src_len)

NTSTATUS	utf16_to_utf8 (char dest, ULONG dest_max, ULONG dest_len, WCHAR *src, ULONG src_len)

uint32_t	get_num_of_processors ()

_Ret_maybenull_ root *	find_default_subvol (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_opt_ PIRP Irp)

void	do_shutdown (PIRP Irp)

bool	check_superblock_checksum (superblock *sb)

void	init_fast_io_dispatch (FAST_IO_DISPATCH **fiod)

void	calc_sha256 (uint8_t hash, const void input, size_t len)

void	blake2b (void out, size_t outlen, const void in, size_t inlen)

NTSTATUS	find_item (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension Vcb, _In_ root r, _Out_ traverse_ptr tp, _In_ const KEY searchkey, _In_ bool ignore, _In_opt_ PIRP Irp) __attribute__((nonnull(1

NTSTATUS NTSTATUS	find_item_to_level (device_extension Vcb, root r, traverse_ptr tp, const KEY searchkey, bool ignore, uint8_t level, PIRP Irp) __attribute__((nonnull(1

NTSTATUS NTSTATUS bool	find_next_item (_Requires_lock_held_(_Curr_->tree_lock) device_extension Vcb, const traverse_ptr tp, traverse_ptr *next_tp, bool ignore, PIRP Irp) __attribute__((nonnull(1

NTSTATUS NTSTATUS bool bool	find_prev_item (_Requires_lock_held_(_Curr_->tree_lock) device_extension Vcb, const traverse_ptr tp, traverse_ptr *prev_tp, PIRP Irp) __attribute__((nonnull(1

NTSTATUS NTSTATUS bool bool void	free_trees (device_extension *Vcb) __attribute__((nonnull(1)))

NTSTATUS	insert_tree_item (_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension Vcb, _In_ root r, _In_ uint64_t obj_id, _In_ uint8_t obj_type, _In_ uint64_t offset, _In_reads_bytes_opt_(size) _When_(return >=0, __drv_aliasesMem) void data, _In_ uint16_t size, _Out_opt_ traverse_ptr ptp, _In_opt_ PIRP Irp) __attribute__((nonnull(1

NTSTATUS NTSTATUS	delete_tree_item (_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension Vcb, _Inout_ traverse_ptr tp) __attribute__((nonnull(1

NTSTATUS NTSTATUS void	free_tree (tree *t) __attribute__((nonnull(1)))

NTSTATUS	load_tree (device_extension Vcb, uint64_t addr, uint8_t buf, root r, tree *pt) __attribute__((nonnull(1

NTSTATUS NTSTATUS	do_load_tree (device_extension Vcb, tree_holder th, root r, tree t, tree_data *td, PIRP Irp) __attribute__((nonnull(1

NTSTATUS NTSTATUS void	clear_rollback (LIST_ENTRY *rollback) __attribute__((nonnull(1)))

void	do_rollback (device_extension Vcb, LIST_ENTRY rollback) __attribute__((nonnull(1

void void	free_trees_root (device_extension Vcb, root r) __attribute__((nonnull(1

void void void	add_rollback (_In_ LIST_ENTRY rollback, _In_ enum rollback_type type, _In_ __drv_aliasesMem void ptr) __attribute__((nonnull(1

void void void NTSTATUS	commit_batch_list (_Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension Vcb, LIST_ENTRY batchlist, PIRP Irp) __attribute__((nonnull(1

void void void NTSTATUS void	clear_batch_list (device_extension Vcb, LIST_ENTRY batchlist) __attribute__((nonnull(1

void void void NTSTATUS void NTSTATUS	skip_to_difference (device_extension Vcb, traverse_ptr tp, traverse_ptr tp2, bool ended1, bool *ended2) __attribute__((nonnull(1

void void void NTSTATUS void NTSTATUS NTSTATUS	remove_drive_letter (PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath)

	_Function_class_ (KSTART_ROUTINE) void __stdcall mountmgr_thread(_In_ void *context)

	_Function_class_ (DRIVER_NOTIFICATION_CALLBACK_ROUTINE) NTSTATUS __stdcall pnp_notification(PVOID NotificationStructure

void	disk_arrival (PUNICODE_STRING devpath)

bool	volume_arrival (PUNICODE_STRING devpath, bool fve_callback)

void	volume_removal (PUNICODE_STRING devpath)

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)

void	init_cache ()

NTSTATUS	write_file (device_extension *Vcb, PIRP Irp, bool wait, bool deferred_write) __attribute__((nonnull(1

NTSTATUS NTSTATUS	write_file2 (device_extension Vcb, PIRP Irp, LARGE_INTEGER offset, void buf, ULONG length, bool paging_io, bool no_cache, bool wait, bool deferred_write, bool write_irp, LIST_ENTRY rollback) __attribute__((nonnull(1

NTSTATUS NTSTATUS NTSTATUS	truncate_file (fcb fcb, uint64_t end, PIRP Irp, LIST_ENTRY rollback) __attribute__((nonnull(1

NTSTATUS NTSTATUS NTSTATUS NTSTATUS	extend_file (fcb fcb, file_ref fileref, uint64_t end, bool prealloc, PIRP Irp, LIST_ENTRY *rollback) __attribute__((nonnull(1

NTSTATUS NTSTATUS NTSTATUS NTSTATUS NTSTATUS	excise_extents (device_extension Vcb, fcb fcb, uint64_t start_data, uint64_t end_data, PIRP Irp, LIST_ENTRY *rollback) __attribute__((nonnull(1

NTSTATUS NTSTATUS NTSTATUS NTSTATUS NTSTATUS chunk *	get_chunk_from_address (device_extension *Vcb, uint64_t address) __attribute__((nonnull(1)))

NTSTATUS	alloc_chunk (device_extension Vcb, uint64_t flags, chunk *pc, bool full_size) __attribute__((nonnull(1

NTSTATUS NTSTATUS	write_data (_In_ device_extension Vcb, _In_ uint64_t address, _In_reads_bytes_(length) void data, _In_ uint32_t length, _In_ write_data_context wtc, _In_opt_ PIRP Irp, _In_opt_ chunk c, _In_ bool file_write, _In_ uint64_t irp_offset, _In_ ULONG priority) __attribute__((nonnull(1

NTSTATUS NTSTATUS NTSTATUS	write_data_complete (device_extension Vcb, uint64_t address, void data, uint32_t length, PIRP Irp, chunk *c, bool file_write, uint64_t irp_offset, ULONG priority) __attribute__((nonnull(1

NTSTATUS NTSTATUS NTSTATUS void	free_write_data_stripes (write_data_context *wtc) __attribute__((nonnull(1)))

	_Dispatch_type_ (IRP_MJ_WRITE) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_write(IN PDEVICE_OBJECT DeviceObject

IN PIRP Irp	__attribute__ ((nonnull(1, 2)))

	_Requires_lock_held_ (c->lock) _When_(return !=0

	_Releases_lock_ (c->lock)) bool insert_extent_chunk(_In_ device_extension *Vcb

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t _In_ bool _In_ uint64_t irp_offset	__attribute__ ((nonnull(1, 2, 3, 9)))

NTSTATUS	do_write_file (fcb fcb, uint64_t start_data, uint64_t end_data, void data, PIRP Irp, bool file_write, uint32_t irp_offset, LIST_ENTRY *rollback) __attribute__((nonnull(1

NTSTATUS bool	find_data_address_in_chunk (device_extension Vcb, chunk c, uint64_t length, uint64_t *address) __attribute__((nonnull(1

NTSTATUS bool void	get_raid56_lock_range (chunk c, uint64_t address, uint64_t length, uint64_t lockaddr, uint64_t *locklen) __attribute__((nonnull(1

NTSTATUS bool void NTSTATUS	add_extent_to_fcb (_In_ fcb fcb, _In_ uint64_t offset, _In_reads_bytes_(edsize) EXTENT_DATA ed, _In_ uint16_t edsize, _In_ bool unique, _In_opt_ _When_(return >=0, __drv_aliasesMem) void csum, _In_ LIST_ENTRY rollback) __attribute__((nonnull(1

NTSTATUS bool void NTSTATUS void	add_extent (_In_ fcb fcb, _In_ LIST_ENTRY prevextle, _In_ __drv_aliasesMem extent *newext) __attribute__((nonnull(1

NTSTATUS bool void NTSTATUS void	_Dispatch_type_ (IRP_MJ_DIRECTORY_CONTROL) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_directory_control(IN PDEVICE_OBJECT DeviceObject

ULONG	get_reparse_tag (device_extension Vcb, root subvol, uint64_t inode, uint8_t type, ULONG atts, bool lxss, PIRP Irp)

ULONG	get_reparse_tag_fcb (fcb *fcb)

	_Dispatch_type_ (IRP_MJ_QUERY_SECURITY) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_query_security(IN PDEVICE_OBJECT DeviceObject

	_Dispatch_type_ (IRP_MJ_SET_SECURITY) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_set_security(IN PDEVICE_OBJECT DeviceObject

void	fcb_get_sd (fcb fcb, struct _fcb parent, bool look_for_xattr, PIRP Irp)

void	add_user_mapping (WCHAR *sidstring, ULONG sidstringlength, uint32_t uid)

void	add_group_mapping (WCHAR *sidstring, ULONG sidstringlength, uint32_t gid)

uint32_t	sid_to_uid (PSID sid)

NTSTATUS	uid_to_sid (uint32_t uid, PSID *sid)

NTSTATUS	fcb_get_new_sd (fcb fcb, file_ref parfileref, ACCESS_STATE *as)

void	find_gid (struct _fcb fcb, struct _fcb parfcb, PSECURITY_SUBJECT_CONTEXT subjcont)

	_Dispatch_type_ (IRP_MJ_SET_INFORMATION) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_set_information(IN PDEVICE_OBJECT DeviceObject

	_Dispatch_type_ (IRP_MJ_QUERY_INFORMATION) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_query_information(IN PDEVICE_OBJECT DeviceObject

	_Dispatch_type_ (IRP_MJ_QUERY_EA) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_query_ea(IN PDEVICE_OBJECT DeviceObject

	_Dispatch_type_ (IRP_MJ_SET_EA) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_set_ea(IN PDEVICE_OBJECT DeviceObject

bool	has_open_children (file_ref *fileref)

NTSTATUS	stream_set_end_of_file_information (device_extension Vcb, uint16_t end, fcb fcb, file_ref *fileref, bool advance_only)

NTSTATUS	fileref_get_filename (file_ref fileref, PUNICODE_STRING fn, USHORT name_offset, ULONG *preqlen)

void	insert_dir_child_into_hash_lists (fcb fcb, dir_child dc)

void	remove_dir_child_from_hash_lists (fcb fcb, dir_child dc)

void	add_fcb_to_subvol (_In_ _Requires_exclusive_lock_held_(_Curr_->Vcb->fcb_lock) fcb *fcb)

void	remove_fcb_from_subvol (_In_ _Requires_exclusive_lock_held_(_Curr_->Vcb->fcb_lock) fcb *fcb)

NTSTATUS	get_reparse_point (PFILE_OBJECT FileObject, void buffer, DWORD buflen, ULONG_PTR retlen)

NTSTATUS	set_reparse_point2 (fcb fcb, REPARSE_DATA_BUFFER rdb, ULONG buflen, ccb ccb, file_ref fileref, PIRP Irp, LIST_ENTRY *rollback)

NTSTATUS	set_reparse_point (PIRP Irp)

NTSTATUS	delete_reparse_point (PIRP Irp)

	_Dispatch_type_ (IRP_MJ_CREATE) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_create(IN PDEVICE_OBJECT DeviceObject

NTSTATUS	open_fileref (_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension Vcb, _Out_ file_ref pfr, _In_ PUNICODE_STRING fnus, _In_opt_ file_ref related, _In_ bool parent, _Out_opt_ USHORT parsed, _Out_opt_ ULONG fn_offset, _In_ POOL_TYPE pooltype, _In_ bool case_sensitive, _In_opt_ PIRP Irp)

NTSTATUS	open_fcb (_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension Vcb, root subvol, uint64_t inode, uint8_t type, PANSI_STRING utf8, bool always_add_hl, fcb parent, fcb *pfcb, POOL_TYPE pooltype, PIRP Irp)

NTSTATUS	load_csum (_Requires_lock_held_(_Curr_->tree_lock) device_extension Vcb, void csum, uint64_t start, uint64_t length, PIRP Irp)

NTSTATUS	load_dir_children (_Requires_lock_held_(_Curr_->tree_lock) device_extension Vcb, fcb fcb, bool ignore_size, PIRP Irp)

NTSTATUS	add_dir_child (fcb fcb, uint64_t inode, bool subvol, PANSI_STRING utf8, PUNICODE_STRING name, uint8_t type, dir_child *pdc)

NTSTATUS	open_fileref_child (_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension Vcb, _In_ file_ref sf, _In_ PUNICODE_STRING name, _In_ bool case_sensitive, _In_ bool lastpart, _In_ bool streampart, _In_ POOL_TYPE pooltype, _Out_ file_ref **psf2, _In_opt_ PIRP Irp)

fcb *	create_fcb (device_extension *Vcb, POOL_TYPE pool_type)

NTSTATUS	find_file_in_dir (PUNICODE_STRING filename, fcb fcb, root subvol, uint64_t inode, dir_child **pdc, bool case_sensitive)

uint32_t	inherit_mode (fcb *parfcb, bool is_dir)

file_ref *	create_fileref (device_extension *Vcb)

NTSTATUS	open_fileref_by_inode (_Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension Vcb, root subvol, uint64_t inode, file_ref **pfr, PIRP Irp)

NTSTATUS	fsctl_request (PDEVICE_OBJECT DeviceObject, PIRP *Pirp, uint32_t type)

void	do_unlock_volume (device_extension *Vcb)

void	trim_whole_device (device *dev)

void	flush_subvol_fcbs (root *subvol)

bool	fcb_is_inline (fcb *fcb)

NTSTATUS	dismount_volume (device_extension *Vcb, bool shutdown, PIRP Irp)

NTSTATUS	do_write (device_extension *Vcb, PIRP Irp)

NTSTATUS	get_tree_new_address (device_extension Vcb, tree t, PIRP Irp, LIST_ENTRY *rollback)

NTSTATUS	flush_fcb (fcb fcb, bool cache, LIST_ENTRY batchlist, PIRP Irp)

NTSTATUS	write_data_phys (_In_ PDEVICE_OBJECT device, _In_ PFILE_OBJECT fileobj, _In_ uint64_t address, _In_reads_bytes_(length) void *data, _In_ uint32_t length)

bool	is_tree_unique (device_extension Vcb, tree t, PIRP Irp)

NTSTATUS	do_tree_writes (device_extension Vcb, LIST_ENTRY tree_writes, bool no_free)

void	add_checksum_entry (device_extension Vcb, uint64_t address, ULONG length, void csum, PIRP Irp)

bool	find_metadata_address_in_chunk (device_extension Vcb, chunk c, uint64_t *address)

void	add_trim_entry_avoid_sb (device_extension Vcb, device dev, uint64_t address, uint64_t size)

NTSTATUS	flush_partial_stripe (device_extension Vcb, chunk c, partial_stripe *ps)

NTSTATUS	update_dev_item (device_extension Vcb, device device, PIRP Irp)

void	calc_tree_checksum (device_extension Vcb, tree_header th)

	_Dispatch_type_ (IRP_MJ_READ) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_read(PDEVICE_OBJECT DeviceObject

NTSTATUS	read_data (_In_ device_extension Vcb, _In_ uint64_t addr, _In_ uint32_t length, _In_reads_bytes_opt_(length sizeof(uint32_t)/Vcb->superblock.sector_size) void csum, _In_ bool is_tree, _Out_writes_bytes_(length) uint8_t buf, _In_opt_ chunk c, _Out_opt_ chunk *pc, _In_opt_ PIRP Irp, _In_ uint64_t generation, _In_ bool file_read, _In_ ULONG priority)

NTSTATUS	read_file (fcb fcb, uint8_t data, uint64_t start, uint64_t length, ULONG *pbr, PIRP Irp) __attribute__((nonnull(1

NTSTATUS NTSTATUS	read_stream (fcb fcb, uint8_t data, uint64_t start, ULONG length, ULONG *pbr) __attribute__((nonnull(1

NTSTATUS NTSTATUS NTSTATUS	do_read (PIRP Irp, bool wait, ULONG *bytes_read)

NTSTATUS	check_csum (device_extension Vcb, uint8_t data, uint32_t sectors, void *csum)

void	raid6_recover2 (uint8_t sectors, uint16_t num_stripes, ULONG sector_size, uint16_t missing1, uint16_t missing2, uint8_t out)

void	get_tree_checksum (device_extension Vcb, tree_header th, void *csum)

bool	check_tree_checksum (device_extension Vcb, tree_header th)

void	get_sector_csum (device_extension Vcb, void buf, void *csum)

bool	check_sector_csum (device_extension Vcb, void buf, void *csum)

	_Dispatch_type_ (IRP_MJ_PNP) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_pnp(PDEVICE_OBJECT DeviceObject

NTSTATUS	pnp_surprise_removal (PDEVICE_OBJECT DeviceObject, PIRP Irp)

NTSTATUS	pnp_query_remove_device (PDEVICE_OBJECT DeviceObject, PIRP Irp)

NTSTATUS	load_cache_chunk (device_extension Vcb, chunk c, PIRP Irp)

NTSTATUS	clear_free_space_cache (device_extension Vcb, LIST_ENTRY batchlist, PIRP Irp)

NTSTATUS	allocate_cache (device_extension Vcb, bool changed, PIRP Irp, LIST_ENTRY *rollback)

NTSTATUS	update_chunk_caches (device_extension Vcb, PIRP Irp, LIST_ENTRY rollback)

NTSTATUS	update_chunk_caches_tree (device_extension *Vcb, PIRP Irp)

NTSTATUS	add_space_entry (LIST_ENTRY list, LIST_ENTRY list_size, uint64_t offset, uint64_t size)

void	space_list_add (chunk c, uint64_t address, uint64_t length, LIST_ENTRY rollback)

void	space_list_add2 (LIST_ENTRY list, LIST_ENTRY list_size, uint64_t address, uint64_t length, chunk c, LIST_ENTRY rollback)

void	space_list_subtract (chunk c, uint64_t address, uint64_t length, LIST_ENTRY rollback)

void	space_list_subtract2 (LIST_ENTRY list, LIST_ENTRY list_size, uint64_t address, uint64_t length, chunk c, LIST_ENTRY rollback)

void	space_list_merge (LIST_ENTRY spacelist, LIST_ENTRY spacelist_size, LIST_ENTRY *deleting)

NTSTATUS	load_stored_free_space_cache (device_extension Vcb, chunk c, bool load_only, PIRP Irp)

NTSTATUS	increase_extent_refcount_data (device_extension *Vcb, uint64_t address, uint64_t size, uint64_t root, uint64_t inode, uint64_t offset, uint32_t refcount, PIRP Irp)

NTSTATUS	decrease_extent_refcount_data (device_extension *Vcb, uint64_t address, uint64_t size, uint64_t root, uint64_t inode, uint64_t offset, uint32_t refcount, bool superseded, PIRP Irp)

NTSTATUS	decrease_extent_refcount_tree (device_extension *Vcb, uint64_t address, uint64_t size, uint64_t root, uint8_t level, PIRP Irp)

uint64_t	get_extent_refcount (device_extension *Vcb, uint64_t address, uint64_t size, PIRP Irp)

bool	is_extent_unique (device_extension *Vcb, uint64_t address, uint64_t size, PIRP Irp)

NTSTATUS	increase_extent_refcount (device_extension Vcb, uint64_t address, uint64_t size, uint8_t type, void data, KEY *firstitem, uint8_t level, PIRP Irp)

uint64_t	get_extent_flags (device_extension *Vcb, uint64_t address, PIRP Irp)

void	update_extent_flags (device_extension *Vcb, uint64_t address, uint64_t flags, PIRP Irp)

NTSTATUS	update_changed_extent_ref (device_extension Vcb, chunk c, uint64_t address, uint64_t size, uint64_t root, uint64_t objid, uint64_t offset, int32_t count, bool no_csum, bool superseded, PIRP Irp)

void	add_changed_extent_ref (chunk *c, uint64_t address, uint64_t size, uint64_t root, uint64_t objid, uint64_t offset, uint32_t count, bool no_csum)

uint64_t	find_extent_shared_tree_refcount (device_extension *Vcb, uint64_t address, uint64_t parent, PIRP Irp)

uint32_t	find_extent_shared_data_refcount (device_extension *Vcb, uint64_t address, uint64_t parent, PIRP Irp)

NTSTATUS	decrease_extent_refcount (device_extension Vcb, uint64_t address, uint64_t size, uint8_t type, void data, KEY *firstitem, uint8_t level, uint64_t parent, bool superseded, PIRP Irp)

uint64_t	get_extent_data_ref_hash2 (uint64_t root, uint64_t objid, uint64_t offset)

NTSTATUS	do_read_job (PIRP Irp)

NTSTATUS	do_write_job (device_extension *Vcb, PIRP Irp)

bool	add_thread_job (device_extension *Vcb, PIRP Irp)

void	read_registry (PUNICODE_STRING regpath, bool refresh)

NTSTATUS	registry_mark_volume_mounted (BTRFS_UUID *uuid)

NTSTATUS	registry_mark_volume_unmounted (BTRFS_UUID *uuid)

NTSTATUS	registry_load_volume_options (device_extension *Vcb)

void	watch_registry (HANDLE regh)

NTSTATUS	zlib_decompress (uint8_t inbuf, uint32_t inlen, uint8_t outbuf, uint32_t outlen)

NTSTATUS	lzo_decompress (uint8_t inbuf, uint32_t inlen, uint8_t outbuf, uint32_t outlen, uint32_t inpageoff)

NTSTATUS	zstd_decompress (uint8_t inbuf, uint32_t inlen, uint8_t outbuf, uint32_t outlen)

NTSTATUS	write_compressed (fcb fcb, uint64_t start_data, uint64_t end_data, void data, PIRP Irp, LIST_ENTRY *rollback)

NTSTATUS	zlib_compress (uint8_t inbuf, uint32_t inlen, uint8_t outbuf, uint32_t outlen, unsigned int level, unsigned int *space_left)

NTSTATUS	lzo_compress (uint8_t inbuf, uint32_t inlen, uint8_t outbuf, uint32_t outlen, unsigned int *space_left)

NTSTATUS	zstd_compress (uint8_t inbuf, uint32_t inlen, uint8_t outbuf, uint32_t outlen, uint32_t level, unsigned int *space_left)

void	galois_double (uint8_t *data, uint32_t len)

void	galois_divpower (uint8_t *data, uint8_t div, uint32_t readlen)

uint8_t	gpow2 (uint8_t e)

uint8_t	gmul (uint8_t a, uint8_t b)

uint8_t	gdiv (uint8_t a, uint8_t b)

	_Dispatch_type_ (IRP_MJ_DEVICE_CONTROL) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_device_control(IN PDEVICE_OBJECT DeviceObject

void	do_calc_job (device_extension Vcb, uint8_t data, uint32_t sectors, void *csum)

NTSTATUS	add_calc_job_decomp (device_extension Vcb, uint8_t compression, void in, unsigned int inlen, void out, unsigned int outlen, unsigned int off, calc_job *pcj)

NTSTATUS	add_calc_job_comp (device_extension Vcb, uint8_t compression, void in, unsigned int inlen, void out, unsigned int outlen, calc_job *pcj)

void	calc_thread_main (device_extension Vcb, calc_job cj)

NTSTATUS	start_balance (device_extension Vcb, void data, ULONG length, KPROCESSOR_MODE processor_mode)

NTSTATUS	query_balance (device_extension Vcb, void data, ULONG length)

NTSTATUS	pause_balance (device_extension *Vcb, KPROCESSOR_MODE processor_mode)

NTSTATUS	resume_balance (device_extension *Vcb, KPROCESSOR_MODE processor_mode)

NTSTATUS	stop_balance (device_extension *Vcb, KPROCESSOR_MODE processor_mode)

NTSTATUS	look_for_balance_item (_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb)

NTSTATUS	remove_device (device_extension Vcb, void data, ULONG length, KPROCESSOR_MODE processor_mode)

NTSTATUS	vol_create (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

NTSTATUS	vol_close (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

NTSTATUS	vol_read (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

NTSTATUS	vol_write (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

NTSTATUS	vol_device_control (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

void	add_volume_device (superblock *sb, PUNICODE_STRING devpath, uint64_t length, ULONG disk_num, ULONG part_num)

NTSTATUS	mountmgr_add_drive_letter (PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath)

void	free_vol (volume_device_extension *vde)

NTSTATUS	start_scrub (device_extension *Vcb, KPROCESSOR_MODE processor_mode)

NTSTATUS	query_scrub (device_extension Vcb, KPROCESSOR_MODE processor_mode, void data, ULONG length)

NTSTATUS	pause_scrub (device_extension *Vcb, KPROCESSOR_MODE processor_mode)

NTSTATUS	resume_scrub (device_extension *Vcb, KPROCESSOR_MODE processor_mode)

NTSTATUS	stop_scrub (device_extension *Vcb, KPROCESSOR_MODE processor_mode)

NTSTATUS	send_subvol (device_extension Vcb, void data, ULONG datalen, PFILE_OBJECT FileObject, PIRP Irp)

NTSTATUS	read_send_buffer (device_extension Vcb, PFILE_OBJECT FileObject, void data, ULONG datalen, ULONG_PTR *retlen, KPROCESSOR_MODE processor_mode)

NTSTATUS __stdcall	compat_FsRtlValidateReparsePointBuffer (IN ULONG BufferLength, IN PREPARSE_DATA_BUFFER ReparseBuffer)

void	check_system_root ()

void	boot_add_device (DEVICE_OBJECT *pdo)

static __inline POPLOCK	fcb_oplock (fcb *fcb)

static __inline FAST_IO_POSSIBLE	fast_io_possible (fcb *fcb)

static __inline void	print_open_trees (device_extension *Vcb)

static __inline bool	write_fcb_compressed (fcb *fcb)

static __inline uint64_t	fcb_alloc_size (fcb *fcb)

PEPROCESS __stdcall	PsGetThreadProcess (_In_ PETHREAD Thread)

Variables
_In_ uint64_t	a

return	n

_In_ uint16_t	len

_In_ uint16_t _Out_ ULONG *	atts

xor_func	do_xor

PDEVICE_OBJECT	PhysicalDeviceObject

uint32_t	mount_compress

uint32_t	mount_compress_force

uint32_t	mount_compress_type

uint32_t	mount_zlib_level

uint32_t	mount_zstd_level

uint32_t	mount_flush_interval

uint32_t	mount_max_inline

uint32_t	mount_skip_balance

uint32_t	mount_no_barrier

uint32_t	mount_no_trim

uint32_t	mount_clear_cache

uint32_t	mount_allow_degraded

uint32_t	mount_readonly

uint32_t	mount_no_root_dir

uint32_t	mount_nodatacow

uint32_t	no_pnp

static const char	lxuid [] = "$LXUID"

static const char	lxgid [] = "$LXGID"

static const char	lxmod [] = "$LXMOD"

static const char	lxdev [] = "$LXDEV"

PVOID	Context

KSPIN_LOCK	fve_data_lock

CACHE_MANAGER_CALLBACKS	cache_callbacks

_In_ fcb _In_ chunk *	c

_In_ fcb _In_ chunk _In_ uint64_t	start_data

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t	length

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool	prealloc

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void *	data

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP	Irp

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY *	rollback

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t	compression

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t	decoded_size

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t _In_ bool	file_write

BTRFS_UUID	boot_uuid

Macro Definition Documentation

◆ attribute

#define __attribute__ ( x )

Definition at line 1197 of file btrfs_drv.h.

◆ __drv_aliasesMem

#define __drv_aliasesMem

Definition at line 203 of file btrfs_drv.h.

◆ __S_IFBLK

#define __S_IFBLK 0060000 /* Block device. */

Definition at line 1756 of file btrfs_drv.h.

◆ __S_IFCHR

#define __S_IFCHR 0020000 /* Character device. */

Definition at line 1755 of file btrfs_drv.h.

◆ __S_IFDIR

#define __S_IFDIR 0040000 /* Directory. */

Definition at line 1754 of file btrfs_drv.h.

◆ __S_IFIFO

#define __S_IFIFO 0010000 /* FIFO. */

Definition at line 1758 of file btrfs_drv.h.

◆ __S_IFLNK

#define __S_IFLNK 0120000 /* Symbolic link. */

Definition at line 1759 of file btrfs_drv.h.

◆ __S_IFMT

#define __S_IFMT 0170000 /* These bits determine file type. */

Definition at line 1753 of file btrfs_drv.h.

◆ __S_IFREG

#define __S_IFREG 0100000 /* Regular file. */

Definition at line 1757 of file btrfs_drv.h.

◆ __S_IFSOCK

#define __S_IFSOCK 0140000 /* Socket. */

Definition at line 1760 of file btrfs_drv.h.

◆ __S_ISTYPE

#define __S_ISTYPE	(	mode,
		mask
	)	(((mode) & __S_IFMT) == (mask))

Definition at line 1761 of file btrfs_drv.h.

◆ _CRT_SECURE_NO_WARNINGS

#define _CRT_SECURE_NO_WARNINGS

Definition at line 26 of file btrfs_drv.h.

◆ _Dispatch_type_

#define _Dispatch_type_ ( a )

Definition at line 204 of file btrfs_drv.h.

◆ _Lock_level_order_

#define _Lock_level_order_	(	a,
		b
	)

Definition at line 205 of file btrfs_drv.h.

◆ _NO_CRT_STDIO_INLINE

#define _NO_CRT_STDIO_INLINE

Definition at line 27 of file btrfs_drv.h.

◆ _WIN32_WINNT

#define _WIN32_WINNT 0x0601

Definition at line 24 of file btrfs_drv.h.

◆ acquire_chunk_lock

#define acquire_chunk_lock	(	c,
		Vcb
	)	ExAcquireResourceExclusiveLite(&(c)->lock, true)

Definition at line 1139 of file btrfs_drv.h.

◆ ALLOC_TAG

#define ALLOC_TAG 0x7442484D

Definition at line 87 of file btrfs_drv.h.

◆ ALLOC_TAG_ZLIB

#define ALLOC_TAG_ZLIB 0x7A42484D

Definition at line 88 of file btrfs_drv.h.

◆ BALANCE_OPTS_DATA

#define BALANCE_OPTS_DATA 0

Definition at line 693 of file btrfs_drv.h.

◆ BALANCE_OPTS_METADATA

#define BALANCE_OPTS_METADATA 1

Definition at line 694 of file btrfs_drv.h.

◆ BALANCE_OPTS_SYSTEM

#define BALANCE_OPTS_SYSTEM 2

Definition at line 695 of file btrfs_drv.h.

◆ BLAKE2_HASH_SIZE

#define BLAKE2_HASH_SIZE 32

Definition at line 1252 of file btrfs_drv.h.

◆ BTRFS_NODE_TYPE_CCB

#define BTRFS_NODE_TYPE_CCB 0x2295

Definition at line 84 of file btrfs_drv.h.

◆ BTRFS_NODE_TYPE_FCB

#define BTRFS_NODE_TYPE_FCB 0x2296

Definition at line 85 of file btrfs_drv.h.

◆ BTRFS_VOLUME_PREFIX

#define BTRFS_VOLUME_PREFIX L"\\Device\\Btrfs{"

Definition at line 127 of file btrfs_drv.h.

◆ CC_ENABLE_DISK_IO_ACCOUNTING

#define CC_ENABLE_DISK_IO_ACCOUNTING 0x00000010

Definition at line 1845 of file btrfs_drv.h.

◆ COMPRESSED_EXTENT_SIZE

#define COMPRESSED_EXTENT_SIZE 0x20000

Definition at line 112 of file btrfs_drv.h.

◆ EA_CASE_SENSITIVE

#define EA_CASE_SENSITIVE "user.casesensitive"

Definition at line 105 of file btrfs_drv.h.

◆ EA_CASE_SENSITIVE_HASH

#define EA_CASE_SENSITIVE_HASH 0x1a9d97d4

Definition at line 106 of file btrfs_drv.h.

◆ EA_DOSATTRIB

#define EA_DOSATTRIB "user.DOSATTRIB"

Definition at line 96 of file btrfs_drv.h.

◆ EA_DOSATTRIB_HASH

#define EA_DOSATTRIB_HASH 0x914f9939

Definition at line 97 of file btrfs_drv.h.

◆ EA_EA

#define EA_EA "user.EA"

Definition at line 102 of file btrfs_drv.h.

◆ EA_EA_HASH

#define EA_EA_HASH 0x8270dd43

Definition at line 103 of file btrfs_drv.h.

◆ EA_NTACL

#define EA_NTACL "security.NTACL"

Definition at line 93 of file btrfs_drv.h.

◆ EA_NTACL_HASH

#define EA_NTACL_HASH 0x45922146

Definition at line 94 of file btrfs_drv.h.

◆ EA_PROP_COMPRESSION

#define EA_PROP_COMPRESSION "btrfs.compression"

Definition at line 108 of file btrfs_drv.h.

◆ EA_PROP_COMPRESSION_HASH

#define EA_PROP_COMPRESSION_HASH 0x20ccdf69

Definition at line 109 of file btrfs_drv.h.

◆ EA_REPARSE

#define EA_REPARSE "user.reparse"

Definition at line 99 of file btrfs_drv.h.

◆ EA_REPARSE_HASH

#define EA_REPARSE_HASH 0xfabad1fe

Definition at line 100 of file btrfs_drv.h.

◆ ERR

#define ERR	(	s,
		...
	)	DbgPrint("Btrfs ERR : %s : " s, funcname, ##__VA_ARGS__)

Definition at line 1234 of file btrfs_drv.h.

◆ except

#define except ( x ) if (0 && (x))

Definition at line 136 of file btrfs_drv.h.

◆ FILE_CS_FLAG_CASE_SENSITIVE_DIR

#define FILE_CS_FLAG_CASE_SENSITIVE_DIR 1

Definition at line 165 of file btrfs_drv.h.

◆ FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL

#define FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL 0x00020000

Definition at line 156 of file btrfs_drv.h.

◆ FILE_SUPPORTS_BLOCK_REFCOUNTING

#define FILE_SUPPORTS_BLOCK_REFCOUNTING 0x08000000

Definition at line 148 of file btrfs_drv.h.

◆ FILE_SUPPORTS_POSIX_UNLINK_RENAME

#define FILE_SUPPORTS_POSIX_UNLINK_RENAME 0x00000400

Definition at line 152 of file btrfs_drv.h.

◆ finally

#define finally if (1)

Definition at line 137 of file btrfs_drv.h.

◆ FIXME

#define FIXME	(	s,
		...
	)	DbgPrint("Btrfs FIXME : %s : " s, funcname, ##__VA_ARGS__)

Definition at line 1233 of file btrfs_drv.h.

◆ FSCTL_DUPLICATE_EXTENTS_TO_FILE

#define FSCTL_DUPLICATE_EXTENTS_TO_FILE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 209, METHOD_BUFFERED, FILE_WRITE_ACCESS)

Definition at line 182 of file btrfs_drv.h.

◆ FSCTL_GET_INTEGRITY_INFORMATION

#define FSCTL_GET_INTEGRITY_INFORMATION CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 159, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 198 of file btrfs_drv.h.

◆ FSCTL_SET_INTEGRITY_INFORMATION

#define FSCTL_SET_INTEGRITY_INFORMATION CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 160, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)

Definition at line 199 of file btrfs_drv.h.

◆ FSRTL_FCB_HEADER_V2

#define FSRTL_FCB_HEADER_V2 2

Definition at line 1655 of file btrfs_drv.h.

◆ funcname

#define funcname __func__

Definition at line 1176 of file btrfs_drv.h.

◆ GID_NOBODY

#define GID_NOBODY 65534

Definition at line 91 of file btrfs_drv.h.

◆ hex_digit

#define hex_digit ( c ) ((c) <= 9) ? ((c) + '0') : ((c) - 10 + 'a')

Definition at line 1748 of file btrfs_drv.h.

◆ increase_fileref_refcount

#define increase_fileref_refcount ( fileref ) InterlockedIncrement(&fileref->refcount)

Definition at line 1739 of file btrfs_drv.h.

◆ int3

#define int3 asm("int3;")

Definition at line 1745 of file btrfs_drv.h.

◆ InterlockedIncrement64

#define InterlockedIncrement64 ( a ) __sync_add_and_fetch(a, 1)

Definition at line 143 of file btrfs_drv.h.

◆ IO_REPARSE_TAG_AF_UNIX

#define IO_REPARSE_TAG_AF_UNIX 0x80000023

Definition at line 120 of file btrfs_drv.h.

◆ IO_REPARSE_TAG_LX_BLK

#define IO_REPARSE_TAG_LX_BLK 0x80000026

Definition at line 123 of file btrfs_drv.h.

◆ IO_REPARSE_TAG_LX_CHR

#define IO_REPARSE_TAG_LX_CHR 0x80000025

Definition at line 122 of file btrfs_drv.h.

◆ IO_REPARSE_TAG_LX_FIFO

#define IO_REPARSE_TAG_LX_FIFO 0x80000024

Definition at line 121 of file btrfs_drv.h.

◆ IO_REPARSE_TAG_LX_SYMLINK

#define IO_REPARSE_TAG_LX_SYMLINK 0xa000001d

Definition at line 118 of file btrfs_drv.h.

◆ keycmp

#define keycmp	(	key1,
		key2
	)

Value:

    ((key1.obj_id < key2.obj_id) ? -1 :\
    ((key1.obj_id > key2.obj_id) ? 1 :\
    ((key1.obj_type < key2.obj_type) ? -1 :\
    ((key1.obj_type > key2.obj_type) ? 1 :\
    ((key1.offset < key2.offset) ? -1 :\
    ((key1.offset > key2.offset) ? 1 :\
    0))))))

Definition at line 1016 of file btrfs_drv.h.

◆ leave

#define leave

Definition at line 138 of file btrfs_drv.h.

◆ major

#define major ( rdev ) ((((rdev) >> 8) & 0xFFF) | ((uint32_t)((rdev) >> 32) & ~0xFFF))

Definition at line 1821 of file btrfs_drv.h.

◆ makedev

#define makedev	(	major,
		minor
	)	(((minor) & 0xFF) \| (((major) & 0xFFF) << 8) \| (((uint64_t)((minor) & ~0xFF)) << 12) \| (((uint64_t)((major) & ~0xFFF)) << 32))

Definition at line 1637 of file btrfs_drv.h.

◆ MAX_EXTENT_SIZE

#define MAX_EXTENT_SIZE 0x8000000

Definition at line 111 of file btrfs_drv.h.

◆ MAX_HASH_SIZE

#define MAX_HASH_SIZE 32

Definition at line 213 of file btrfs_drv.h.

◆ minor

#define minor ( rdev ) (((rdev) & 0xFF) | ((uint32_t)((rdev) >> 12) & ~0xFF))

Definition at line 1822 of file btrfs_drv.h.

◆ NTDDI_VERSION

#define NTDDI_VERSION 0x06020000

Definition at line 25 of file btrfs_drv.h.

◆ READ_AHEAD_GRANULARITY

#define READ_AHEAD_GRANULARITY COMPRESSED_EXTENT_SIZE

Definition at line 114 of file btrfs_drv.h.

◆ release_chunk_lock

#define release_chunk_lock	(	c,
		Vcb
	)	ExReleaseResourceLite(&(c)->lock)

Definition at line 1140 of file btrfs_drv.h.

◆ S_IRGRP

#define S_IRGRP (S_IRUSR >> 3)

Definition at line 1785 of file btrfs_drv.h.

◆ S_IROTH

#define S_IROTH (S_IRGRP >> 3)

Definition at line 1797 of file btrfs_drv.h.

◆ S_IRUSR

#define S_IRUSR 0000400

Definition at line 1768 of file btrfs_drv.h.

◆ S_ISDIR

#define S_ISDIR ( mode ) __S_ISTYPE((mode), __S_IFDIR)

Definition at line 1764 of file btrfs_drv.h.

◆ S_ISGID

#define S_ISGID 0002000

Definition at line 1813 of file btrfs_drv.h.

◆ S_ISUID

#define S_ISUID 0004000

Definition at line 1809 of file btrfs_drv.h.

◆ S_ISVTX

#define S_ISVTX 0001000

Definition at line 1817 of file btrfs_drv.h.

◆ S_IWGRP

#define S_IWGRP (S_IWUSR >> 3)

Definition at line 1789 of file btrfs_drv.h.

◆ S_IWOTH

#define S_IWOTH (S_IWGRP >> 3)

Definition at line 1801 of file btrfs_drv.h.

◆ S_IWUSR

#define S_IWUSR 0000200

Definition at line 1772 of file btrfs_drv.h.

◆ S_IXGRP

#define S_IXGRP (S_IXUSR >> 3)

Definition at line 1793 of file btrfs_drv.h.

◆ S_IXOTH

#define S_IXOTH (S_IXGRP >> 3)

Definition at line 1805 of file btrfs_drv.h.

◆ S_IXUSR

#define S_IXUSR 0000100

Definition at line 1776 of file btrfs_drv.h.

◆ SHA256_HASH_SIZE

#define SHA256_HASH_SIZE 32

Definition at line 1248 of file btrfs_drv.h.

◆ TRACE

#define TRACE	(	s,
		...
	)	do { } while(0)

Definition at line 1231 of file btrfs_drv.h.

◆ try

#define try if (1)

Definition at line 135 of file btrfs_drv.h.

◆ UID_NOBODY

#define UID_NOBODY 65534

Definition at line 90 of file btrfs_drv.h.

◆ UNUSED

#define UNUSED ( x ) (void)(x)

Definition at line 82 of file btrfs_drv.h.

◆ VCB_TYPE_BUS

#define VCB_TYPE_BUS 5

Definition at line 691 of file btrfs_drv.h.

◆ VCB_TYPE_CONTROL

#define VCB_TYPE_CONTROL 2

Definition at line 688 of file btrfs_drv.h.

◆ VCB_TYPE_FS

#define VCB_TYPE_FS 1

Definition at line 687 of file btrfs_drv.h.

◆ VCB_TYPE_PDO

#define VCB_TYPE_PDO 4

Definition at line 690 of file btrfs_drv.h.

◆ VCB_TYPE_VOLUME

#define VCB_TYPE_VOLUME 3

Definition at line 689 of file btrfs_drv.h.

◆ WARN

#define WARN	(	s,
		...
	)	do { } while(0)

Definition at line 1232 of file btrfs_drv.h.

Typedef Documentation

◆ ccb

typedef struct _ccb ccb

◆ device_extension

typedef struct _device_extension device_extension

◆ DUPLICATE_EXTENTS_DATA

typedef struct _DUPLICATE_EXTENTS_DATA DUPLICATE_EXTENTS_DATA

◆ fcb

_In_ fcb * fcb

Definition at line 1364 of file btrfs_drv.h.

◆ fcb_nonpaged

typedef struct _fcb_nonpaged fcb_nonpaged

◆ FILE_ID_128

typedef struct _FILE_ID_128 FILE_ID_128

◆ file_ref

typedef struct _file_ref file_ref

◆ FSCTL_GET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER FSCTL_GET_INTEGRITY_INFORMATION_BUFFER

◆ FSCTL_SET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER FSCTL_SET_INTEGRITY_INFORMATION_BUFFER

◆ LDR_DATA_TABLE_ENTRY

typedef struct _LDR_DATA_TABLE_ENTRY LDR_DATA_TABLE_ENTRY

◆ pdo_device_extension

typedef struct pdo_device_extension pdo_device_extension

◆ PDUPLICATE_EXTENTS_DATA

typedef struct _DUPLICATE_EXTENTS_DATA * PDUPLICATE_EXTENTS_DATA

◆ PEB

typedef struct _PEB PEB

◆ PEB_LDR_DATA

typedef struct _PEB_LDR_DATA PEB_LDR_DATA

◆ PFILE_ID_128

typedef struct _FILE_ID_128 * PFILE_ID_128

◆ PFSCTL_GET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER * PFSCTL_GET_INTEGRITY_INFORMATION_BUFFER

◆ PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER * PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER

◆ PLDR_DATA_TABLE_ENTRY

typedef struct _LDR_DATA_TABLE_ENTRY* PLDR_DATA_TABLE_ENTRY

◆ PPEB

typedef struct _PEB* PPEB

◆ PPEB_LDR_DATA

typedef struct _PEB_LDR_DATA* PPEB_LDR_DATA

◆ PPS_POST_PROCESS_INIT_ROUTINE

typedef VOID(NTAPI * PPS_POST_PROCESS_INIT_ROUTINE) (VOID)

Definition at line 1905 of file btrfs_drv.h.

◆ PRTL_USER_PROCESS_PARAMETERS

typedef struct _RTL_USER_PROCESS_PARAMETERS* PRTL_USER_PROCESS_PARAMETERS

◆ root

typedef struct _root root

◆ root_cache

typedef struct _root_cache root_cache

◆ RTL_USER_PROCESS_PARAMETERS

typedef struct _RTL_USER_PROCESS_PARAMETERS RTL_USER_PROCESS_PARAMETERS

◆ tCcCopyReadEx

typedef BOOLEAN(__stdcall * tCcCopyReadEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PETHREAD IoIssuerThread)

Definition at line 1841 of file btrfs_drv.h.

◆ tCcCopyWriteEx

typedef BOOLEAN(__stdcall * tCcCopyWriteEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PETHREAD IoIssuerThread)

Definition at line 1838 of file btrfs_drv.h.

◆ tCcSetAdditionalCacheAttributesEx

typedef VOID(__stdcall * tCcSetAdditionalCacheAttributesEx) (PFILE_OBJECT FileObject, ULONG Flags)

Definition at line 1853 of file btrfs_drv.h.

◆ tFsRtlAreThereCurrentOrInProgressFileLocks

typedef BOOLEAN(__stdcall * tFsRtlAreThereCurrentOrInProgressFileLocks) (PFILE_LOCK FileLock)

Definition at line 1868 of file btrfs_drv.h.

◆ tFsRtlCheckLockForOplockRequest

typedef BOOLEAN(__stdcall * tFsRtlCheckLockForOplockRequest) (PFILE_LOCK FileLock, PLARGE_INTEGER AllocationSize)

Definition at line 1866 of file btrfs_drv.h.

◆ tFsRtlGetEcpListFromIrp

typedef NTSTATUS(__stdcall * tFsRtlGetEcpListFromIrp) (PIRP Irp, PECP_LIST *EcpList)

Definition at line 1859 of file btrfs_drv.h.

◆ tFsRtlGetNextExtraCreateParameter

typedef NTSTATUS(__stdcall * tFsRtlGetNextExtraCreateParameter) (PECP_LIST EcpList, PVOID CurrentEcpContext, LPGUID NextEcpType, PVOID *NextEcpContext, ULONG *NextEcpContextSize)

Definition at line 1861 of file btrfs_drv.h.

◆ tFsRtlUpdateDiskCounters

typedef VOID(__stdcall * tFsRtlUpdateDiskCounters) (ULONG64 BytesRead, ULONG64 BytesWritten)

Definition at line 1855 of file btrfs_drv.h.

◆ tFsRtlValidateReparsePointBuffer

typedef NTSTATUS(__stdcall * tFsRtlValidateReparsePointBuffer) (ULONG BufferLength, PREPARSE_DATA_BUFFER ReparseBuffer)

Definition at line 1864 of file btrfs_drv.h.

◆ tIoUnregisterPlugPlayNotificationEx

typedef NTSTATUS(__stdcall * tIoUnregisterPlugPlayNotificationEx) (PVOID NotificationEntry)

Definition at line 1857 of file btrfs_drv.h.

◆ tPsIsDiskCountersEnabled

typedef BOOLEAN(__stdcall * tPsIsDiskCountersEnabled) ()

Definition at line 1833 of file btrfs_drv.h.

◆ tPsUpdateDiskCounters

typedef VOID(__stdcall * tPsUpdateDiskCounters) (PEPROCESS Process, ULONG64 BytesRead, ULONG64 BytesWritten, ULONG ReadOperationCount, ULONG WriteOperationCount, ULONG FlushOperationCount)

Definition at line 1835 of file btrfs_drv.h.

◆ tree

typedef struct _tree tree

◆ tree_data

typedef struct _tree_data tree_data

◆ volume_device_extension

typedef struct _volume_device_extension volume_device_extension

◆ write_data_context

typedef struct _write_data_context write_data_context

◆ xor_func

typedef void(__stdcall * xor_func) (uint8_t *buf1, uint8_t *buf2, uint32_t len)

Definition at line 1131 of file btrfs_drv.h.

Enumeration Type Documentation

◆ batch_operation

enum batch_operation

Enumerator
Batch_Delete
Batch_DeleteInode
Batch_DeleteDirItem
Batch_DeleteInodeRef
Batch_DeleteInodeExtRef
Batch_DeleteXattr
Batch_DeleteExtentData
Batch_DeleteFreeSpace
Batch_Insert
Batch_SetXattr
Batch_DirItem
Batch_InodeRef
Batch_InodeExtRef

Definition at line 470 of file btrfs_drv.h.

                     {
    Batch_Delete,
    Batch_DeleteInode,
    Batch_DeleteDirItem,
    Batch_DeleteInodeRef,
    Batch_DeleteInodeExtRef,
    Batch_DeleteXattr,
    Batch_DeleteExtentData,
    Batch_DeleteFreeSpace,
    Batch_Insert,
    Batch_SetXattr,
    Batch_DirItem,
    Batch_InodeRef,
    Batch_InodeExtRef,
};

◆ calc_thread_type

enum calc_thread_type

Enumerator
calc_thread_crc32c
calc_thread_xxhash
calc_thread_sha256
calc_thread_blake2
calc_thread_decomp_zlib
calc_thread_decomp_lzo
calc_thread_decomp_zstd
calc_thread_comp_zlib
calc_thread_comp_lzo
calc_thread_comp_zstd

Definition at line 627 of file btrfs_drv.h.

                      {
    calc_thread_crc32c,
    calc_thread_xxhash,
    calc_thread_sha256,
    calc_thread_blake2,
    calc_thread_decomp_zlib,
    calc_thread_decomp_lzo,
    calc_thread_decomp_zstd,
    calc_thread_comp_zlib,
    calc_thread_comp_lzo,
    calc_thread_comp_zstd,
};

◆ prop_compression_type

enum prop_compression_type

Enumerator
PropCompression_None
PropCompression_Zlib
PropCompression_LZO
PropCompression_ZSTD

Definition at line 267 of file btrfs_drv.h.

                           {
    PropCompression_None,
    PropCompression_Zlib,
    PropCompression_LZO,
    PropCompression_ZSTD
};

◆ rollback_type

enum rollback_type

Enumerator
ROLLBACK_INSERT_EXTENT
ROLLBACK_DELETE_EXTENT
ROLLBACK_ADD_SPACE
ROLLBACK_SUBTRACT_SPACE

Definition at line 1267 of file btrfs_drv.h.

                   {
    ROLLBACK_INSERT_EXTENT,
    ROLLBACK_DELETE_EXTENT,
    ROLLBACK_ADD_SPACE,
    ROLLBACK_SUBTRACT_SPACE
};

◆ write_data_status

enum write_data_status

Enumerator
WriteDataStatus_Pending
WriteDataStatus_Success
WriteDataStatus_Error
WriteDataStatus_Cancelling
WriteDataStatus_Cancelled
WriteDataStatus_Ignore

Definition at line 914 of file btrfs_drv.h.

                       {
    WriteDataStatus_Pending,
    WriteDataStatus_Success,
    WriteDataStatus_Error,
    WriteDataStatus_Cancelling,
    WriteDataStatus_Cancelled,
    WriteDataStatus_Ignore
};

Function Documentation

◆ attribute() [1/2]

IN PIRP Irp __attribute__ ( (nonnull(1, 2)) )

Definition at line 2730 of file read.c.

                                                                                        {
    ULONG readlen;
 
    TRACE("(%p, %p, %I64x, %lx, %p)\n", fcb, data, start, length, pbr);
 
    if (pbr) *pbr = 0;
 
    if (start >= fcb->adsdata.Length) {
        TRACE("tried to read beyond end of stream\n");
        return STATUS_END_OF_FILE;
    }
 
    if (length == 0) {
        WARN("tried to read zero bytes\n");
        return STATUS_SUCCESS;
    }
 
    if (start + length < fcb->adsdata.Length)
        readlen = length;
    else
        readlen = fcb->adsdata.Length - (ULONG)start;
 
    if (readlen > 0)
        RtlCopyMemory(data, fcb->adsdata.Buffer + start, readlen);
 
    if (pbr) *pbr = readlen;
 
    return STATUS_SUCCESS;
}

◆ attribute() [2/2]

_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t _In_ bool _In_ uint64_t irp_offset __attribute__ ( (nonnull(1, 2, 3, 9)) )

◆ _Create_lock_level_()

_Create_lock_level_ ( tree_lock )

◆ _Dispatch_type_() [1/12]

_Dispatch_type_ ( IRP_MJ_CREATE )

Definition at line 297 of file isapnp.c.

{
    PAGED_CODE();
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
    DPRINT("%s(%p, %p)\n", __FUNCTION__, DeviceObject, Irp);
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

◆ _Dispatch_type_() [2/12]

_Dispatch_type_ ( IRP_MJ_DEVICE_CONTROL )

Definition at line 1385 of file isapnp.c.

{
    PISAPNP_COMMON_EXTENSION CommonExt = DeviceObject->DeviceExtension;
 
    PAGED_CODE();
 
    DPRINT("%s(%p, %p) Minor - %X\n", __FUNCTION__, DeviceObject, Irp,
           IoGetCurrentIrpStackLocation(Irp)->MinorFunction);
 
    if (CommonExt->Signature == IsaPnpBus)
    {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(((PISAPNP_FDO_EXTENSION)CommonExt)->Ldo, Irp);
    }
    else
    {
        NTSTATUS Status = Irp->IoStatus.Status;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
}

◆ _Dispatch_type_() [3/12]

NTSTATUS bool void NTSTATUS void _Dispatch_type_ ( IRP_MJ_DIRECTORY_CONTROL )

◆ _Dispatch_type_() [4/12]

_Dispatch_type_ ( IRP_MJ_PNP )

Definition at line 377 of file isapnp.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PISAPNP_COMMON_EXTENSION DevExt = DeviceObject->DeviceExtension;
 
    PAGED_CODE();
 
    if (DevExt->Signature == IsaPnpBus)
        return IsaFdoPnp((PISAPNP_FDO_EXTENSION)DevExt, Irp, IrpSp);
    else
        return IsaPdoPnp((PISAPNP_PDO_EXTENSION)DevExt, Irp, IrpSp);
}

◆ _Dispatch_type_() [5/12]

_Dispatch_type_ ( IRP_MJ_QUERY_EA )

◆ _Dispatch_type_() [6/12]

_Dispatch_type_ ( IRP_MJ_QUERY_INFORMATION )

◆ _Dispatch_type_() [7/12]

_Dispatch_type_ ( IRP_MJ_QUERY_SECURITY )

◆ _Dispatch_type_() [8/12]

_Dispatch_type_ ( IRP_MJ_READ )

◆ _Dispatch_type_() [9/12]

_Dispatch_type_ ( IRP_MJ_SET_EA )

◆ _Dispatch_type_() [10/12]

_Dispatch_type_ ( IRP_MJ_SET_INFORMATION )

◆ _Dispatch_type_() [11/12]

_Dispatch_type_ ( IRP_MJ_SET_SECURITY )

◆ _Dispatch_type_() [12/12]

_Dispatch_type_ ( IRP_MJ_WRITE )

◆ _Function_class_() [1/3]

_Function_class_ ( DRIVER_ADD_DEVICE )

◆ _Function_class_() [2/3]

_Function_class_ ( DRIVER_NOTIFICATION_CALLBACK_ROUTINE )

◆ _Function_class_() [3/3]

_Function_class_ ( KSTART_ROUTINE )

Definition at line 3047 of file balance.c.

                                             {
    device_extension* Vcb = (device_extension*)context;
    LIST_ENTRY chunks;
    LIST_ENTRY* le;
    uint64_t num_chunks[3], okay_metadata_chunks = 0, okay_data_chunks = 0, okay_system_chunks = 0;
    uint64_t old_data_flags = 0, old_metadata_flags = 0, old_system_flags = 0;
    NTSTATUS Status;
 
    Vcb->balance.balance_num++;
 
    Vcb->balance.stopping = false;
    KeInitializeEvent(&Vcb->balance.finished, NotificationEvent, false);
 
    if (Vcb->balance.opts[BALANCE_OPTS_DATA].flags & BTRFS_BALANCE_OPTS_ENABLED && Vcb->balance.opts[BALANCE_OPTS_DATA].flags & BTRFS_BALANCE_OPTS_CONVERT) {
        old_data_flags = Vcb->data_flags;
        Vcb->data_flags = BLOCK_FLAG_DATA | (Vcb->balance.opts[BALANCE_OPTS_DATA].convert == BLOCK_FLAG_SINGLE ? 0 : Vcb->balance.opts[BALANCE_OPTS_DATA].convert);
 
        FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_CHANGE_SIZE);
    }
 
    if (Vcb->balance.opts[BALANCE_OPTS_METADATA].flags & BTRFS_BALANCE_OPTS_ENABLED && Vcb->balance.opts[BALANCE_OPTS_METADATA].flags & BTRFS_BALANCE_OPTS_CONVERT) {
        old_metadata_flags = Vcb->metadata_flags;
        Vcb->metadata_flags = BLOCK_FLAG_METADATA | (Vcb->balance.opts[BALANCE_OPTS_METADATA].convert == BLOCK_FLAG_SINGLE ? 0 : Vcb->balance.opts[BALANCE_OPTS_METADATA].convert);
    }
 
    if (Vcb->balance.opts[BALANCE_OPTS_SYSTEM].flags & BTRFS_BALANCE_OPTS_ENABLED && Vcb->balance.opts[BALANCE_OPTS_SYSTEM].flags & BTRFS_BALANCE_OPTS_CONVERT) {
        old_system_flags = Vcb->system_flags;
        Vcb->system_flags = BLOCK_FLAG_SYSTEM | (Vcb->balance.opts[BALANCE_OPTS_SYSTEM].convert == BLOCK_FLAG_SINGLE ? 0 : Vcb->balance.opts[BALANCE_OPTS_SYSTEM].convert);
    }
 
    if (Vcb->superblock.incompat_flags & BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS) {
        if (Vcb->balance.opts[BALANCE_OPTS_DATA].flags & BTRFS_BALANCE_OPTS_ENABLED)
            RtlCopyMemory(&Vcb->balance.opts[BALANCE_OPTS_METADATA], &Vcb->balance.opts[BALANCE_OPTS_DATA], sizeof(btrfs_balance_opts));
        else if (Vcb->balance.opts[BALANCE_OPTS_METADATA].flags & BTRFS_BALANCE_OPTS_ENABLED)
            RtlCopyMemory(&Vcb->balance.opts[BALANCE_OPTS_DATA], &Vcb->balance.opts[BALANCE_OPTS_METADATA], sizeof(btrfs_balance_opts));
    }
 
    num_chunks[0] = num_chunks[1] = num_chunks[2] = 0;
    Vcb->balance.total_chunks = Vcb->balance.chunks_left = 0;
 
    InitializeListHead(&chunks);
 
    // FIXME - what are we supposed to do with limit_start?
 
    if (!Vcb->readonly) {
        if (!Vcb->balance.removing && !Vcb->balance.shrinking) {
            Status = add_balance_item(Vcb);
            if (!NT_SUCCESS(Status)) {
                ERR("add_balance_item returned %08lx\n", Status);
                Vcb->balance.status = Status;
                goto end;
            }
        } else {
            if (Vcb->need_write) {
                Status = do_write(Vcb, NULL);
 
                free_trees(Vcb);
 
                if (!NT_SUCCESS(Status)) {
                    ERR("do_write returned %08lx\n", Status);
                    Vcb->balance.status = Status;
                    goto end;
                }
            }
        }
    }
 
    KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, false, NULL);
 
    if (Vcb->balance.stopping)
        goto end;
 
    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
    le = Vcb->chunks.Flink;
    while (le != &Vcb->chunks) {
        chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
        uint8_t sort;
 
        acquire_chunk_lock(c, Vcb);
 
        if (c->chunk_item->type & BLOCK_FLAG_DATA)
            sort = BALANCE_OPTS_DATA;
        else if (c->chunk_item->type & BLOCK_FLAG_METADATA)
            sort = BALANCE_OPTS_METADATA;
        else if (c->chunk_item->type & BLOCK_FLAG_SYSTEM)
            sort = BALANCE_OPTS_SYSTEM;
        else {
            ERR("unexpected chunk type %I64x\n", c->chunk_item->type);
            release_chunk_lock(c, Vcb);
            break;
        }
 
        if ((!(Vcb->balance.opts[sort].flags & BTRFS_BALANCE_OPTS_LIMIT) || num_chunks[sort] < Vcb->balance.opts[sort].limit_end) &&
            should_balance_chunk(Vcb, sort, c)) {
            InsertTailList(&chunks, &c->list_entry_balance);
 
            num_chunks[sort]++;
            Vcb->balance.total_chunks++;
            Vcb->balance.chunks_left++;
        } else if (sort == BALANCE_OPTS_METADATA)
            okay_metadata_chunks++;
        else if (sort == BALANCE_OPTS_DATA)
            okay_data_chunks++;
        else if (sort == BALANCE_OPTS_SYSTEM)
            okay_system_chunks++;
 
        if (!c->cache_loaded) {
            Status = load_cache_chunk(Vcb, c, NULL);
 
            if (!NT_SUCCESS(Status)) {
                ERR("load_cache_chunk returned %08lx\n", Status);
                Vcb->balance.status = Status;
                release_chunk_lock(c, Vcb);
                ExReleaseResourceLite(&Vcb->chunk_lock);
                goto end;
            }
        }
 
        release_chunk_lock(c, Vcb);
 
        le = le->Flink;
    }
 
    ExReleaseResourceLite(&Vcb->chunk_lock);
 
    // If we're doing a full balance, try and allocate a new chunk now, before we mess things up
    if (okay_metadata_chunks == 0 || okay_data_chunks == 0 || okay_system_chunks == 0) {
        bool consolidated = false;
        chunk* c;
 
        if (okay_metadata_chunks == 0) {
            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
            Status = alloc_chunk(Vcb, Vcb->metadata_flags, &c, true);
            if (NT_SUCCESS(Status))
                c->balance_num = Vcb->balance.balance_num;
            else if (Status != STATUS_DISK_FULL || consolidated) {
                ERR("alloc_chunk returned %08lx\n", Status);
                ExReleaseResourceLite(&Vcb->chunk_lock);
                Vcb->balance.status = Status;
                goto end;
            }
 
            ExReleaseResourceLite(&Vcb->chunk_lock);
 
            if (Status == STATUS_DISK_FULL) {
                Status = try_consolidation(Vcb, Vcb->metadata_flags, &c);
                if (!NT_SUCCESS(Status)) {
                    ERR("try_consolidation returned %08lx\n", Status);
                    Vcb->balance.status = Status;
                    goto end;
                } else
                    c->balance_num = Vcb->balance.balance_num;
 
                consolidated = true;
 
                if (Vcb->balance.stopping)
                    goto end;
            }
        }
 
        if (okay_data_chunks == 0) {
            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
            Status = alloc_chunk(Vcb, Vcb->data_flags, &c, true);
            if (NT_SUCCESS(Status))
                c->balance_num = Vcb->balance.balance_num;
            else if (Status != STATUS_DISK_FULL || consolidated) {
                ERR("alloc_chunk returned %08lx\n", Status);
                ExReleaseResourceLite(&Vcb->chunk_lock);
                Vcb->balance.status = Status;
                goto end;
            }
 
            ExReleaseResourceLite(&Vcb->chunk_lock);
 
            if (Status == STATUS_DISK_FULL) {
                Status = try_consolidation(Vcb, Vcb->data_flags, &c);
                if (!NT_SUCCESS(Status)) {
                    ERR("try_consolidation returned %08lx\n", Status);
                    Vcb->balance.status = Status;
                    goto end;
                } else
                    c->balance_num = Vcb->balance.balance_num;
 
                consolidated = true;
 
                if (Vcb->balance.stopping)
                    goto end;
            }
        }
 
        if (okay_system_chunks == 0) {
            ExAcquireResourceExclusiveLite(&Vcb->chunk_lock, true);
 
            Status = alloc_chunk(Vcb, Vcb->system_flags, &c, true);
            if (NT_SUCCESS(Status))
                c->balance_num = Vcb->balance.balance_num;
            else if (Status != STATUS_DISK_FULL || consolidated) {
                ERR("alloc_chunk returned %08lx\n", Status);
                ExReleaseResourceLite(&Vcb->chunk_lock);
                Vcb->balance.status = Status;
                goto end;
            }
 
            ExReleaseResourceLite(&Vcb->chunk_lock);
 
            if (Status == STATUS_DISK_FULL) {
                Status = try_consolidation(Vcb, Vcb->system_flags, &c);
                if (!NT_SUCCESS(Status)) {
                    ERR("try_consolidation returned %08lx\n", Status);
                    Vcb->balance.status = Status;
                    goto end;
                } else
                    c->balance_num = Vcb->balance.balance_num;
 
                consolidated = true;
 
                if (Vcb->balance.stopping)
                    goto end;
            }
        }
    }
 
    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
    le = chunks.Flink;
    while (le != &chunks) {
        chunk* c = CONTAINING_RECORD(le, chunk, list_entry_balance);
 
        c->reloc = true;
 
        le = le->Flink;
    }
 
    ExReleaseResourceLite(&Vcb->chunk_lock);
 
    // do data chunks before metadata
    le = chunks.Flink;
    while (le != &chunks) {
        chunk* c = CONTAINING_RECORD(le, chunk, list_entry_balance);
        LIST_ENTRY* le2 = le->Flink;
 
        if (c->chunk_item->type & BLOCK_FLAG_DATA) {
            bool changed;
 
            do {
                changed = false;
 
                Status = balance_data_chunk(Vcb, c, &changed);
                if (!NT_SUCCESS(Status)) {
                    ERR("balance_data_chunk returned %08lx\n", Status);
                    Vcb->balance.status = Status;
                    goto end;
                }
 
                KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, false, NULL);
 
                if (Vcb->readonly)
                    Vcb->balance.stopping = true;
 
                if (Vcb->balance.stopping)
                    break;
            } while (changed);
 
            c->changed = true;
            c->space_changed = true;
        }
 
        if (Vcb->balance.stopping)
            goto end;
 
        if (c->chunk_item->type & BLOCK_FLAG_DATA &&
            (!(Vcb->balance.opts[BALANCE_OPTS_METADATA].flags & BTRFS_BALANCE_OPTS_ENABLED) || !(c->chunk_item->type & BLOCK_FLAG_METADATA))) {
            RemoveEntryList(&c->list_entry_balance);
            c->list_entry_balance.Flink = NULL;
 
            Vcb->balance.chunks_left--;
        }
 
        le = le2;
    }
 
    // do metadata chunks
    while (!IsListEmpty(&chunks)) {
        chunk* c;
        bool changed;
 
        le = RemoveHeadList(&chunks);
        c = CONTAINING_RECORD(le, chunk, list_entry_balance);
 
        if (c->chunk_item->type & BLOCK_FLAG_METADATA || c->chunk_item->type & BLOCK_FLAG_SYSTEM) {
            do {
                Status = balance_metadata_chunk(Vcb, c, &changed);
                if (!NT_SUCCESS(Status)) {
                    ERR("balance_metadata_chunk returned %08lx\n", Status);
                    Vcb->balance.status = Status;
                    goto end;
                }
 
                KeWaitForSingleObject(&Vcb->balance.event, Executive, KernelMode, false, NULL);
 
                if (Vcb->readonly)
                    Vcb->balance.stopping = true;
 
                if (Vcb->balance.stopping)
                    break;
            } while (changed);
 
            c->changed = true;
            c->space_changed = true;
        }
 
        if (Vcb->balance.stopping)
            break;
 
        c->list_entry_balance.Flink = NULL;
 
        Vcb->balance.chunks_left--;
    }
 
end:
    if (!Vcb->readonly) {
        if (Vcb->balance.stopping || !NT_SUCCESS(Vcb->balance.status)) {
            le = chunks.Flink;
            while (le != &chunks) {
                chunk* c = CONTAINING_RECORD(le, chunk, list_entry_balance);
                c->reloc = false;
 
                le = le->Flink;
                c->list_entry_balance.Flink = NULL;
            }
 
            if (old_data_flags != 0)
                Vcb->data_flags = old_data_flags;
 
            if (old_metadata_flags != 0)
                Vcb->metadata_flags = old_metadata_flags;
 
            if (old_system_flags != 0)
                Vcb->system_flags = old_system_flags;
        }
 
        if (Vcb->balance.removing) {
            device* dev = NULL;
 
            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
            le = Vcb->devices.Flink;
            while (le != &Vcb->devices) {
                device* dev2 = CONTAINING_RECORD(le, device, list_entry);
 
                if (dev2->devitem.dev_id == Vcb->balance.opts[0].devid) {
                    dev = dev2;
                    break;
                }
 
                le = le->Flink;
            }
 
            if (dev) {
                if (Vcb->balance.chunks_left == 0) {
                    Status = finish_removing_device(Vcb, dev);
 
                    if (!NT_SUCCESS(Status)) {
                        ERR("finish_removing_device returned %08lx\n", Status);
                        dev->reloc = false;
                    }
                } else
                    dev->reloc = false;
            }
 
            ExReleaseResourceLite(&Vcb->tree_lock);
        } else if (Vcb->balance.shrinking) {
            device* dev = NULL;
 
            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
            le = Vcb->devices.Flink;
            while (le != &Vcb->devices) {
                device* dev2 = CONTAINING_RECORD(le, device, list_entry);
 
                if (dev2->devitem.dev_id == Vcb->balance.opts[0].devid) {
                    dev = dev2;
                    break;
                }
 
                le = le->Flink;
            }
 
            if (!dev) {
                ERR("could not find device %I64x\n", Vcb->balance.opts[0].devid);
                Vcb->balance.status = STATUS_INTERNAL_ERROR;
            }
 
            if (Vcb->balance.stopping || !NT_SUCCESS(Vcb->balance.status)) {
                if (dev) {
                    Status = regenerate_space_list(Vcb, dev);
                    if (!NT_SUCCESS(Status))
                        WARN("regenerate_space_list returned %08lx\n", Status);
                }
            } else {
                uint64_t old_size;
 
                old_size = dev->devitem.num_bytes;
                dev->devitem.num_bytes = Vcb->balance.opts[0].drange_start;
 
                Status = update_dev_item(Vcb, dev, NULL);
                if (!NT_SUCCESS(Status)) {
                    ERR("update_dev_item returned %08lx\n", Status);
                    dev->devitem.num_bytes = old_size;
                    Vcb->balance.status = Status;
 
                    Status = regenerate_space_list(Vcb, dev);
                    if (!NT_SUCCESS(Status))
                        WARN("regenerate_space_list returned %08lx\n", Status);
                } else {
                    Vcb->superblock.total_bytes -= old_size - dev->devitem.num_bytes;
 
                    Status = do_write(Vcb, NULL);
                    if (!NT_SUCCESS(Status))
                        ERR("do_write returned %08lx\n", Status);
 
                    free_trees(Vcb);
                }
            }
 
            ExReleaseResourceLite(&Vcb->tree_lock);
 
            if (!Vcb->balance.stopping && NT_SUCCESS(Vcb->balance.status))
                FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_CHANGE_SIZE);
        } else {
            Status = remove_balance_item(Vcb);
            if (!NT_SUCCESS(Status)) {
                ERR("remove_balance_item returned %08lx\n", Status);
                goto end;
            }
        }
 
        if (Vcb->trim && !Vcb->options.no_trim) {
            ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
            le = Vcb->devices.Flink;
            while (le != &Vcb->devices) {
                device* dev2 = CONTAINING_RECORD(le, device, list_entry);
 
                if (dev2->devobj && !dev2->readonly && dev2->trim)
                    trim_unalloc_space(Vcb, dev2);
 
                le = le->Flink;
            }
 
            ExReleaseResourceLite(&Vcb->tree_lock);
        }
    }
 
    ZwClose(Vcb->balance.thread);
    Vcb->balance.thread = NULL;
 
    KeSetEvent(&Vcb->balance.finished, 0, false);
}

◆ _Post_satisfies_()

_Post_satisfies_ ( return >= n )

◆ _Releases_lock_()

_Releases_lock_ ( c-> lock )

◆ _Requires_lock_held_() [1/2]

_Requires_lock_held_ ( c-> lock )

pure virtual

◆ _Requires_lock_held_() [2/2]

_Requires_lock_held_ ( Vcb-> fcb_lock ) -> fcb_lock) static __inline void release_fcb_lock(device_extension* Vcb)

Definition at line 971 of file btrfs_drv.h.

                                                             {
    ExReleaseResourceLite(&Vcb->fcb_lock);
}

◆ _Requires_lock_not_held_()

_Requires_lock_not_held_ ( Vcb-> fcb_lock ) -> fcb_lock) static __inline void acquire_fcb_lock_shared(device_extension* Vcb)

Definition at line 959 of file btrfs_drv.h.

                                                                    {
    ExAcquireResourceSharedLite(&Vcb->fcb_lock, true);
}

◆ _Success_()

_Success_ ( return )

◆ add_calc_job_comp()

NTSTATUS add_calc_job_comp	(	device_extension *	Vcb,
		uint8_t	compression,
		void *	in,
		unsigned int	inlen,
		void *	out,
		unsigned int	outlen,
		calc_job **	pcj
	)

Definition at line 237 of file calcthread.c.

                                                                           {
    calc_job* cj;
    KIRQL irql;
 
    cj = ExAllocatePoolWithTag(NonPagedPool, sizeof(calc_job), ALLOC_TAG);
    if (!cj) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    cj->in = in;
    cj->inlen = inlen;
    cj->out = out;
    cj->outlen = outlen;
    cj->left = cj->not_started = 1;
    cj->Status = STATUS_SUCCESS;
 
    switch (compression) {
        case BTRFS_COMPRESSION_ZLIB:
            cj->type = calc_thread_comp_zlib;
        break;
 
        case BTRFS_COMPRESSION_LZO:
            cj->type = calc_thread_comp_lzo;
        break;
 
        case BTRFS_COMPRESSION_ZSTD:
            cj->type = calc_thread_comp_zstd;
        break;
 
        default:
            ERR("unexpected compression type %x\n", compression);
            ExFreePool(cj);
        return STATUS_NOT_SUPPORTED;
    }
 
    KeInitializeEvent(&cj->event, NotificationEvent, false);
 
    KeAcquireSpinLock(&Vcb->calcthreads.spinlock, &irql);
 
    InsertTailList(&Vcb->calcthreads.job_list, &cj->list_entry);
 
    KeSetEvent(&Vcb->calcthreads.event, 0, false);
    KeClearEvent(&Vcb->calcthreads.event);
 
    KeReleaseSpinLock(&Vcb->calcthreads.spinlock, irql);
 
    *pcj = cj;
 
    return STATUS_SUCCESS;
}

Referenced by write_compressed().

◆ add_calc_job_decomp()

NTSTATUS add_calc_job_decomp	(	device_extension *	Vcb,
		uint8_t	compression,
		void *	in,
		unsigned int	inlen,
		void *	out,
		unsigned int	outlen,
		unsigned int	off,
		calc_job **	pcj
	)

Definition at line 183 of file calcthread.c.

                                                                                               {
    calc_job* cj;
    KIRQL irql;
 
    cj = ExAllocatePoolWithTag(NonPagedPool, sizeof(calc_job), ALLOC_TAG);
    if (!cj) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    cj->in = in;
    cj->inlen = inlen;
    cj->out = out;
    cj->outlen = outlen;
    cj->off = off;
    cj->left = cj->not_started = 1;
    cj->Status = STATUS_SUCCESS;
 
    switch (compression) {
        case BTRFS_COMPRESSION_ZLIB:
            cj->type = calc_thread_decomp_zlib;
        break;
 
        case BTRFS_COMPRESSION_LZO:
            cj->type = calc_thread_decomp_lzo;
        break;
 
        case BTRFS_COMPRESSION_ZSTD:
            cj->type = calc_thread_decomp_zstd;
        break;
 
        default:
            ERR("unexpected compression type %x\n", compression);
            ExFreePool(cj);
        return STATUS_NOT_SUPPORTED;
    }
 
    KeInitializeEvent(&cj->event, NotificationEvent, false);
 
    KeAcquireSpinLock(&Vcb->calcthreads.spinlock, &irql);
 
    InsertTailList(&Vcb->calcthreads.job_list, &cj->list_entry);
 
    KeSetEvent(&Vcb->calcthreads.event, 0, false);
    KeClearEvent(&Vcb->calcthreads.event);
 
    KeReleaseSpinLock(&Vcb->calcthreads.spinlock, irql);
 
    *pcj = cj;
 
    return STATUS_SUCCESS;
}

◆ add_changed_extent_ref()

void add_changed_extent_ref	(	chunk *	c,
		uint64_t	address,
		uint64_t	size,
		uint64_t	root,
		uint64_t	objid,
		uint64_t	offset,
		uint32_t	count,
		bool	no_csum
	)

Definition at line 2076 of file extent-tree.c.

                                                                                                                                                     {
    changed_extent* ce;
    changed_extent_ref* cer;
    LIST_ENTRY* le;
 
    ce = get_changed_extent_item(c, address, size, no_csum);
 
    if (!ce) {
        ERR("get_changed_extent_item failed\n");
        return;
    }
 
    le = ce->refs.Flink;
    while (le != &ce->refs) {
        cer = CONTAINING_RECORD(le, changed_extent_ref, list_entry);
 
        if (cer->type == TYPE_EXTENT_DATA_REF && cer->edr.root == root && cer->edr.objid == objid && cer->edr.offset == offset) {
            ce->count += count;
            cer->edr.count += count;
            return;
        }
 
        le = le->Flink;
    }
 
    cer = ExAllocatePoolWithTag(PagedPool, sizeof(changed_extent_ref), ALLOC_TAG);
 
    if (!cer) {
        ERR("out of memory\n");
        return;
    }
 
    cer->type = TYPE_EXTENT_DATA_REF;
    cer->edr.root = root;
    cer->edr.objid = objid;
    cer->edr.offset = offset;
    cer->edr.count = count;
 
    InsertTailList(&ce->refs, &cer->list_entry);
 
    ce->count += count;
}

Referenced by insert_extent_chunk(), rationalize_extents(), and write_compressed().

◆ add_checksum_entry()

void add_checksum_entry	(	device_extension *	Vcb,
		uint64_t	address,
		ULONG	length,
		void *	csum,
		PIRP	Irp
	)

Definition at line 2602 of file flushthread.c.

                                                                                                     {
    KEY searchkey;
    traverse_ptr tp, next_tp;
    NTSTATUS Status;
    uint64_t startaddr, endaddr;
    ULONG len;
    RTL_BITMAP bmp;
    ULONG* bmparr;
    ULONG runlength, index;
 
    TRACE("(%p, %I64x, %lx, %p, %p)\n", Vcb, address, length, csum, Irp);
 
    searchkey.obj_id = EXTENT_CSUM_ID;
    searchkey.obj_type = TYPE_EXTENT_CSUM;
    searchkey.offset = address;
 
    // FIXME - create checksum_root if it doesn't exist at all
 
    Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
    if (Status == STATUS_NOT_FOUND) { // tree is completely empty
        if (csum) { // not deleted
            ULONG length2 = length;
            uint64_t off = address;
            void* data = csum;
 
            do {
                uint16_t il = (uint16_t)min(length2, MAX_CSUM_SIZE / Vcb->csum_size);
 
                void* checksums = ExAllocatePoolWithTag(PagedPool, il * Vcb->csum_size, ALLOC_TAG);
                if (!checksums) {
                    ERR("out of memory\n");
                    return;
                }
 
                RtlCopyMemory(checksums, data, il * Vcb->csum_size);
 
                Status = insert_tree_item(Vcb, Vcb->checksum_root, EXTENT_CSUM_ID, TYPE_EXTENT_CSUM, off, checksums,
                                          il * Vcb->csum_size, NULL, Irp);
                if (!NT_SUCCESS(Status)) {
                    ERR("insert_tree_item returned %08lx\n", Status);
                    ExFreePool(checksums);
                    return;
                }
 
                length2 -= il;
 
                if (length2 > 0) {
                    off += (uint64_t)il << Vcb->sector_shift;
                    data = (uint8_t*)data + (il * Vcb->csum_size);
                }
            } while (length2 > 0);
        }
    } else if (!NT_SUCCESS(Status)) {
        ERR("find_item returned %08lx\n", Status);
        return;
    } else {
        uint32_t tplen;
        void* checksums;
 
        // FIXME - check entry is TYPE_EXTENT_CSUM?
 
        if (tp.item->key.offset < address && tp.item->key.offset + (((uint64_t)tp.item->size << Vcb->sector_shift) / Vcb->csum_size) >= address)
            startaddr = tp.item->key.offset;
        else
            startaddr = address;
 
        searchkey.obj_id = EXTENT_CSUM_ID;
        searchkey.obj_type = TYPE_EXTENT_CSUM;
        searchkey.offset = address + (length << Vcb->sector_shift);
 
        Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("find_item returned %08lx\n", Status);
            return;
        }
 
        tplen = tp.item->size / Vcb->csum_size;
 
        if (tp.item->key.offset + (tplen << Vcb->sector_shift) >= address + (length << Vcb->sector_shift))
            endaddr = tp.item->key.offset + (tplen << Vcb->sector_shift);
        else
            endaddr = address + (length << Vcb->sector_shift);
 
        TRACE("cs starts at %I64x (%lx sectors)\n", address, length);
        TRACE("startaddr = %I64x\n", startaddr);
        TRACE("endaddr = %I64x\n", endaddr);
 
        len = (ULONG)((endaddr - startaddr) >> Vcb->sector_shift);
 
        checksums = ExAllocatePoolWithTag(PagedPool, Vcb->csum_size * len, ALLOC_TAG);
        if (!checksums) {
            ERR("out of memory\n");
            return;
        }
 
        bmparr = ExAllocatePoolWithTag(PagedPool, sizeof(ULONG) * ((len/8)+1), ALLOC_TAG);
        if (!bmparr) {
            ERR("out of memory\n");
            ExFreePool(checksums);
            return;
        }
 
        RtlInitializeBitMap(&bmp, bmparr, len);
        RtlSetAllBits(&bmp);
 
        searchkey.obj_id = EXTENT_CSUM_ID;
        searchkey.obj_type = TYPE_EXTENT_CSUM;
        searchkey.offset = address;
 
        Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("find_item returned %08lx\n", Status);
            ExFreePool(checksums);
            ExFreePool(bmparr);
            return;
        }
 
        // set bit = free space, cleared bit = allocated sector
 
        while (tp.item->key.offset < endaddr) {
            if (tp.item->key.offset >= startaddr) {
                if (tp.item->size > 0) {
                    ULONG itemlen = (ULONG)min((len - ((tp.item->key.offset - startaddr) >> Vcb->sector_shift)) * Vcb->csum_size, tp.item->size);
 
                    RtlCopyMemory((uint8_t*)checksums + (((tp.item->key.offset - startaddr) * Vcb->csum_size) >> Vcb->sector_shift),
                                  tp.item->data, itemlen);
                    RtlClearBits(&bmp, (ULONG)((tp.item->key.offset - startaddr) >> Vcb->sector_shift), itemlen / Vcb->csum_size);
                }
 
                Status = delete_tree_item(Vcb, &tp);
                if (!NT_SUCCESS(Status)) {
                    ERR("delete_tree_item returned %08lx\n", Status);
                    ExFreePool(checksums);
                    ExFreePool(bmparr);
                    return;
                }
            }
 
            if (find_next_item(Vcb, &tp, &next_tp, false, Irp)) {
                tp = next_tp;
            } else
                break;
        }
 
        if (!csum) { // deleted
            RtlSetBits(&bmp, (ULONG)((address - startaddr) >> Vcb->sector_shift), length);
        } else {
            RtlCopyMemory((uint8_t*)checksums + (((address - startaddr) * Vcb->csum_size) >> Vcb->sector_shift),
                          csum, length * Vcb->csum_size);
            RtlClearBits(&bmp, (ULONG)((address - startaddr) >> Vcb->sector_shift), length);
        }
 
        runlength = RtlFindFirstRunClear(&bmp, &index);
 
        while (runlength != 0) {
            if (index >= len)
                break;
 
            if (index + runlength >= len) {
                runlength = len - index;
 
                if (runlength == 0)
                    break;
            }
 
            do {
                uint16_t rl;
                uint64_t off;
                void* data;
 
                if (runlength * Vcb->csum_size > MAX_CSUM_SIZE)
                    rl = (uint16_t)(MAX_CSUM_SIZE / Vcb->csum_size);
                else
                    rl = (uint16_t)runlength;
 
                data = ExAllocatePoolWithTag(PagedPool, Vcb->csum_size * rl, ALLOC_TAG);
                if (!data) {
                    ERR("out of memory\n");
                    ExFreePool(bmparr);
                    ExFreePool(checksums);
                    return;
                }
 
                RtlCopyMemory(data, (uint8_t*)checksums + (Vcb->csum_size * index), Vcb->csum_size * rl);
 
                off = startaddr + ((uint64_t)index << Vcb->sector_shift);
 
                Status = insert_tree_item(Vcb, Vcb->checksum_root, EXTENT_CSUM_ID, TYPE_EXTENT_CSUM, off, data, Vcb->csum_size * rl, NULL, Irp);
                if (!NT_SUCCESS(Status)) {
                    ERR("insert_tree_item returned %08lx\n", Status);
                    ExFreePool(data);
                    ExFreePool(bmparr);
                    ExFreePool(checksums);
                    return;
                }
 
                runlength -= rl;
                index += rl;
            } while (runlength > 0);
 
            runlength = RtlFindNextForwardRunClear(&bmp, index, &index);
        }
 
        ExFreePool(bmparr);
        ExFreePool(checksums);
    }
}

Referenced by balance_data_chunk(), decrease_extent_refcount(), flush_fcb(), and rationalize_extents().

◆ add_dir_child()

NTSTATUS add_dir_child	(	fcb *	fcb,
		uint64_t	inode,
		bool	subvol,
		PANSI_STRING	utf8,
		PUNICODE_STRING	name,
		uint8_t	type,
		dir_child **	pdc
	)

Definition at line 1871 of file create.c.

                                                                                                                                      {
    NTSTATUS Status;
    dir_child* dc;
    bool locked;
 
    dc = ExAllocatePoolWithTag(PagedPool, sizeof(dir_child), ALLOC_TAG);
    if (!dc) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(dc, sizeof(dir_child));
 
    dc->utf8.Buffer = ExAllocatePoolWithTag(PagedPool, utf8->Length, ALLOC_TAG);
    if (!dc->utf8.Buffer) {
        ERR("out of memory\n");
        ExFreePool(dc);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    dc->name.Buffer = ExAllocatePoolWithTag(PagedPool, name->Length, ALLOC_TAG);
    if (!dc->name.Buffer) {
        ERR("out of memory\n");
        ExFreePool(dc->utf8.Buffer);
        ExFreePool(dc);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    dc->key.obj_id = inode;
    dc->key.obj_type = subvol ? TYPE_ROOT_ITEM : TYPE_INODE_ITEM;
    dc->key.offset = subvol ? 0xffffffffffffffff : 0;
    dc->type = type;
    dc->fileref = NULL;
 
    dc->utf8.Length = dc->utf8.MaximumLength = utf8->Length;
    RtlCopyMemory(dc->utf8.Buffer, utf8->Buffer, utf8->Length);
 
    dc->name.Length = dc->name.MaximumLength = name->Length;
    RtlCopyMemory(dc->name.Buffer, name->Buffer, name->Length);
 
    Status = RtlUpcaseUnicodeString(&dc->name_uc, name, true);
    if (!NT_SUCCESS(Status)) {
        ERR("RtlUpcaseUnicodeString returned %08lx\n", Status);
        ExFreePool(dc->utf8.Buffer);
        ExFreePool(dc->name.Buffer);
        ExFreePool(dc);
        return Status;
    }
 
    dc->hash = calc_crc32c(0xffffffff, (uint8_t*)dc->name.Buffer, dc->name.Length);
    dc->hash_uc = calc_crc32c(0xffffffff, (uint8_t*)dc->name_uc.Buffer, dc->name_uc.Length);
 
    locked = ExIsResourceAcquiredExclusive(&fcb->nonpaged->dir_children_lock);
 
    if (!locked)
        ExAcquireResourceExclusiveLite(&fcb->nonpaged->dir_children_lock, true);
 
    if (IsListEmpty(&fcb->dir_children_index))
        dc->index = 2;
    else {
        dir_child* dc2 = CONTAINING_RECORD(fcb->dir_children_index.Blink, dir_child, list_entry_index);
 
        dc->index = max(2, dc2->index + 1);
    }
 
    InsertTailList(&fcb->dir_children_index, &dc->list_entry_index);
 
    insert_dir_child_into_hash_lists(fcb, dc);
 
    if (!locked)
        ExReleaseResourceLite(&fcb->nonpaged->dir_children_lock);
 
    *pdc = dc;
 
    return STATUS_SUCCESS;
}

Referenced by create_subvol(), do_create_snapshot(), file_create2(), mknod(), and set_link_information().

◆ add_extent()

NTSTATUS bool void NTSTATUS void add_extent	(	_In_ fcb *	fcb,
		_In_ LIST_ENTRY *	prevextle,
		_In_ __drv_aliasesMem extent *	newext
	)

Referenced by __attribute__(), and duplicate_extents().

◆ add_extent_to_fcb()

NTSTATUS bool void NTSTATUS add_extent_to_fcb	(	_In_ fcb *	fcb,
		_In_ uint64_t	offset,
		_In_reads_bytes_(edsize) EXTENT_DATA *	ed,
		_In_ uint16_t	edsize,
		_In_ bool	unique,
		_In_opt_ _When_(return >=0, __drv_aliasesMem) void *	csum,
		_In_ LIST_ENTRY *	rollback
	)

Referenced by __attribute__(), duplicate_extents(), insert_extent_chunk(), rename_stream_to_file(), write_compressed(), and zero_data().

◆ add_fcb_to_subvol()

void add_fcb_to_subvol ( _In_ _Requires_exclusive_lock_held_(_Curr_->Vcb->fcb_lock) fcb * fcb )

Definition at line 888 of file fileinfo.c.

                                                                                            {
    LIST_ENTRY* lastle = NULL;
    uint32_t hash = fcb->hash;
 
    if (fcb->subvol->fcbs_ptrs[hash >> 24]) {
        LIST_ENTRY* le = fcb->subvol->fcbs_ptrs[hash >> 24];
 
        while (le != &fcb->subvol->fcbs) {
            struct _fcb* fcb2 = CONTAINING_RECORD(le, struct _fcb, list_entry);
 
            if (fcb2->hash > hash) {
                lastle = le->Blink;
                break;
            }
 
            le = le->Flink;
        }
    }
 
    if (!lastle) {
        uint8_t c = hash >> 24;
 
        if (c != 0xff) {
            uint8_t d = c + 1;
 
            do {
                if (fcb->subvol->fcbs_ptrs[d]) {
                    lastle = fcb->subvol->fcbs_ptrs[d]->Blink;
                    break;
                }
 
                d++;
            } while (d != 0);
        }
    }
 
    if (lastle) {
        InsertHeadList(lastle, &fcb->list_entry);
 
        if (lastle == &fcb->subvol->fcbs || (CONTAINING_RECORD(lastle, struct _fcb, list_entry)->hash >> 24) != (hash >> 24))
            fcb->subvol->fcbs_ptrs[hash >> 24] = &fcb->list_entry;
    } else {
        InsertTailList(&fcb->subvol->fcbs, &fcb->list_entry);
 
        if (fcb->list_entry.Blink == &fcb->subvol->fcbs || (CONTAINING_RECORD(fcb->list_entry.Blink, struct _fcb, list_entry)->hash >> 24) != (hash >> 24))
            fcb->subvol->fcbs_ptrs[hash >> 24] = &fcb->list_entry;
    }
}

Referenced by allocate_cache_chunk(), create_directory_fcb(), create_subvol(), mknod(), move_across_subvols(), rename_stream(), and rename_stream_to_file().

◆ add_group_mapping()

void add_group_mapping	(	WCHAR *	sidstring,
		ULONG	sidstringlength,
		uint32_t	gid
	)

Definition at line 145 of file security.c.

                                                                              {
    unsigned int i, np;
    uint8_t numdashes;
    uint64_t val;
    ULONG sidsize;
    sid_header* sid;
    gid_map* gm;
 
    if (sidstringlength < 4 || sidstring[0] != 'S' || sidstring[1] != '-' || sidstring[2] != '1' || sidstring[3] != '-') {
        ERR("invalid SID\n");
        return;
    }
 
    sidstring = &sidstring[4];
    sidstringlength -= 4;
 
    numdashes = 0;
    for (i = 0; i < sidstringlength; i++) {
        if (sidstring[i] == '-') {
            numdashes++;
            sidstring[i] = 0;
        }
    }
 
    sidsize = 8 + (numdashes * 4);
    sid = ExAllocatePoolWithTag(PagedPool, sidsize, ALLOC_TAG);
    if (!sid) {
        ERR("out of memory\n");
        return;
    }
 
    sid->revision = 0x01;
    sid->elements = numdashes;
 
    np = 0;
    while (sidstringlength > 0) {
        val = 0;
        i = 0;
        while (i < sidstringlength && sidstring[i] != '-') {
            if (sidstring[i] >= '0' && sidstring[i] <= '9') {
                val *= 10;
                val += sidstring[i] - '0';
            } else
                break;
 
            i++;
        }
 
        i++;
        TRACE("val = %u, i = %u, ssl = %lu\n", (uint32_t)val, i, sidstringlength);
 
        if (np == 0) {
            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_t)val;
 
        np++;
 
        if (sidstringlength > i) {
            sidstringlength -= i;
 
            sidstring = &sidstring[i];
        } else
            break;
    }
 
    gm = ExAllocatePoolWithTag(PagedPool, sizeof(gid_map), ALLOC_TAG);
    if (!gm) {
        ERR("out of memory\n");
        ExFreePool(sid);
        return;
    }
 
    gm->sid = sid;
    gm->gid = gid;
 
    InsertTailList(&gid_map_list, &gm->listentry);
}

Referenced by read_group_mappings().

◆ add_rollback()

void void void add_rollback	(	_In_ LIST_ENTRY *	rollback,
		_In_ enum rollback_type	type,
		_In_ __drv_aliasesMem void *	ptr
	)

Referenced by add_rollback_space().

◆ add_space_entry()

NTSTATUS add_space_entry	(	LIST_ENTRY *	list,
		LIST_ENTRY *	list_size,
		uint64_t	offset,
		uint64_t	size
	)

Definition at line 190 of file free-space.c.

                                                                                                  {
    space* s;
 
    s = ExAllocatePoolWithTag(PagedPool, sizeof(space), ALLOC_TAG);
 
    if (!s) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    s->address = offset;
    s->size = size;
 
    if (IsListEmpty(list))
        InsertTailList(list, &s->list_entry);
    else {
        space* s2 = CONTAINING_RECORD(list->Blink, space, list_entry);
 
        if (s2->address < offset)
            InsertTailList(list, &s->list_entry);
        else {
            LIST_ENTRY* le;
 
            le = list->Flink;
            while (le != list) {
                s2 = CONTAINING_RECORD(le, space, list_entry);
 
                if (s2->address > offset) {
                    InsertTailList(le, &s->list_entry);
                    goto size;
                }
 
                le = le->Flink;
            }
        }
    }
 
size:
    if (!list_size)
        return STATUS_SUCCESS;
 
    if (IsListEmpty(list_size))
        InsertTailList(list_size, &s->list_entry_size);
    else {
        space* s2 = CONTAINING_RECORD(list_size->Blink, space, list_entry_size);
 
        if (s2->size >= size)
            InsertTailList(list_size, &s->list_entry_size);
        else {
            LIST_ENTRY* le;
 
            le = list_size->Flink;
            while (le != list_size) {
                s2 = CONTAINING_RECORD(le, space, list_entry_size);
 
                if (s2->size <= size) {
                    InsertHeadList(le->Blink, &s->list_entry_size);
                    return STATUS_SUCCESS;
                }
 
                le = le->Flink;
            }
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by add_device(), find_disk_holes(), load_free_space_bitmap(), load_stored_free_space_cache(), and load_stored_free_space_tree().

◆ add_thread_job()

bool add_thread_job	(	device_extension *	Vcb,
		PIRP	Irp
	)

Definition at line 109 of file worker-thread.c.

                                                     {
    job_info* ji;
 
    ji = ExAllocatePoolWithTag(NonPagedPool, sizeof(job_info), ALLOC_TAG);
    if (!ji) {
        ERR("out of memory\n");
        return false;
    }
 
    ji->Vcb = Vcb;
    ji->Irp = Irp;
 
    if (!Irp->MdlAddress) {
        PMDL Mdl;
        LOCK_OPERATION op;
        ULONG len;
        PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
        if (IrpSp->MajorFunction == IRP_MJ_READ) {
            op = IoWriteAccess;
            len = IrpSp->Parameters.Read.Length;
        } else if (IrpSp->MajorFunction == IRP_MJ_WRITE) {
            op = IoReadAccess;
            len = IrpSp->Parameters.Write.Length;
        } else {
            ERR("unexpected major function %u\n", IrpSp->MajorFunction);
            ExFreePool(ji);
            return false;
        }
 
        Mdl = IoAllocateMdl(Irp->UserBuffer, len, false, false, Irp);
 
        if (!

Classes

Macros

Typedefs

Enumerations

Functions

Variables