btrfs_drv.h File Reference

#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 <emmintrin.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_nonpaged
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_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_LXSS_SYMLINK   0xa000001d
#define	IO_REPARSE_TAG_LXSS_SOCKET   0x80000023
#define	IO_REPARSE_TAG_LXSS_FIFO   0x80000024
#define	IO_REPARSE_TAG_LXSS_CHARDEV   0x80000025
#define	IO_REPARSE_TAG_LXSS_BLOCKDEV   0x80000026
#define	BTRFS_VOLUME_PREFIX   L"\\Device\\Btrfs{"
#define	try   if (1)
#define	except(x)   if (0 && (x))
#define	finally   if (1)
#define	FILE_SUPPORTS_BLOCK_REFCOUNTING   0x08000000
#define	FILE_SUPPORTS_POSIX_UNLINK_RENAME   0x00000400
#define	FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL   0x00020000
#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	_Requires_lock_held_(a)
#define	_Requires_exclusive_lock_held_(a)
#define	_Releases_lock_(a)
#define	_Out_writes_bytes_opt_(a)
#define	_Pre_satisfies_(a)
#define	_Post_satisfies_(a)
#define	_Releases_exclusive_lock_(a)
#define	_Dispatch_type_(a)
#define	_Create_lock_level_(a)
#define	_Lock_level_order_(a, b)
#define	_Has_lock_level_(a)
#define	_Requires_lock_not_held_(a)
#define	_Acquires_exclusive_lock_(a)
#define	_Acquires_shared_lock_(a)
#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	TRACE(s, ...)
#define	WARN(s, ...)
#define	FIXME(s, ...)   DbgPrint("Btrfs FIXME : %s : " s, funcname, ##__VA_ARGS__)
#define	ERR(s, ...)   DbgPrint("Btrfs ERR : %s : " s, funcname, ##__VA_ARGS__)
#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 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	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)
bool	is_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)
uint64_t	chunk_estimate_phys_size (device_extension *Vcb, chunk *c, uint64_t u)
NTSTATUS	utf8_to_utf16 (WCHAR *dest, ULONG dest_max, ULONG *dest_len, char *src, ULONG src_len)
NTSTATUS	utf16_to_utf8 (char *dest, ULONG dest_max, ULONG *dest_len, WCHAR *src, ULONG src_len)
uint32_t	get_num_of_processors ()
_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)
void	init_fast_io_dispatch (FAST_IO_DISPATCH **fiod)
uint32_t	calc_crc32c (_In_ uint32_t seed, _In_reads_bytes_(msglen) uint8_t *msg, _In_ ULONG msglen)
NTSTATUS	find_item (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ root *r, _Out_ traverse_ptr *tp, _In_ const KEY *searchkey, _In_ bool ignore, _In_opt_ PIRP Irp)
NTSTATUS	find_item_to_level (device_extension *Vcb, root *r, traverse_ptr *tp, const KEY *searchkey, bool ignore, uint8_t level, PIRP Irp)
bool	find_next_item (_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, const traverse_ptr *tp, traverse_ptr *next_tp, bool ignore, PIRP Irp)
bool	find_prev_item (_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, const traverse_ptr *tp, traverse_ptr *prev_tp, PIRP Irp)
void	free_trees (device_extension *Vcb)
NTSTATUS	insert_tree_item (_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ root *r, _In_ uint64_t obj_id, _In_ uint8_t obj_type, _In_ uint64_t offset, _In_reads_bytes_opt_(size) _When_(return >=0, __drv_aliasesMem) void *data, _In_ uint16_t size, _Out_opt_ traverse_ptr *ptp, _In_opt_ PIRP Irp)
NTSTATUS	delete_tree_item (_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _Inout_ traverse_ptr *tp)
void	free_tree (tree *t)
NTSTATUS	load_tree (device_extension *Vcb, uint64_t addr, uint8_t *buf, root *r, tree **pt)
NTSTATUS	do_load_tree (device_extension *Vcb, tree_holder *th, root *r, tree *t, tree_data *td, PIRP Irp)
void	clear_rollback (LIST_ENTRY *rollback)
void	do_rollback (device_extension *Vcb, LIST_ENTRY *rollback)
void	free_trees_root (device_extension *Vcb, root *r)
void	add_rollback (_In_ LIST_ENTRY *rollback, _In_ enum rollback_type type, _In_ __drv_aliasesMem void *ptr)
NTSTATUS	commit_batch_list (_Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, LIST_ENTRY *batchlist, PIRP Irp)
void	clear_batch_list (device_extension *Vcb, LIST_ENTRY *batchlist)
NTSTATUS	skip_to_difference (device_extension *Vcb, traverse_ptr *tp, traverse_ptr *tp2, bool *ended1, bool *ended2)
NTSTATUS	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 (PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath)
void	volume_arrival (PDRIVER_OBJECT DriverObject, PUNICODE_STRING devpath)
void	volume_removal (PDRIVER_OBJECT DriverObject, 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)
NTSTATUS	write_file2 (device_extension *Vcb, PIRP Irp, LARGE_INTEGER offset, void *buf, ULONG *length, bool paging_io, bool no_cache, bool wait, bool deferred_write, bool write_irp, LIST_ENTRY *rollback)
NTSTATUS	truncate_file (fcb *fcb, uint64_t end, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	extend_file (fcb *fcb, file_ref *fileref, uint64_t end, bool prealloc, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	excise_extents (device_extension *Vcb, fcb *fcb, uint64_t start_data, uint64_t end_data, PIRP Irp, LIST_ENTRY *rollback)
chunk *	get_chunk_from_address (device_extension *Vcb, uint64_t address)
NTSTATUS	alloc_chunk (device_extension *Vcb, uint64_t flags, chunk **pc, bool full_size)
NTSTATUS	write_data (_In_ device_extension *Vcb, _In_ uint64_t address, _In_reads_bytes_(length) void *data, _In_ uint32_t length, _In_ write_data_context *wtc, _In_opt_ PIRP Irp, _In_opt_ chunk *c, _In_ bool file_write, _In_ uint64_t irp_offset, _In_ ULONG priority)
NTSTATUS	write_data_complete (device_extension *Vcb, uint64_t address, void *data, uint32_t length, PIRP Irp, chunk *c, bool file_write, uint64_t irp_offset, ULONG priority)
void	free_write_data_stripes (write_data_context *wtc)
	_Dispatch_type_ (IRP_MJ_WRITE) _Function_class_(DRIVER_DISPATCH) NTSTATUS __stdcall drv_write(IN PDEVICE_OBJECT DeviceObject
	_Requires_lock_held_ (c->lock) _When_(return !=0
	_Releases_lock_ (c->lock)) bool insert_extent_chunk(_In_ device_extension *Vcb
NTSTATUS	do_write_file (fcb *fcb, uint64_t start_data, uint64_t end_data, void *data, PIRP Irp, bool file_write, uint32_t irp_offset, LIST_ENTRY *rollback)
NTSTATUS	write_compressed (fcb *fcb, uint64_t start_data, uint64_t end_data, void *data, PIRP Irp, LIST_ENTRY *rollback)
bool	find_data_address_in_chunk (device_extension *Vcb, chunk *c, uint64_t length, uint64_t *address)
void	get_raid56_lock_range (chunk *c, uint64_t address, uint64_t length, uint64_t *lockaddr, uint64_t *locklen)
NTSTATUS	calc_csum (_In_ device_extension *Vcb, _In_reads_bytes_(sectors *Vcb->superblock.sector_size) uint8_t *data, _In_ uint32_t sectors, _Out_writes_bytes_(sectors *sizeof(uint32_t)) uint32_t *csum)
void	add_insert_extent_rollback (LIST_ENTRY *rollback, fcb *fcb, extent *ext)
NTSTATUS	add_extent_to_fcb (_In_ fcb *fcb, _In_ uint64_t offset, _In_reads_bytes_(edsize) EXTENT_DATA *ed, _In_ uint16_t edsize, _In_ bool unique, _In_opt_ _When_(return >=0, __drv_aliasesMem) uint32_t *csum, _In_ LIST_ENTRY *rollback)
void	add_extent (_In_ fcb *fcb, _In_ LIST_ENTRY *prevextle, _In_ __drv_aliasesMem extent *newext)
	_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)
NTSTATUS	get_reparse_point (PDEVICE_OBJECT DeviceObject, PFILE_OBJECT FileObject, void *buffer, DWORD buflen, ULONG_PTR *retlen)
NTSTATUS	set_reparse_point2 (fcb *fcb, REPARSE_DATA_BUFFER *rdb, ULONG buflen, ccb *ccb, file_ref *fileref, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	set_reparse_point (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	delete_reparse_point (PDEVICE_OBJECT DeviceObject, PIRP Irp)
	_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, uint32_t *csum, uint64_t start, uint64_t length, PIRP Irp)
NTSTATUS	load_dir_children (_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, fcb *fcb, bool ignore_size, PIRP Irp)
NTSTATUS	add_dir_child (fcb *fcb, uint64_t inode, bool subvol, PANSI_STRING utf8, PUNICODE_STRING name, uint8_t type, dir_child **pdc)
NTSTATUS	open_fileref_child (_Requires_lock_held_(_Curr_->tree_lock) _Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension *Vcb, _In_ file_ref *sf, _In_ PUNICODE_STRING name, _In_ bool case_sensitive, _In_ bool lastpart, _In_ bool streampart, _In_ 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, uint32_t *csum, PIRP Irp)
bool	find_metadata_address_in_chunk (device_extension *Vcb, chunk *c, uint64_t *address)
void	add_trim_entry_avoid_sb (device_extension *Vcb, device *dev, uint64_t address, uint64_t size)
NTSTATUS	insert_tree_item_batch (LIST_ENTRY *batchlist, device_extension *Vcb, root *r, uint64_t objid, uint8_t objtype, uint64_t offset, _In_opt_ _When_(return >=0, __drv_aliasesMem) void *data, uint16_t datalen, enum batch_operation operation)
NTSTATUS	flush_partial_stripe (device_extension *Vcb, chunk *c, partial_stripe *ps)
NTSTATUS	update_dev_item (device_extension *Vcb, device *device, PIRP Irp)
	_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) uint32_t *csum, _In_ bool is_tree, _Out_writes_bytes_(length) uint8_t *buf, _In_opt_ chunk *c, _Out_opt_ chunk **pc, _In_opt_ PIRP Irp, _In_ uint64_t generation, _In_ bool file_read, _In_ ULONG priority)
NTSTATUS	read_file (fcb *fcb, uint8_t *data, uint64_t start, uint64_t length, ULONG *pbr, PIRP Irp)
NTSTATUS	read_stream (fcb *fcb, uint8_t *data, uint64_t start, ULONG length, ULONG *pbr)
NTSTATUS	do_read (PIRP Irp, bool wait, ULONG *bytes_read)
NTSTATUS	check_csum (device_extension *Vcb, uint8_t *data, uint32_t sectors, uint32_t *csum)
void	raid6_recover2 (uint8_t *sectors, uint16_t num_stripes, ULONG sector_size, uint16_t missing1, uint16_t missing2, uint8_t *out)
	_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, bool deleting, uint64_t address, uint64_t length, LIST_ENTRY *rollback)
void	space_list_subtract2 (LIST_ENTRY *list, LIST_ENTRY *list_size, uint64_t address, uint64_t length, chunk *c, LIST_ENTRY *rollback)
NTSTATUS	load_stored_free_space_cache (device_extension *Vcb, chunk *c, bool load_only, PIRP Irp)
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_bit (fcb *fcb, uint64_t start_data, uint64_t end_data, void *data, bool *compressed, PIRP Irp, LIST_ENTRY *rollback)
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
NTSTATUS	add_calc_job (device_extension *Vcb, uint8_t *data, uint32_t sectors, uint32_t *csum, calc_job **pcj)
void	free_calc_job (calc_job *cj)
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_query_information (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_set_information (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_query_ea (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_set_ea (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_flush_buffers (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_query_volume_information (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_set_volume_information (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_cleanup (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_directory_control (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_file_system_control (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_lock_control (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_device_control (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_shutdown (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_query_security (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	vol_set_security (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
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 __stdcall	check_system_root (PDRIVER_OBJECT DriverObject, PVOID Context, ULONG Count)
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 void	do_xor (uint8_t *buf1, uint8_t *buf2, uint32_t len)
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
PDEVICE_OBJECT	PhysicalDeviceObject
bool	have_sse2
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	no_pnp
static const char	lxuid [] = "$LXUID"
static const char	lxgid [] = "$LXGID"
static const char	lxmod [] = "$LXMOD"
static const char	lxdev [] = "$LXDEV"
PVOID	Context
CACHE_MANAGER_CALLBACKS	cache_callbacks
IN PIRP	Irp
_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 _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 = 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 = 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
_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

Macro Definition Documentation

__drv_aliasesMem

#define __drv_aliasesMem

Definition at line 189 of file btrfs_drv.h.

__S_IFBLK

#define __S_IFBLK   0060000 /* Block device. */

Definition at line 1733 of file btrfs_drv.h.

__S_IFCHR

#define __S_IFCHR   0020000 /* Character device. */

Definition at line 1732 of file btrfs_drv.h.

__S_IFDIR

#define __S_IFDIR   0040000 /* Directory. */

Definition at line 1731 of file btrfs_drv.h.

__S_IFIFO

#define __S_IFIFO   0010000 /* FIFO. */

Definition at line 1735 of file btrfs_drv.h.

__S_IFLNK

#define __S_IFLNK   0120000 /* Symbolic link. */

Definition at line 1736 of file btrfs_drv.h.

__S_IFMT

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

Definition at line 1730 of file btrfs_drv.h.

__S_IFREG

#define __S_IFREG   0100000 /* Regular file. */

Definition at line 1734 of file btrfs_drv.h.

__S_IFSOCK

#define __S_IFSOCK   0140000 /* Socket. */

Definition at line 1737 of file btrfs_drv.h.

__S_ISTYPE

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

Definition at line 1738 of file btrfs_drv.h.

_Acquires_exclusive_lock_

#define _Acquires_exclusive_lock_

(

a

)

Definition at line 202 of file btrfs_drv.h.

_Acquires_shared_lock_

#define _Acquires_shared_lock_

(

a

)

Definition at line 203 of file btrfs_drv.h.

_Create_lock_level_

#define _Create_lock_level_

(

a

)

Definition at line 198 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 197 of file btrfs_drv.h.

_Has_lock_level_

#define _Has_lock_level_

(

a

)

Definition at line 200 of file btrfs_drv.h.

_Lock_level_order_

#define _Lock_level_order_	(		a,
			b
	)

Definition at line 199 of file btrfs_drv.h.

_NO_CRT_STDIO_INLINE

#define _NO_CRT_STDIO_INLINE

Definition at line 27 of file btrfs_drv.h.

_Out_writes_bytes_opt_

#define _Out_writes_bytes_opt_

(

a

)

Definition at line 193 of file btrfs_drv.h.

_Post_satisfies_

#define _Post_satisfies_

(

a

)

Definition at line 195 of file btrfs_drv.h.

_Pre_satisfies_

#define _Pre_satisfies_

(

a

)

Definition at line 194 of file btrfs_drv.h.

_Releases_exclusive_lock_

#define _Releases_exclusive_lock_

(

a

)

Definition at line 196 of file btrfs_drv.h.

_Releases_lock_

#define _Releases_lock_

(

a

)

Definition at line 192 of file btrfs_drv.h.

_Requires_exclusive_lock_held_

#define _Requires_exclusive_lock_held_

(

a

)

Definition at line 191 of file btrfs_drv.h.

_Requires_lock_held_

#define _Requires_lock_held_

(

a

)

Definition at line 190 of file btrfs_drv.h.

_Requires_lock_not_held_

#define _Requires_lock_not_held_

(

a

)

Definition at line 201 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 1104 of file btrfs_drv.h.

ALLOC_TAG

#define ALLOC_TAG   0x7442484D

Definition at line 91 of file btrfs_drv.h.

ALLOC_TAG_ZLIB

#define ALLOC_TAG_ZLIB   0x7A42484D

Definition at line 92 of file btrfs_drv.h.

BALANCE_OPTS_DATA

#define BALANCE_OPTS_DATA   0

Definition at line 670 of file btrfs_drv.h.

BALANCE_OPTS_METADATA

#define BALANCE_OPTS_METADATA   1

Definition at line 671 of file btrfs_drv.h.

BALANCE_OPTS_SYSTEM

#define BALANCE_OPTS_SYSTEM   2

Definition at line 672 of file btrfs_drv.h.

BTRFS_NODE_TYPE_CCB

#define BTRFS_NODE_TYPE_CCB   0x2295

Definition at line 88 of file btrfs_drv.h.

BTRFS_NODE_TYPE_FCB

#define BTRFS_NODE_TYPE_FCB   0x2296

Definition at line 89 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 1822 of file btrfs_drv.h.

COMPRESSED_EXTENT_SIZE

#define COMPRESSED_EXTENT_SIZE   0x20000

Definition at line 116 of file btrfs_drv.h.

EA_CASE_SENSITIVE

#define EA_CASE_SENSITIVE   "user.casesensitive"

Definition at line 109 of file btrfs_drv.h.

EA_CASE_SENSITIVE_HASH

#define EA_CASE_SENSITIVE_HASH   0x1a9d97d4

Definition at line 110 of file btrfs_drv.h.

EA_DOSATTRIB

#define EA_DOSATTRIB   "user.DOSATTRIB"

Definition at line 100 of file btrfs_drv.h.

EA_DOSATTRIB_HASH

#define EA_DOSATTRIB_HASH   0x914f9939

Definition at line 101 of file btrfs_drv.h.

EA_EA

#define EA_EA   "user.EA"

Definition at line 106 of file btrfs_drv.h.

EA_EA_HASH

#define EA_EA_HASH   0x8270dd43

Definition at line 107 of file btrfs_drv.h.

EA_NTACL

#define EA_NTACL   "security.NTACL"

Definition at line 97 of file btrfs_drv.h.

EA_NTACL_HASH

#define EA_NTACL_HASH   0x45922146

Definition at line 98 of file btrfs_drv.h.

EA_PROP_COMPRESSION

#define EA_PROP_COMPRESSION   "btrfs.compression"

Definition at line 112 of file btrfs_drv.h.

EA_PROP_COMPRESSION_HASH

#define EA_PROP_COMPRESSION_HASH   0x20ccdf69

Definition at line 113 of file btrfs_drv.h.

EA_REPARSE

#define EA_REPARSE   "user.reparse"

Definition at line 103 of file btrfs_drv.h.

EA_REPARSE_HASH

#define EA_REPARSE_HASH   0xfabad1fe

Definition at line 104 of file btrfs_drv.h.

ERR

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

Definition at line 1196 of file btrfs_drv.h.

except

#define except

(

x

)

if (0 && (x))

Definition at line 135 of file btrfs_drv.h.

FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL

#define FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL   0x00020000

Definition at line 154 of file btrfs_drv.h.

FILE_SUPPORTS_BLOCK_REFCOUNTING

#define FILE_SUPPORTS_BLOCK_REFCOUNTING   0x08000000

Definition at line 146 of file btrfs_drv.h.

FILE_SUPPORTS_POSIX_UNLINK_RENAME

#define FILE_SUPPORTS_POSIX_UNLINK_RENAME   0x00000400

Definition at line 150 of file btrfs_drv.h.

finally

#define finally   if (1)

Definition at line 136 of file btrfs_drv.h.

FIXME

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

Definition at line 1195 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 168 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 184 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 185 of file btrfs_drv.h.

FSRTL_FCB_HEADER_V2

#define FSRTL_FCB_HEADER_V2   2

Definition at line 1607 of file btrfs_drv.h.

funcname

#define funcname   __func__

Definition at line 1141 of file btrfs_drv.h.

GID_NOBODY

#define GID_NOBODY   65534

Definition at line 95 of file btrfs_drv.h.

hex_digit

#define hex_digit

(

c

)

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

Definition at line 1725 of file btrfs_drv.h.

increase_fileref_refcount

#define increase_fileref_refcount

(

fileref

)

InterlockedIncrement(&fileref->refcount)

Definition at line 1716 of file btrfs_drv.h.

int3

#define int3   asm("int3;")

Definition at line 1722 of file btrfs_drv.h.

IO_REPARSE_TAG_LXSS_BLOCKDEV

#define IO_REPARSE_TAG_LXSS_BLOCKDEV   0x80000026

Definition at line 125 of file btrfs_drv.h.

IO_REPARSE_TAG_LXSS_CHARDEV

#define IO_REPARSE_TAG_LXSS_CHARDEV   0x80000025

Definition at line 124 of file btrfs_drv.h.

IO_REPARSE_TAG_LXSS_FIFO

#define IO_REPARSE_TAG_LXSS_FIFO   0x80000024

Definition at line 123 of file btrfs_drv.h.

IO_REPARSE_TAG_LXSS_SOCKET

#define IO_REPARSE_TAG_LXSS_SOCKET   0x80000023

Definition at line 122 of file btrfs_drv.h.

IO_REPARSE_TAG_LXSS_SYMLINK

#define IO_REPARSE_TAG_LXSS_SYMLINK   0xa000001d

Definition at line 120 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 991 of file btrfs_drv.h.

major

#define major

(

rdev

)

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

Definition at line 1798 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 1589 of file btrfs_drv.h.

MAX_EXTENT_SIZE

#define MAX_EXTENT_SIZE   0x8000000

Definition at line 115 of file btrfs_drv.h.

minor

#define minor

(

rdev

)

(((rdev) & 0xFF) | ((uint32_t)((rdev) >> 12) & ~0xFF))

Definition at line 1799 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 118 of file btrfs_drv.h.

release_chunk_lock

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

Definition at line 1105 of file btrfs_drv.h.

S_IRGRP

#define S_IRGRP   (S_IRUSR >> 3)

Definition at line 1762 of file btrfs_drv.h.

S_IROTH

#define S_IROTH   (S_IRGRP >> 3)

Definition at line 1774 of file btrfs_drv.h.

S_IRUSR

#define S_IRUSR   0000400

Definition at line 1745 of file btrfs_drv.h.

S_ISDIR

#define S_ISDIR

(

mode

)

__S_ISTYPE((mode), __S_IFDIR)

Definition at line 1741 of file btrfs_drv.h.

S_ISGID

#define S_ISGID   0002000

Definition at line 1790 of file btrfs_drv.h.

S_ISUID

#define S_ISUID   0004000

Definition at line 1786 of file btrfs_drv.h.

S_ISVTX

#define S_ISVTX   0001000

Definition at line 1794 of file btrfs_drv.h.

S_IWGRP

#define S_IWGRP   (S_IWUSR >> 3)

Definition at line 1766 of file btrfs_drv.h.

S_IWOTH

#define S_IWOTH   (S_IWGRP >> 3)

Definition at line 1778 of file btrfs_drv.h.

S_IWUSR

#define S_IWUSR   0000200

Definition at line 1749 of file btrfs_drv.h.

S_IXGRP

#define S_IXGRP   (S_IXUSR >> 3)

Definition at line 1770 of file btrfs_drv.h.

S_IXOTH

#define S_IXOTH   (S_IXGRP >> 3)

Definition at line 1782 of file btrfs_drv.h.

S_IXUSR

#define S_IXUSR   0000100

Definition at line 1753 of file btrfs_drv.h.

TRACE

#define TRACE	(		s,
			...
	)

Definition at line 1193 of file btrfs_drv.h.

try

#define try   if (1)

Definition at line 134 of file btrfs_drv.h.

UID_NOBODY

#define UID_NOBODY   65534

Definition at line 94 of file btrfs_drv.h.

UNUSED

#define UNUSED

(

x

)

(void)(x)

Definition at line 86 of file btrfs_drv.h.

VCB_TYPE_BUS

#define VCB_TYPE_BUS   5

Definition at line 668 of file btrfs_drv.h.

VCB_TYPE_CONTROL

#define VCB_TYPE_CONTROL   2

Definition at line 665 of file btrfs_drv.h.

VCB_TYPE_FS

#define VCB_TYPE_FS   1

Definition at line 664 of file btrfs_drv.h.

VCB_TYPE_PDO

#define VCB_TYPE_PDO   4

Definition at line 667 of file btrfs_drv.h.

VCB_TYPE_VOLUME

#define VCB_TYPE_VOLUME   3

Definition at line 666 of file btrfs_drv.h.

WARN

#define WARN	(		s,
			...
	)

Definition at line 1194 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 1314 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 1882 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 1818 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 1815 of file btrfs_drv.h.

tCcSetAdditionalCacheAttributesEx

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

Definition at line 1830 of file btrfs_drv.h.

tFsRtlAreThereCurrentOrInProgressFileLocks

typedef BOOLEAN(__stdcall * tFsRtlAreThereCurrentOrInProgressFileLocks) (PFILE_LOCK FileLock)

Definition at line 1845 of file btrfs_drv.h.

tFsRtlCheckLockForOplockRequest

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

Definition at line 1843 of file btrfs_drv.h.

tFsRtlGetEcpListFromIrp

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

Definition at line 1836 of file btrfs_drv.h.

tFsRtlGetNextExtraCreateParameter

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

Definition at line 1838 of file btrfs_drv.h.

tFsRtlUpdateDiskCounters

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

Definition at line 1832 of file btrfs_drv.h.

tFsRtlValidateReparsePointBuffer

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

Definition at line 1841 of file btrfs_drv.h.

tIoUnregisterPlugPlayNotificationEx

typedef NTSTATUS(__stdcall * tIoUnregisterPlugPlayNotificationEx) (PVOID NotificationEntry)

Definition at line 1834 of file btrfs_drv.h.

tPsIsDiskCountersEnabled

typedef BOOLEAN(__stdcall * tPsIsDiskCountersEnabled) ()

Definition at line 1810 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 1812 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

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,
};

prop_compression_type

enum prop_compression_type

Enumerator
PropCompression_None
PropCompression_Zlib
PropCompression_LZO
PropCompression_ZSTD

Definition at line 263 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 1224 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 889 of file btrfs_drv.h.

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

Function Documentation

_Create_lock_level_()

_Create_lock_level_

(

tree_lock

)

_Dispatch_type_() [1/12]

_Dispatch_type_

(

IRP_MJ_WRITE

)

_Dispatch_type_() [2/12]

_Dispatch_type_

(

IRP_MJ_DIRECTORY_CONTROL

)

_Dispatch_type_() [3/12]

_Dispatch_type_

(

IRP_MJ_QUERY_SECURITY

)

_Dispatch_type_() [4/12]

_Dispatch_type_

(

IRP_MJ_SET_SECURITY

)

_Dispatch_type_() [5/12]

_Dispatch_type_

(

IRP_MJ_SET_INFORMATION

)

_Dispatch_type_() [6/12]

_Dispatch_type_

(

IRP_MJ_QUERY_INFORMATION

)

_Dispatch_type_() [7/12]

_Dispatch_type_

(

IRP_MJ_QUERY_EA

)

_Dispatch_type_() [8/12]

_Dispatch_type_

(

IRP_MJ_SET_EA

)

_Dispatch_type_() [9/12]

_Dispatch_type_

(

IRP_MJ_CREATE

)

_Dispatch_type_() [10/12]

_Dispatch_type_

(

IRP_MJ_READ

)

_Dispatch_type_() [11/12]

_Dispatch_type_

(

IRP_MJ_PNP

)

_Dispatch_type_() [12/12]

_Dispatch_type_

(

IRP_MJ_DEVICE_CONTROL

)

_Function_class_() [1/3]

_Function_class_

(

DRIVER_ADD_DEVICE

)

_Function_class_() [2/3]

_Function_class_

(

KSTART_ROUTINE

)

Definition at line 3046 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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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 %08x\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);
}

_Function_class_() [3/3]

_Function_class_

(

DRIVER_NOTIFICATION_CALLBACK_ROUTINE

)

_Post_satisfies_()

_Post_satisfies_

(

return >=

n

)

_Releases_lock_()

_Releases_lock_

(

c->

lock

)

_Requires_lock_held_() [1/2]

_Requires_lock_held_

(

Vcb->

fcb_lock

)

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

Definition at line 946 of file btrfs_drv.h.

                                                             {
    ExReleaseResourceLite(&Vcb->fcb_lock);
}

_Requires_lock_held_() [2/2]

_Requires_lock_held_ ( c->  lock )

pure virtual

_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 934 of file btrfs_drv.h.

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

_Success_()

_Success_

(

return

)

add_calc_job()

NTSTATUS add_calc_job	(	device_extension *	Vcb,
		uint8_t *	data,
		uint32_t	sectors,
		uint32_t *	csum,
		calc_job **	pcj
	)

Definition at line 22 of file calcthread.c.

                                                                                                              {
    calc_job* cj;

    cj = ExAllocatePoolWithTag(NonPagedPool, sizeof(calc_job), ALLOC_TAG);
    if (!cj) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    cj->data = data;
    cj->sectors = sectors;
    cj->csum = csum;
    cj->pos = 0;
    cj->done = 0;
    cj->refcount = 1;
    KeInitializeEvent(&cj->event, NotificationEvent, false);

    ExAcquireResourceExclusiveLite(&Vcb->calcthreads.lock, true);

    InsertTailList(&Vcb->calcthreads.job_list, &cj->list_entry);

    KeSetEvent(&Vcb->calcthreads.event, 0, false);
    KeClearEvent(&Vcb->calcthreads.event);

    ExReleaseResourceLite(&Vcb->calcthreads.lock);

    *pcj = cj;

    return STATUS_SUCCESS;
}

Referenced by calc_csum(), and check_csum().

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 2075 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 rationalize_extents().

add_checksum_entry()

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

Definition at line 2555 of file flushthread.c.

                                                                                                         {
    KEY searchkey;
    traverse_ptr tp, next_tp;
    NTSTATUS Status;
    uint64_t startaddr, endaddr;
    ULONG len;
    uint32_t* checksums;
    RTL_BITMAP bmp;
    ULONG* bmparr;
    ULONG runlength, index;

    TRACE("(%p, %I64x, %x, %p, %p)\n", Vcb, address, length, csum, Irp);

    searchkey.obj_id = EXTENT_CSUM_ID;
    searchkey.obj_type = TYPE_EXTENT_CSUM;
    searchkey.offset = address;

    // FIXME - create checksum_root if it doesn't exist at all

    Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
    if (Status == STATUS_NOT_FOUND) { // tree is completely empty
        if (csum) { // not deleted
            ULONG length2 = length;
            uint64_t off = address;
            uint32_t* data = csum;

            do {
                uint16_t il = (uint16_t)min(length2, MAX_CSUM_SIZE / sizeof(uint32_t));

                checksums = ExAllocatePoolWithTag(PagedPool, il * sizeof(uint32_t), ALLOC_TAG);
                if (!checksums) {
                    ERR("out of memory\n");
                    return;
                }

                RtlCopyMemory(checksums, data, il * sizeof(uint32_t));

                Status = insert_tree_item(Vcb, Vcb->checksum_root, EXTENT_CSUM_ID, TYPE_EXTENT_CSUM, off, checksums,
                                          il * sizeof(uint32_t), NULL, Irp);
                if (!NT_SUCCESS(Status)) {
                    ERR("insert_tree_item returned %08x\n", Status);
                    ExFreePool(checksums);
                    return;
                }

                length2 -= il;

                if (length2 > 0) {
                    off += il * Vcb->superblock.sector_size;
                    data += il;
                }
            } while (length2 > 0);
        }
    } else if (!NT_SUCCESS(Status)) {
        ERR("find_item returned %08x\n", Status);
        return;
    } else {
        uint32_t tplen;

        // FIXME - check entry is TYPE_EXTENT_CSUM?

        if (tp.item->key.offset < address && tp.item->key.offset + (tp.item->size * Vcb->superblock.sector_size / sizeof(uint32_t)) >= 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->superblock.sector_size);

        Status = find_item(Vcb, Vcb->checksum_root, &tp, &searchkey, false, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("find_item returned %08x\n", Status);
            return;
        }

        tplen = tp.item->size / sizeof(uint32_t);

        if (tp.item->key.offset + (tplen * Vcb->superblock.sector_size) >= address + (length * Vcb->superblock.sector_size))
            endaddr = tp.item->key.offset + (tplen * Vcb->superblock.sector_size);
        else
            endaddr = address + (length * Vcb->superblock.sector_size);

        TRACE("cs starts at %I64x (%x sectors)\n", address, length);
        TRACE("startaddr = %I64x\n", startaddr);
        TRACE("endaddr = %I64x\n", endaddr);

        len = (ULONG)((endaddr - startaddr) / Vcb->superblock.sector_size);

        checksums = ExAllocatePoolWithTag(PagedPool, sizeof(uint32_t) * 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 %08x\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->superblock.sector_size) * sizeof(uint32_t), tp.item->size);

                    RtlCopyMemory(&checksums[(tp.item->key.offset - startaddr) / Vcb->superblock.sector_size], tp.item->data, itemlen);
                    RtlClearBits(&bmp, (ULONG)((tp.item->key.offset - startaddr) / Vcb->superblock.sector_size), itemlen / sizeof(uint32_t));
                }

                Status = delete_tree_item(Vcb, &tp);
                if (!NT_SUCCESS(Status)) {
                    ERR("delete_tree_item returned %08x\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->superblock.sector_size), length);
        } else {
            RtlCopyMemory(&checksums[(address - startaddr) / Vcb->superblock.sector_size], csum, length * sizeof(uint32_t));
            RtlClearBits(&bmp, (ULONG)((address - startaddr) / Vcb->superblock.sector_size), length);
        }

        runlength = RtlFindFirstRunClear(&bmp, &index);

        while (runlength != 0) {
            if (index >= len)
                break;

            if (index + runlength >= len) {
                runlength = len - index;

                if (runlength == 0)
                    break;
            }

            do {
                uint16_t rl;
                uint64_t off;
                uint32_t* data;

                if (runlength * sizeof(uint32_t) > MAX_CSUM_SIZE)
                    rl = MAX_CSUM_SIZE / sizeof(uint32_t);
                else
                    rl = (uint16_t)runlength;

                data = ExAllocatePoolWithTag(PagedPool, sizeof(uint32_t) * rl, ALLOC_TAG);
                if (!data) {
                    ERR("out of memory\n");
                    ExFreePool(bmparr);
                    ExFreePool(checksums);
                    return;
                }

                RtlCopyMemory(data, &checksums[index], sizeof(uint32_t) * rl);

                off = startaddr + UInt32x32To64(index, Vcb->superblock.sector_size);

                Status = insert_tree_item(Vcb, Vcb->checksum_root, EXTENT_CSUM_ID, TYPE_EXTENT_CSUM, off, data, sizeof(uint32_t) * rl, NULL, Irp);
                if (!NT_SUCCESS(Status)) {
                    ERR("insert_tree_item returned %08x\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 1830 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;
    }

    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 %08x\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()

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

Definition at line 2351 of file write.c.

                                                                                                 {
    LIST_ENTRY* le = prevextle->Flink;

    while (le != &fcb->extents) {
        extent* ext = CONTAINING_RECORD(le, extent, list_entry);

        if (ext->offset >= newext->offset) {
            InsertHeadList(ext->list_entry.Blink, &newext->list_entry);
            return;
        }

        le = le->Flink;
    }

    InsertTailList(&fcb->extents, &newext->list_entry);
}

Referenced by do_write_file_prealloc(), duplicate_extents(), and excise_extents().

add_extent_to_fcb()

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

Definition at line 2720 of file write.c.

                                                                                                                                       {
    extent* ext;
    LIST_ENTRY* le;

    ext = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + edsize, ALLOC_TAG);
    if (!ext) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    ext->offset = offset;
    ext->datalen = edsize;
    ext->unique = unique;
    ext->ignore = false;
    ext->inserted = true;
    ext->csum = csum;

    RtlCopyMemory(&ext->extent_data, ed, edsize);

    le = fcb->extents.Flink;
    while (le != &fcb->extents) {
        extent* oldext = CONTAINING_RECORD(le, extent, list_entry);

        if (oldext->offset >= offset) {
            InsertHeadList(le->Blink, &ext->list_entry);
            goto end;
        }

        le = le->Flink;
    }

    InsertTailList(&fcb->extents, &ext->list_entry);

end:
    add_insert_extent_rollback(rollback, fcb, ext);

    return STATUS_SUCCESS;
}

Referenced by duplicate_extents(), extend_file(), rename_stream_to_file(), truncate_file(), write_file2(), and zero_data().

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 (sidstring[i] != '-' && i < sidstringlength) {
            if (sidstring[i] >= '0' && sidstring[i] <= '9') {
                val *= 10;
                val += sidstring[i] - '0';
            } else
                break;

            i++;
        }

        i++;
        TRACE("val = %u, i = %u, ssl = %u\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_insert_extent_rollback()

void add_insert_extent_rollback	(	LIST_ENTRY *	rollback,
		fcb *	fcb,
		extent *	ext
	)

Definition at line 2701 of file write.c.

                                                                             {
    rollback_extent* re;

    re = ExAllocatePoolWithTag(NonPagedPool, sizeof(rollback_extent), ALLOC_TAG);
    if (!re) {
        ERR("out of memory\n");
        return;
    }

    re->fcb = fcb;
    re->ext = ext;

    add_rollback(rollback, ROLLBACK_INSERT_EXTENT, re);
}

Referenced by add_extent_to_fcb(), and do_write_file_prealloc().

add_rollback()

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

Definition at line 836 of file treefuncs.c.

                                                                                                            {
    rollback_item* ri;

    ri = ExAllocatePoolWithTag(PagedPool, sizeof(rollback_item), ALLOC_TAG);
    if (!ri) {
        ERR("out of memory\n");
        return;
    }

    ri->type = type;
    ri->ptr = ptr;
    InsertTailList(rollback, &ri->list_entry);
}

Referenced by add_insert_extent_rollback(), add_rollback_space(), and remove_fcb_extent().

add_space_entry()

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

Definition at line 189 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) {