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 <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	_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
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	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	_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_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_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	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)((minor) & ~0xFF)) << 12) | (((UINT64)((major) & ~0xFFF)) << 32))
#define	fast_io_possible(fcb)   (!FsRtlAreThereCurrentFileLocks(&fcb->lock) && !fcb->Vcb->readonly ? FastIoIsPossible : FastIoIsQuestionable)
#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)((rdev) >> 32) & ~0xFFF))
#define	minor(rdev)   (((rdev) & 0xFF) | ((UINT32)((rdev) >> 12) & ~0xFF))
#define	CC_ENABLE_DISK_IO_ACCOUNTING   0x00000010

Typedefs
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(*	tPsIsDiskCountersEnabled) ()
typedef VOID(*	tPsUpdateDiskCounters) (PEPROCESS Process, ULONG64 BytesRead, ULONG64 BytesWritten, ULONG ReadOperationCount, ULONG WriteOperationCount, ULONG FlushOperationCount)
typedef BOOLEAN(*	tCcCopyWriteEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PETHREAD IoIssuerThread)
typedef BOOLEAN(*	tCcCopyReadEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PETHREAD IoIssuerThread)
typedef VOID(*	tCcSetAdditionalCacheAttributesEx) (PFILE_OBJECT FileObject, ULONG Flags)
typedef VOID(*	tFsRtlUpdateDiskCounters) (ULONG64 BytesRead, ULONG64 BytesWritten)
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	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 off, _In_ UINT64 stripe_length, _In_ UINT16 num_stripes, _Out_ UINT64 *stripeoff, _Out_ UINT16 *stripe)
static __inline UINT64	make_file_id (root *r, UINT64 inode)
	_Post_satisfies_ (return >=n) __inline static UINT64 sector_align(_In_ UINT64 n
static __inline BOOL	is_subvol_readonly (root *r, PIRP Irp)
static __inline UINT16	get_extent_data_len (UINT8 type)
static __inline UINT32	get_extent_data_refcount (UINT8 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 inode, _In_ UINT8 type, _In_ BOOL dotfile, _In_ BOOL ignore_xa, _In_opt_ PIRP Irp)
void	free_fcb (_Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension *Vcb, _Inout_ fcb *fcb)
void	free_fileref (_Requires_exclusive_lock_held_(_Curr_->fcb_lock) _In_ device_extension *Vcb, _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 id, _Out_ root **rootptr, _In_ BOOL no_tree, _In_ UINT64 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_ BOOLEAN Override, _Out_opt_ IO_STATUS_BLOCK *iosb)
BOOL	is_file_name_valid (_In_ PUNICODE_STRING us, _In_ BOOL posix)
void	send_notification_fileref (_In_ file_ref *fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream)
void	send_notification_fcb (_In_ file_ref *fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream)
_Ret_z_ WCHAR *	file_desc (_In_ PFILE_OBJECT FileObject)
WCHAR *	file_desc_fileref (_In_ file_ref *fileref)
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_opt_ PIRP Irp, _In_ LIST_ENTRY *rollback)
void	chunk_lock_range (_In_ device_extension *Vcb, _In_ chunk *c, _In_ UINT64 start, _In_ UINT64 length)
void	chunk_unlock_range (_In_ device_extension *Vcb, _In_ chunk *c, _In_ UINT64 start, _In_ UINT64 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_ UINT64 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)
NTSTATUS	AddDevice (PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject)
void	init_fast_io_dispatch (FAST_IO_DISPATCH **fiod)
UINT32	calc_crc32c (_In_ UINT32 seed, _In_reads_bytes_(msglen) UINT8 *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 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 obj_id, _In_ UINT8 obj_type, _In_ UINT64 offset, _In_reads_bytes_opt_(size) _When_(return >=0, __drv_aliasesMem) void *data, _In_ UINT16 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)
tree *	free_tree (tree *t)
NTSTATUS	load_tree (device_extension *Vcb, UINT64 addr, root *r, tree **pt, UINT64 generation, PIRP Irp)
NTSTATUS	do_load_tree (device_extension *Vcb, tree_holder *th, root *r, tree *t, tree_data *td, BOOL *loaded, 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 mountmgr_thread(_In_ void *context)
	_Function_class_ (DRIVER_NOTIFICATION_CALLBACK_ROUTINE) NTSTATUS 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)
NTSTATUS	init_cache ()
void	free_cache ()
NTSTATUS	write_file (device_extension *Vcb, PIRP Irp, BOOLEAN wait, BOOLEAN deferred_write)
NTSTATUS	write_file2 (device_extension *Vcb, PIRP Irp, LARGE_INTEGER offset, void *buf, ULONG *length, BOOLEAN paging_io, BOOLEAN no_cache, BOOLEAN wait, BOOLEAN deferred_write, BOOLEAN write_irp, LIST_ENTRY *rollback)
NTSTATUS	truncate_file (fcb *fcb, UINT64 end, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	extend_file (fcb *fcb, file_ref *fileref, UINT64 end, BOOL prealloc, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	excise_extents (device_extension *Vcb, fcb *fcb, UINT64 start_data, UINT64 end_data, PIRP Irp, LIST_ENTRY *rollback)
chunk *	get_chunk_from_address (device_extension *Vcb, UINT64 address)
NTSTATUS	alloc_chunk (device_extension *Vcb, UINT64 flags, chunk **pc, BOOL full_size)
NTSTATUS	write_data (_In_ device_extension *Vcb, _In_ UINT64 address, _In_reads_bytes_(length) void *data, _In_ UINT32 length, _In_ write_data_context *wtc, _In_opt_ PIRP Irp, _In_opt_ chunk *c, _In_ BOOL file_write, _In_ UINT64 irp_offset, _In_ ULONG priority)
NTSTATUS	write_data_complete (device_extension *Vcb, UINT64 address, void *data, UINT32 length, PIRP Irp, chunk *c, BOOL file_write, UINT64 irp_offset, ULONG priority)
void	free_write_data_stripes (write_data_context *wtc)
	_Dispatch_type_ (IRP_MJ_WRITE) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI 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 start_data, UINT64 end_data, void *data, PIRP Irp, BOOL file_write, UINT32 irp_offset, LIST_ENTRY *rollback)
NTSTATUS	write_compressed (fcb *fcb, UINT64 start_data, UINT64 end_data, void *data, PIRP Irp, LIST_ENTRY *rollback)
BOOL	find_data_address_in_chunk (device_extension *Vcb, chunk *c, UINT64 length, UINT64 *address)
void	get_raid56_lock_range (chunk *c, UINT64 address, UINT64 length, UINT64 *lockaddr, UINT64 *locklen)
NTSTATUS	calc_csum (_In_ device_extension *Vcb, _In_reads_bytes_(sectors *Vcb->superblock.sector_size) UINT8 *data, _In_ UINT32 sectors, _Out_writes_bytes_(sectors *sizeof(UINT32)) UINT32 *csum)
void	add_insert_extent_rollback (LIST_ENTRY *rollback, fcb *fcb, extent *ext)
NTSTATUS	add_extent_to_fcb (_In_ fcb *fcb, _In_ UINT64 offset, _In_reads_bytes_(edsize) EXTENT_DATA *ed, _In_ UINT16 edsize, _In_ BOOL unique, _In_opt_ _When_(return >=0, __drv_aliasesMem) UINT32 *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 NTAPI drv_directory_control(IN PDEVICE_OBJECT DeviceObject
ULONG	get_reparse_tag (device_extension *Vcb, root *subvol, UINT64 inode, UINT8 type, ULONG atts, BOOL lxss, PIRP Irp)
ULONG	get_reparse_tag_fcb (fcb *fcb)
	_Dispatch_type_ (IRP_MJ_QUERY_SECURITY) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI drv_query_security(IN PDEVICE_OBJECT DeviceObject
	_Dispatch_type_ (IRP_MJ_SET_SECURITY) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI 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 uid)
void	add_group_mapping (WCHAR *sidstring, ULONG sidstringlength, UINT32 gid)
UINT32	sid_to_uid (PSID sid)
NTSTATUS	uid_to_sid (UINT32 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 NTAPI drv_set_information(IN PDEVICE_OBJECT DeviceObject
	_Dispatch_type_ (IRP_MJ_QUERY_INFORMATION) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI drv_query_information(IN PDEVICE_OBJECT DeviceObject
	_Dispatch_type_ (IRP_MJ_QUERY_EA) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI drv_query_ea(IN PDEVICE_OBJECT DeviceObject
	_Dispatch_type_ (IRP_MJ_SET_EA) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI 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 end, fcb *fcb, file_ref *fileref, BOOL advance_only)
NTSTATUS	fileref_get_filename (file_ref *fileref, PUNICODE_STRING fn, USHORT *name_offset, ULONG *preqlen)
NTSTATUS	open_fileref_by_inode (_Requires_exclusive_lock_held_(_Curr_->fcb_lock) device_extension *Vcb, root *subvol, UINT64 inode, file_ref **pfr, PIRP Irp)
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 NTAPI 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 inode, UINT8 type, PANSI_STRING utf8, fcb *parent, fcb **pfcb, POOL_TYPE pooltype, PIRP Irp)
NTSTATUS	load_csum (_Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, UINT32 *csum, UINT64 start, UINT64 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 inode, BOOL subvol, PANSI_STRING utf8, PUNICODE_STRING name, UINT8 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 *inode, dir_child **pdc, BOOL case_sensitive)
UINT32	inherit_mode (fcb *parfcb, BOOL is_dir)
file_ref *	create_fileref (device_extension *Vcb)
NTSTATUS	fsctl_request (PDEVICE_OBJECT DeviceObject, PIRP *Pirp, UINT32 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	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_ UINT64 address, _In_reads_bytes_(length) void *data, _In_ UINT32 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 address, ULONG length, UINT32 *csum, PIRP Irp)
BOOL	find_metadata_address_in_chunk (device_extension *Vcb, chunk *c, UINT64 *address)
void	add_trim_entry_avoid_sb (device_extension *Vcb, device *dev, UINT64 address, UINT64 size)
NTSTATUS	insert_tree_item_batch (LIST_ENTRY *batchlist, device_extension *Vcb, root *r, UINT64 objid, UINT8 objtype, UINT64 offset, _In_opt_ _When_(return >=0, __drv_aliasesMem) void *data, UINT16 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 NTAPI drv_read(PDEVICE_OBJECT DeviceObject
NTSTATUS	read_data (_In_ device_extension *Vcb, _In_ UINT64 addr, _In_ UINT32 length, _In_reads_bytes_opt_(length *sizeof(UINT32)/Vcb->superblock.sector_size) UINT32 *csum, _In_ BOOL is_tree, _Out_writes_bytes_(length) UINT8 *buf, _In_opt_ chunk *c, _Out_opt_ chunk **pc, _In_opt_ PIRP Irp, _In_ UINT64 generation, _In_ BOOL file_read, _In_ ULONG priority)
NTSTATUS	read_file (fcb *fcb, UINT8 *data, UINT64 start, UINT64 length, ULONG *pbr, PIRP Irp)
NTSTATUS	read_stream (fcb *fcb, UINT8 *data, UINT64 start, ULONG length, ULONG *pbr)
NTSTATUS	do_read (PIRP Irp, BOOLEAN wait, ULONG *bytes_read)
NTSTATUS	check_csum (device_extension *Vcb, UINT8 *data, UINT32 sectors, UINT32 *csum)
void	raid6_recover2 (UINT8 *sectors, UINT16 num_stripes, ULONG sector_size, UINT16 missing1, UINT16 missing2, UINT8 *out)
	_Dispatch_type_ (IRP_MJ_PNP) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI 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 offset, UINT64 size)
void	space_list_add (chunk *c, UINT64 address, UINT64 length, LIST_ENTRY *rollback)
void	space_list_add2 (LIST_ENTRY *list, LIST_ENTRY *list_size, UINT64 address, UINT64 length, chunk *c, LIST_ENTRY *rollback)
void	space_list_subtract (chunk *c, BOOL deleting, UINT64 address, UINT64 length, LIST_ENTRY *rollback)
void	space_list_subtract2 (LIST_ENTRY *list, LIST_ENTRY *list_size, UINT64 address, UINT64 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 address, UINT64 size, UINT64 root, UINT64 inode, UINT64 offset, UINT32 refcount, PIRP Irp)
NTSTATUS	decrease_extent_refcount_data (device_extension *Vcb, UINT64 address, UINT64 size, UINT64 root, UINT64 inode, UINT64 offset, UINT32 refcount, BOOL superseded, PIRP Irp)
NTSTATUS	decrease_extent_refcount_tree (device_extension *Vcb, UINT64 address, UINT64 size, UINT64 root, UINT8 level, PIRP Irp)
UINT64	get_extent_refcount (device_extension *Vcb, UINT64 address, UINT64 size, PIRP Irp)
BOOL	is_extent_unique (device_extension *Vcb, UINT64 address, UINT64 size, PIRP Irp)
NTSTATUS	increase_extent_refcount (device_extension *Vcb, UINT64 address, UINT64 size, UINT8 type, void *data, KEY *firstitem, UINT8 level, PIRP Irp)
UINT64	get_extent_flags (device_extension *Vcb, UINT64 address, PIRP Irp)
void	update_extent_flags (device_extension *Vcb, UINT64 address, UINT64 flags, PIRP Irp)
NTSTATUS	update_changed_extent_ref (device_extension *Vcb, chunk *c, UINT64 address, UINT64 size, UINT64 root, UINT64 objid, UINT64 offset, INT32 count, BOOL no_csum, BOOL superseded, PIRP Irp)
void	add_changed_extent_ref (chunk *c, UINT64 address, UINT64 size, UINT64 root, UINT64 objid, UINT64 offset, UINT32 count, BOOL no_csum)
UINT64	find_extent_shared_tree_refcount (device_extension *Vcb, UINT64 address, UINT64 parent, PIRP Irp)
UINT32	find_extent_shared_data_refcount (device_extension *Vcb, UINT64 address, UINT64 parent, PIRP Irp)
NTSTATUS	decrease_extent_refcount (device_extension *Vcb, UINT64 address, UINT64 size, UINT8 type, void *data, KEY *firstitem, UINT8 level, UINT64 parent, BOOL superseded, PIRP Irp)
UINT64	get_extent_data_ref_hash2 (UINT64 root, UINT64 objid, UINT64 offset)
void	do_read_job (PIRP Irp)
void	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 *inbuf, UINT32 inlen, UINT8 *outbuf, UINT32 outlen)
NTSTATUS	lzo_decompress (UINT8 *inbuf, UINT32 inlen, UINT8 *outbuf, UINT32 outlen, UINT32 inpageoff)
NTSTATUS	zstd_decompress (UINT8 *inbuf, UINT32 inlen, UINT8 *outbuf, UINT32 outlen)
NTSTATUS	write_compressed_bit (fcb *fcb, UINT64 start_data, UINT64 end_data, void *data, BOOL *compressed, PIRP Irp, LIST_ENTRY *rollback)
void	galois_double (UINT8 *data, UINT32 len)
void	galois_divpower (UINT8 *data, UINT8 div, UINT32 readlen)
UINT8	gpow2 (UINT8 e)
UINT8	gmul (UINT8 a, UINT8 b)
UINT8	gdiv (UINT8 a, UINT8 b)
	_Dispatch_type_ (IRP_MJ_DEVICE_CONTROL) _Function_class_(DRIVER_DISPATCH) NTSTATUS NTAPI drv_device_control(IN PDEVICE_OBJECT DeviceObject
NTSTATUS	add_calc_job (device_extension *Vcb, UINT8 *data, UINT32 sectors, UINT32 *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)
NTSTATUS	vol_power (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
void	add_volume_device (superblock *sb, PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath, UINT64 length, ULONG disk_num, ULONG part_num)
NTSTATUS	mountmgr_add_drive_letter (PDEVICE_OBJECT mountmgr, PUNICODE_STRING devpath)
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)
static __inline void	print_open_trees (device_extension *Vcb)
static __inline BOOL	write_fcb_compressed (fcb *fcb)
static __inline void	do_xor (UINT8 *buf1, UINT8 *buf2, UINT32 len)
static __inline UINT64	fcb_alloc_size (fcb *fcb)
BOOLEAN	RtlIsNtDdiVersionAvailable (ULONG Version)
PEPROCESS	PsGetThreadProcess (_In_ PETHREAD Thread)

Variables
_In_ UINT64	a
return	n
_In_ UINT16	len
_In_ UINT16 _Out_ ULONG *	atts
BOOL	have_sse2
UINT32	mount_compress
UINT32	mount_compress_force
UINT32	mount_compress_type
UINT32	mount_zlib_level
UINT32	mount_zstd_level
UINT32	mount_flush_interval
UINT32	mount_max_inline
UINT32	mount_skip_balance
UINT32	mount_no_barrier
UINT32	mount_no_trim
UINT32	mount_clear_cache
UINT32	mount_allow_degraded
UINT32	mount_readonly
UINT32	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	start_data
_In_ fcb _In_ chunk _In_ UINT64 _In_ UINT64	length
_In_ fcb _In_ chunk _In_ UINT64 _In_ UINT64 _In_ BOOL	prealloc
_In_ fcb _In_ chunk _In_ UINT64 _In_ UINT64 _In_ BOOL _In_opt_ void *	data
_In_ fcb _In_ chunk _In_ UINT64 _In_ UINT64 _In_ BOOL _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY *	rollback
_In_ fcb _In_ chunk _In_ UINT64 _In_ UINT64 _In_ BOOL _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ UINT8	compression = compression
_In_ fcb _In_ chunk _In_ UINT64 _In_ UINT64 _In_ BOOL _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ UINT8 _In_ UINT64	decoded_size = decoded_size
_In_ fcb _In_ chunk _In_ UINT64 _In_ UINT64 _In_ BOOL _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ UINT8 _In_ UINT64 _In_ BOOL	file_write
_In_ fcb _In_ chunk _In_ UINT64 _In_ UINT64 _In_ BOOL _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ UINT8 _In_ UINT64 _In_ BOOL _In_ UINT64	irp_offset

Macro Definition Documentation

__drv_aliasesMem

#define __drv_aliasesMem

Definition at line 167 of file btrfs_drv.h.

__S_IFBLK

#define __S_IFBLK   0060000 /* Block device. */

Definition at line 1694 of file btrfs_drv.h.

__S_IFCHR

#define __S_IFCHR   0020000 /* Character device. */

Definition at line 1693 of file btrfs_drv.h.

__S_IFDIR

#define __S_IFDIR   0040000 /* Directory. */

Definition at line 1692 of file btrfs_drv.h.

__S_IFIFO

#define __S_IFIFO   0010000 /* FIFO. */

Definition at line 1696 of file btrfs_drv.h.

__S_IFLNK

#define __S_IFLNK   0120000 /* Symbolic link. */

Definition at line 1697 of file btrfs_drv.h.

__S_IFMT

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

Definition at line 1691 of file btrfs_drv.h.

__S_IFREG

#define __S_IFREG   0100000 /* Regular file. */

Definition at line 1695 of file btrfs_drv.h.

__S_IFSOCK

#define __S_IFSOCK   0140000 /* Socket. */

Definition at line 1698 of file btrfs_drv.h.

__S_ISTYPE

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

Definition at line 1699 of file btrfs_drv.h.

_Acquires_exclusive_lock_

#define _Acquires_exclusive_lock_

(

a

)

Definition at line 180 of file btrfs_drv.h.

_Acquires_shared_lock_

#define _Acquires_shared_lock_

(

a

)

Definition at line 181 of file btrfs_drv.h.

_Create_lock_level_

#define _Create_lock_level_

(

a

)

Definition at line 176 of file btrfs_drv.h.

_CRT_SECURE_NO_WARNINGS

#define _CRT_SECURE_NO_WARNINGS

Definition at line 27 of file btrfs_drv.h.

_Dispatch_type_

#define _Dispatch_type_

(

a

)

Definition at line 175 of file btrfs_drv.h.

_Has_lock_level_

#define _Has_lock_level_

(

a

)

Definition at line 178 of file btrfs_drv.h.

_Lock_level_order_

#define _Lock_level_order_	(		a,
			b
	)

Definition at line 177 of file btrfs_drv.h.

_NO_CRT_STDIO_INLINE

#define _NO_CRT_STDIO_INLINE

Definition at line 28 of file btrfs_drv.h.

_Out_writes_bytes_opt_

#define _Out_writes_bytes_opt_

(

a

)

Definition at line 171 of file btrfs_drv.h.

_Post_satisfies_

#define _Post_satisfies_

(

a

)

Definition at line 173 of file btrfs_drv.h.

_Pre_satisfies_

#define _Pre_satisfies_

(

a

)

Definition at line 172 of file btrfs_drv.h.

_Releases_exclusive_lock_

#define _Releases_exclusive_lock_

(

a

)

Definition at line 174 of file btrfs_drv.h.

_Releases_lock_

#define _Releases_lock_

(

a

)

Definition at line 170 of file btrfs_drv.h.

_Requires_exclusive_lock_held_

#define _Requires_exclusive_lock_held_

(

a

)

Definition at line 169 of file btrfs_drv.h.

_Requires_lock_held_

#define _Requires_lock_held_

(

a

)

Definition at line 168 of file btrfs_drv.h.

_Requires_lock_not_held_

#define _Requires_lock_not_held_

(

a

)

Definition at line 179 of file btrfs_drv.h.

_WIN32_WINNT

#define _WIN32_WINNT   0x0601

Definition at line 25 of file btrfs_drv.h.

acquire_chunk_lock

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

Definition at line 1108 of file btrfs_drv.h.

ALLOC_TAG

#define ALLOC_TAG   0x7442484D

Definition at line 86 of file btrfs_drv.h.

ALLOC_TAG_ZLIB

#define ALLOC_TAG_ZLIB   0x7A42484D

Definition at line 87 of file btrfs_drv.h.

BALANCE_OPTS_DATA

#define BALANCE_OPTS_DATA   0

Definition at line 654 of file btrfs_drv.h.

BALANCE_OPTS_METADATA

#define BALANCE_OPTS_METADATA   1

Definition at line 655 of file btrfs_drv.h.

BALANCE_OPTS_SYSTEM

#define BALANCE_OPTS_SYSTEM   2

Definition at line 656 of file btrfs_drv.h.

BTRFS_NODE_TYPE_CCB

#define BTRFS_NODE_TYPE_CCB   0x2295

Definition at line 83 of file btrfs_drv.h.

BTRFS_NODE_TYPE_FCB

#define BTRFS_NODE_TYPE_FCB   0x2296

Definition at line 84 of file btrfs_drv.h.

BTRFS_VOLUME_PREFIX

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

Definition at line 119 of file btrfs_drv.h.

CC_ENABLE_DISK_IO_ACCOUNTING

#define CC_ENABLE_DISK_IO_ACCOUNTING   0x00000010

Definition at line 1783 of file btrfs_drv.h.

COMPRESSED_EXTENT_SIZE

#define COMPRESSED_EXTENT_SIZE   0x20000

Definition at line 108 of file btrfs_drv.h.

EA_DOSATTRIB

#define EA_DOSATTRIB   "user.DOSATTRIB"

Definition at line 95 of file btrfs_drv.h.

EA_DOSATTRIB_HASH

#define EA_DOSATTRIB_HASH   0x914f9939

Definition at line 96 of file btrfs_drv.h.

EA_EA

#define EA_EA   "user.EA"

Definition at line 101 of file btrfs_drv.h.

EA_EA_HASH

#define EA_EA_HASH   0x8270dd43

Definition at line 102 of file btrfs_drv.h.

EA_NTACL

#define EA_NTACL   "security.NTACL"

Definition at line 92 of file btrfs_drv.h.

EA_NTACL_HASH

#define EA_NTACL_HASH   0x45922146

Definition at line 93 of file btrfs_drv.h.

EA_PROP_COMPRESSION

#define EA_PROP_COMPRESSION   "btrfs.compression"

Definition at line 104 of file btrfs_drv.h.

EA_PROP_COMPRESSION_HASH

#define EA_PROP_COMPRESSION_HASH   0x20ccdf69

Definition at line 105 of file btrfs_drv.h.

EA_REPARSE

#define EA_REPARSE   "user.reparse"

Definition at line 98 of file btrfs_drv.h.

EA_REPARSE_HASH

#define EA_REPARSE_HASH   0xfabad1fe

Definition at line 99 of file btrfs_drv.h.

ERR

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

Definition at line 1190 of file btrfs_drv.h.

except

#define except

(

x

)

if (0 && (x))

Definition at line 127 of file btrfs_drv.h.

fast_io_possible

#define fast_io_possible

(

fcb

)

(!FsRtlAreThereCurrentFileLocks(&fcb->lock) && !fcb->Vcb->readonly ? FastIoIsPossible : FastIoIsQuestionable)

Definition at line 1605 of file btrfs_drv.h.

FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL

#define FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL   0x00020000

Definition at line 136 of file btrfs_drv.h.

FILE_SUPPORTS_BLOCK_REFCOUNTING

#define FILE_SUPPORTS_BLOCK_REFCOUNTING   0x08000000

Definition at line 132 of file btrfs_drv.h.

finally

#define finally   if (1)

Definition at line 128 of file btrfs_drv.h.

FIXME

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

Definition at line 1189 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 146 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 162 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 163 of file btrfs_drv.h.

funcname

#define funcname   __func__

Definition at line 1136 of file btrfs_drv.h.

GID_NOBODY

#define GID_NOBODY   65534

Definition at line 90 of file btrfs_drv.h.

hex_digit

#define hex_digit

(

c

)

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

Definition at line 1686 of file btrfs_drv.h.

increase_fileref_refcount

#define increase_fileref_refcount

(

fileref

)

InterlockedIncrement(&fileref->refcount)

Definition at line 1677 of file btrfs_drv.h.

int3

#define int3   asm("int3;")

Definition at line 1683 of file btrfs_drv.h.

IO_REPARSE_TAG_LXSS_BLOCKDEV

#define IO_REPARSE_TAG_LXSS_BLOCKDEV   0x80000026

Definition at line 117 of file btrfs_drv.h.

IO_REPARSE_TAG_LXSS_CHARDEV

#define IO_REPARSE_TAG_LXSS_CHARDEV   0x80000025

Definition at line 116 of file btrfs_drv.h.

IO_REPARSE_TAG_LXSS_FIFO

#define IO_REPARSE_TAG_LXSS_FIFO   0x80000024

Definition at line 115 of file btrfs_drv.h.

IO_REPARSE_TAG_LXSS_SOCKET

#define IO_REPARSE_TAG_LXSS_SOCKET   0x80000023

Definition at line 114 of file btrfs_drv.h.

IO_REPARSE_TAG_LXSS_SYMLINK

#define IO_REPARSE_TAG_LXSS_SYMLINK   0xa000001d

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

major

#define major

(

rdev

)

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

Definition at line 1759 of file btrfs_drv.h.

makedev

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

Definition at line 1603 of file btrfs_drv.h.

MAX_EXTENT_SIZE

#define MAX_EXTENT_SIZE   0x8000000

Definition at line 107 of file btrfs_drv.h.

minor

#define minor

(

rdev

)

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

Definition at line 1760 of file btrfs_drv.h.

NTDDI_VERSION

#define NTDDI_VERSION   0x06020000

Definition at line 26 of file btrfs_drv.h.

READ_AHEAD_GRANULARITY

#define READ_AHEAD_GRANULARITY   COMPRESSED_EXTENT_SIZE

Definition at line 110 of file btrfs_drv.h.

release_chunk_lock

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

Definition at line 1109 of file btrfs_drv.h.

S_IRGRP

#define S_IRGRP   (S_IRUSR >> 3)

Definition at line 1723 of file btrfs_drv.h.

S_IROTH

#define S_IROTH   (S_IRGRP >> 3)

Definition at line 1735 of file btrfs_drv.h.

S_IRUSR

#define S_IRUSR   0000400

Definition at line 1706 of file btrfs_drv.h.

S_ISDIR

#define S_ISDIR

(

mode

)

__S_ISTYPE((mode), __S_IFDIR)

Definition at line 1702 of file btrfs_drv.h.

S_ISGID

#define S_ISGID   0002000

Definition at line 1751 of file btrfs_drv.h.

S_ISUID

#define S_ISUID   0004000

Definition at line 1747 of file btrfs_drv.h.

S_ISVTX

#define S_ISVTX   0001000

Definition at line 1755 of file btrfs_drv.h.

S_IWGRP

#define S_IWGRP   (S_IWUSR >> 3)

Definition at line 1727 of file btrfs_drv.h.

S_IWOTH

#define S_IWOTH   (S_IWGRP >> 3)

Definition at line 1739 of file btrfs_drv.h.

S_IWUSR

#define S_IWUSR   0000200

Definition at line 1710 of file btrfs_drv.h.

S_IXGRP

#define S_IXGRP   (S_IXUSR >> 3)

Definition at line 1731 of file btrfs_drv.h.

S_IXOTH

#define S_IXOTH   (S_IXGRP >> 3)

Definition at line 1743 of file btrfs_drv.h.

S_IXUSR

#define S_IXUSR   0000100

Definition at line 1714 of file btrfs_drv.h.

TRACE

#define TRACE	(		s,
			...
	)

Definition at line 1187 of file btrfs_drv.h.

try

#define try   if (1)

Definition at line 126 of file btrfs_drv.h.

UID_NOBODY

#define UID_NOBODY   65534

Definition at line 89 of file btrfs_drv.h.

UNUSED

#define UNUSED

(

x

)

(void)(x)

Definition at line 81 of file btrfs_drv.h.

VCB_TYPE_CONTROL

#define VCB_TYPE_CONTROL   2

Definition at line 628 of file btrfs_drv.h.

VCB_TYPE_FS

#define VCB_TYPE_FS   1

Definition at line 627 of file btrfs_drv.h.

VCB_TYPE_PDO

#define VCB_TYPE_PDO   4

Definition at line 630 of file btrfs_drv.h.

VCB_TYPE_VOLUME

#define VCB_TYPE_VOLUME   3

Definition at line 629 of file btrfs_drv.h.

WARN

#define WARN	(		s,
			...
	)

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

fcb_nonpaged

typedef struct _fcb_nonpaged fcb_nonpaged

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

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 1830 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(* tCcCopyReadEx) (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, ULONG Length, BOOLEAN Wait, PVOID Buffer, PIO_STATUS_BLOCK IoStatus, PETHREAD IoIssuerThread)

Definition at line 1779 of file btrfs_drv.h.

tCcCopyWriteEx

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

Definition at line 1776 of file btrfs_drv.h.

tCcSetAdditionalCacheAttributesEx

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

Definition at line 1786 of file btrfs_drv.h.

tFsRtlUpdateDiskCounters

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

Definition at line 1788 of file btrfs_drv.h.

tPsIsDiskCountersEnabled

typedef BOOLEAN(* tPsIsDiskCountersEnabled) ()

Definition at line 1771 of file btrfs_drv.h.

tPsUpdateDiskCounters

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

Definition at line 1773 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 436 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 240 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 1218 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 866 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/2]

_Function_class_

(

KSTART_ROUTINE

)

Definition at line 3029 of file balance.c.

                                   {
#else
void NTAPI balance_thread(void* context) {
#endif
    device_extension* Vcb = (device_extension*)context;
    LIST_ENTRY chunks;
    LIST_ENTRY* le;
    UINT64 num_chunks[3], okay_metadata_chunks = 0, okay_data_chunks = 0, okay_system_chunks = 0;
    UINT64 old_data_flags = 0, old_metadata_flags = 0, old_system_flags = 0;
    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 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 %llx\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 %llx\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 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_() [2/2]

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

                                                                    {
#ifdef DEBUG_STATS
    LARGE_INTEGER time1, time2;

    if (ExAcquireResourceSharedLite(&Vcb->fcb_lock, FALSE))
        return;

    time1 = KeQueryPerformanceCounter(NULL);
#endif

    ExAcquireResourceSharedLite(&Vcb->fcb_lock, TRUE);

#ifdef DEBUG_STATS
    time2 = KeQueryPerformanceCounter(NULL);
    Vcb->stats.fcb_lock_time += time2.QuadPart - time1.QuadPart;
#endif
}

_Success_()

_Success_

(

return

)

add_calc_job()

NTSTATUS add_calc_job	(	device_extension *	Vcb,
		UINT8 *	data,
		UINT32	sectors,
		UINT32 *	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	address,
		UINT64	size,
		UINT64	root,
		UINT64	objid,
		UINT64	offset,
		UINT32	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	address,
		ULONG	length,
		UINT32 *	csum,
		PIRP	Irp
	)

Definition at line 2438 of file flushthread.c.

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

    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 off = address;
            UINT32* data = csum;

            do {
                UINT16 il = (UINT16)min(length2, MAX_CSUM_SIZE / sizeof(UINT32));

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

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

                Status = insert_tree_item(Vcb, Vcb->checksum_root, EXTENT_CSUM_ID, TYPE_EXTENT_CSUM, off, checksums,
                                          il * sizeof(UINT32), 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 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)) >= 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);

        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 %llx (%x sectors)\n", address, length);
        TRACE("startaddr = %llx\n", startaddr);
        TRACE("endaddr = %llx\n", endaddr);

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

        checksums = ExAllocatePoolWithTag(PagedPool, sizeof(UINT32) * 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), 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));
                }

                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));
            RtlClearBits(&bmp, (ULONG)((address - startaddr) / Vcb->superblock.sector_size), length);
        }

        runlength = RtlFindFirstRunClear(&bmp, &index);

        while (runlength != 0) {
            do {
                UINT16 rl;
                UINT64 off;
                UINT32* data;

                if (runlength * sizeof(UINT32) > MAX_CSUM_SIZE)
                    rl = MAX_CSUM_SIZE / sizeof(UINT32);
                else
                    rl = (UINT16)runlength;

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

                RtlCopyMemory(data, &checksums[index], sizeof(UINT32) * 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) * 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	inode,
		BOOL	subvol,
		PANSI_STRING	utf8,
		PUNICODE_STRING	name,
		UINT8	type,
		dir_child **	pdc
	)

Definition at line 1586 of file create.c.

                                                                                                                                  {
    NTSTATUS Status;
    dir_child* dc;

    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*)dc->name.Buffer, dc->name.Length);
    dc->hash_uc = calc_crc32c(0xffffffff, (UINT8*)dc->name_uc.Buffer, dc->name_uc.Length);

    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);

    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 2359 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	offset,
		_In_reads_bytes_(edsize) EXTENT_DATA *	ed,
		_In_ UINT16	edsize,
		_In_ BOOL	unique,
		_In_opt_ _When_(return >=0, __drv_aliasesMem) UINT32 *	csum,
		_In_ LIST_ENTRY *	rollback
	)

Definition at line 2728 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(), truncate_file(), write_file2(), and zero_data().

add_group_mapping()

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

Definition at line 145 of file security.c.

                                                                            {
    unsigned int i, np;
    UINT8 numdashes;
    UINT64 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)val, i, sidstringlength);

        if (np == 0) {
            sid->auth[0] = (UINT8)((val & 0xff0000000000) >> 40);
            sid->auth[1] = (UINT8)((val & 0xff00000000) >> 32);
            sid->auth[2] = (UINT8)((val & 0xff000000) >> 24);
            sid->auth[3] = (UINT8)((val & 0xff0000) >> 16);
            sid->auth[4] = (UINT8)((val & 0xff00) >> 8);
            sid->auth[5] = val & 0xff;
        } else
            sid->nums[np-1] = (UINT32)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 2709 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 817 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	offset,
		UINT64	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) {
            op = IoReadAccess;
            len = IrpSp->Parameters.Write.Length;
        } else {
            ERR("unexpected major function %u\n", IrpSp->MajorFunction);
            ExFreePool(ji);
            return FALSE;
        }

        Mdl = IoAllocateMdl(Irp->UserBuffer, len, FALSE, FALSE, Irp);

        if (!Mdl) {
            ERR("out of memory\n");
            ExFreePool(ji);
            return FALSE;
        }

        _SEH2_TRY {
            MmProbeAndLockPages(Mdl, Irp->RequestorMode, op);
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
            ERR("MmProbeAndLockPages raised status %08x\n", _SEH2_GetExceptionCode());

            IoFreeMdl(Mdl);
            Irp->MdlAddress = NULL;
            ExFreePool(ji);

            _SEH2_YIELD(return FALSE);
        } _SEH2_END;
    }

    ExInitializeWorkItem(&ji->item, do_job, ji);
    ExQueueWorkItem(&ji->item, DelayedWorkQueue);

    return TRUE;
}

Referenced by _Dispatch_type_().

add_trim_entry_avoid_sb()

void add_trim_entry_avoid_sb	(	device_extension *	Vcb,
		device *	dev,
		UINT64	address,
		UINT64	size
	)

Definition at line 5124 of file flushthread.c.

                                                                                              {
    int i;
    ULONG sblen = (ULONG)sector_align(sizeof(superblock), Vcb->superblock.sector_size);

    i = 0;
    while (superblock_addrs[i] != 0) {
        if (superblock_addrs[i] + sblen >= address && superblock_addrs[i] < address + size) {
            if (superblock_addrs[i] > address)
                add_trim_entry(dev, address, superblock_addrs[i] - address);

            if (size <= superblock_addrs[i] + sblen - address)
                return;

            size -= superblock_addrs[i] + sblen - address;
            address =