#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	_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	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	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	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

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, _In_ BOOL flush)

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)

	_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_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	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_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

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

#define __drv_aliasesMem

Definition at line 161 of file btrfs_drv.h.

#define __S_IFBLK 0060000 /* Block device. */

Definition at line 1659 of file btrfs_drv.h.

Referenced by mknod(), open_fcb(), and send_inode().

#define __S_IFCHR 0020000 /* Character device. */

Definition at line 1658 of file btrfs_drv.h.

Referenced by mknod(), open_fcb(), and send_inode().

#define __S_IFDIR 0040000 /* Directory. */

Definition at line 1657 of file btrfs_drv.h.

Referenced by create_directory_fcb(), create_subvol(), do_create_snapshot(), flush_refs(), mknod(), mount_vol(), open_fcb(), and send_inode().

#define __S_IFIFO 0010000 /* FIFO. */

Definition at line 1661 of file btrfs_drv.h.

Referenced by mknod(), open_fcb(), and send_inode().

#define __S_IFLNK 0120000 /* Symbolic link. */

Definition at line 1662 of file btrfs_drv.h.

Referenced by delete_reparse_point(), finish_inode(), mknod(), open_fcb(), send_extent_data(), send_inode(), and set_symlink().

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

Definition at line 1656 of file btrfs_drv.h.

#define __S_IFREG 0100000 /* Regular file. */

Definition at line 1660 of file btrfs_drv.h.

Referenced by allocate_cache_chunk(), delete_reparse_point(), mknod(), and send_inode().

#define __S_IFSOCK 0140000 /* Socket. */

Definition at line 1663 of file btrfs_drv.h.

Referenced by mknod(), open_fcb(), and send_inode().

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

Definition at line 1664 of file btrfs_drv.h.

#define _Acquires_exclusive_lock_ ( a )

Definition at line 174 of file btrfs_drv.h.

#define _Acquires_shared_lock_ ( a )

Definition at line 175 of file btrfs_drv.h.

#define _Create_lock_level_ ( a )

Definition at line 170 of file btrfs_drv.h.

#define _CRT_SECURE_NO_WARNINGS

Definition at line 27 of file btrfs_drv.h.

#define _Dispatch_type_ ( a )

Definition at line 169 of file btrfs_drv.h.

#define _Has_lock_level_ ( a )

Definition at line 172 of file btrfs_drv.h.

#define _Lock_level_order_	(	a,
		b
	)

Definition at line 171 of file btrfs_drv.h.

#define _NO_CRT_STDIO_INLINE

Definition at line 28 of file btrfs_drv.h.

#define _Out_writes_bytes_opt_ ( a )

Definition at line 165 of file btrfs_drv.h.

Referenced by DECLARE_INTERFACE_().

#define _Post_satisfies_ ( a )

Definition at line 167 of file btrfs_drv.h.

#define _Pre_satisfies_ ( a )

Definition at line 166 of file btrfs_drv.h.

#define _Releases_exclusive_lock_ ( a )

Definition at line 168 of file btrfs_drv.h.

#define _Releases_lock_ ( a )

Definition at line 164 of file btrfs_drv.h.

#define _Requires_exclusive_lock_held_ ( a )

Definition at line 163 of file btrfs_drv.h.

#define _Requires_lock_held_ ( a )

Definition at line 162 of file btrfs_drv.h.

#define _Requires_lock_not_held_ ( a )

Definition at line 173 of file btrfs_drv.h.

#define _WIN32_WINNT 0x0601

Definition at line 25 of file btrfs_drv.h.

#define ALLOC_TAG 0x7442484D

Definition at line 85 of file btrfs_drv.h.

Referenced by _Dispatch_type_(), _Function_class_(), _Success_(), add_balance_item(), add_calc_job(), add_changed_extent_ref(), add_changed_extent_ref_edr(), add_changed_extent_ref_sdr(), add_checksum_entry(), add_children_to_move_list(), add_data_reloc(), add_data_reloc_extent_item(), add_delete_inode_extref(), add_device(), add_dir_child(), add_ext_holes(), add_extent_to_fcb(), add_group_mapping(), add_insert_extent_rollback(), add_metadata_reloc(), add_metadata_reloc_extent_item(), add_parents(), add_partial_stripe(), add_pending_rmdir(), add_rollback(), add_rollback_space(), add_root_item_to_cache(), add_root_ref(), add_shared_block_extent_ref(), add_shared_data_extent_ref(), add_space_entry(), add_superblock_stripe(), add_thread_job(), add_to_bootstrap(), add_tree_block_extent_ref(), add_trim_entry(), add_user_mapping(), add_volume_device(), AddDevice(), alloc_chunk(), allocate_cache_chunk(), allow_degraded_mount(), balance_data_chunk(), bInitDefaultPalette(), bInitSURF(), bus_query_device_relations(), bus_query_hardware_ids(), check_csum(), clean_space_cache(), construct_extent_item(), create_calc_threads(), create_chunk(), create_directory_fcb(), create_fcb(), create_root(), create_snapshot(), create_stream(), create_subvol(), data_reloc_add_tree_edr(), decrease_extent_refcount(), delete_root_ref(), delete_xattr(), disk_arrival(), divide_ext(), do_create_snapshot(), do_tree_writes(), do_write_file_prealloc(), drop_chunk(), drop_root(), DrvEnablePDEV(), DrvEnableSurface(), DrvSetPalette(), DrvSetPointerShape(), duplicate_extents(), duplicate_fcb(), enqueue_pnp_callback(), excise_extents(), extend_file(), fcb_load_csums(), file_create(), file_create2(), file_desc_fcb(), file_desc_fileref(), find_device_from_uuid(), finish_removing_device(), flush_changed_dev_stats(), flush_changed_extent(), flush_disk_caches(), flush_extents(), flush_fcb(), flush_fileref(), flush_partial_stripe(), flush_refs(), flush_subvol(), found_path(), fs_ignored(), fsctl_set_xattr(), get_changed_extent_item(), get_device_pnp_name_guid(), get_registry_value(), get_reparse_block(), get_reparse_point(), get_top_level_sd(), GetAvailableModes(), getAvailableModes(), gid_to_sid(), handle_batch_collision(), if(), increase_extent_refcount(), init_cache(), init_device(), InitPointer(), InitSurface(), insert_sparse_extent(), insert_tree_extent(), insert_tree_extent_skinny(), insert_tree_item_batch(), IntInitDefaultPalette(), IntSetPalette(), invalidate_volumes(), is_btrfs_volume(), is_device_part_of_mounted_btrfs_raid(), lie_about_fs_type(), load_chunk_root(), load_default_acl(), load_dir_children(), load_free_space_cache(), load_stored_free_space_cache(), load_stored_free_space_tree(), load_sys_chunks(), load_tree(), log_error(), log_file_checksum_error(), log_file_checksum_error_shared(), log_tree_checksum_error(), log_tree_checksum_error_shared(), look_for_roots(), lzo_write_compressed_bit(), make_file_orphan(), mknod(), mount_vol(), mountmgr_add_drive_letter(), mountmgr_process_drive(), move_across_subvols(), notify_change_directory(), open_fcb(), open_fcb_stream(), open_file(), open_fileref_by_inode(), partial_stripe_read(), pdo_query_device_id(), pdo_query_hardware_ids(), prepare_raid0_write(), prepare_raid10_write(), prepare_raid5_write(), prepare_raid6_write(), query_directory(), rationalize_extents(), read_data(), read_data_dup(), read_data_raid10(), read_data_raid5(), read_data_raid6(), read_file(), read_group_mappings(), read_mappings(), read_registry(), read_superblock(), registry_load_volume_options(), registry_mark_volume_mounted(), registry_mark_volume_unmounted(), registry_mark_volume_unmounted_path(), remove_drive_letter(), remove_fcb_extent(), remove_superblocks(), remove_volume_child(), reset_subkeys(), scrub_chunk(), scrub_chunk_raid56_stripe_run(), scrub_extent(), scrub_extent_dup(), scrub_extent_raid0(), scrub_extent_raid10(), scrub_raid6_stripe(), send_add_dir(), send_disks_pnp_message(), send_extent_data(), send_inode(), send_inode_extref(), send_inode_ref(), send_notification_fcb(), send_notification_fileref(), send_subvol(), set_link_information(), set_rename_information(), set_reparse_point(), set_symlink(), set_xattr(), snapshot_tree_copy(), space_list_add2(), space_list_subtract2(), split_tree_at(), still_has_superblock(), stream_set_end_of_file_information(), sync_read_phys(), test_vol(), trim_unalloc_space(), truncate_file(), try_tree_amalgamate(), uid_to_sid(), update_changed_extent_ref(), update_chunk_cache(), update_chunk_cache_tree(), update_chunk_usage(), update_dev_item(), update_extent_level(), update_root_backref(), verify_device(), VGADDI_AllocSavedScreenBits(), VGADDI_InitializeOffScreenMem(), vol_get_disk_extents(), vol_read(), write_data(), write_file2(), write_metadata_items(), write_superblock(), write_trees(), zero_data(), and zlib_write_compressed_bit().

#define ALLOC_TAG_ZLIB 0x7A42484D

Definition at line 86 of file btrfs_drv.h.

Referenced by zlib_alloc().

#define BALANCE_OPTS_DATA 0

Definition at line 646 of file btrfs_drv.h.

Referenced by _Function_class_(), add_balance_item(), look_for_balance_item(), query_balance(), and start_balance().

#define BALANCE_OPTS_METADATA 1

Definition at line 647 of file btrfs_drv.h.

Referenced by _Function_class_(), add_balance_item(), look_for_balance_item(), query_balance(), and start_balance().

#define BALANCE_OPTS_SYSTEM 2

Definition at line 648 of file btrfs_drv.h.

Referenced by _Function_class_(), add_balance_item(), look_for_balance_item(), query_balance(), and start_balance().

#define BTRFS_NODE_TYPE_CCB 0x2295

Definition at line 82 of file btrfs_drv.h.

Referenced by _Dispatch_type_(), file_create(), mount_vol(), and open_file().

#define BTRFS_NODE_TYPE_FCB 0x2296

Definition at line 83 of file btrfs_drv.h.

Referenced by create_fcb().

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

Definition at line 113 of file btrfs_drv.h.

Referenced by AddDevice(), and is_btrfs_volume().

#define CC_ENABLE_DISK_IO_ACCOUNTING 0x00000010

Definition at line 1744 of file btrfs_drv.h.

Referenced by FatInitializeCacheMap(), and init_file_cache().

#define COMPRESSED_EXTENT_SIZE 0x20000

Definition at line 107 of file btrfs_drv.h.

Referenced by write_compressed(), write_file2(), and zero_data().

#define EA_DOSATTRIB "user.DOSATTRIB"

Definition at line 94 of file btrfs_drv.h.

#define EA_DOSATTRIB_HASH 0x914f9939

Definition at line 95 of file btrfs_drv.h.

Referenced by flush_fcb(), get_file_attributes(), and open_fcb().

#define EA_EA "user.EA"

Definition at line 100 of file btrfs_drv.h.

#define EA_EA_HASH 0x8270dd43

Definition at line 101 of file btrfs_drv.h.

Referenced by flush_fcb(), get_ea_len(), and open_fcb().

#define EA_NTACL "security.NTACL"

Definition at line 91 of file btrfs_drv.h.

#define EA_NTACL_HASH 0x45922146

Definition at line 92 of file btrfs_drv.h.

Referenced by fcb_get_sd(), flush_fcb(), and open_fcb().

#define EA_PROP_COMPRESSION "btrfs.compression"

Definition at line 103 of file btrfs_drv.h.

Referenced by flush_fcb(), fsctl_set_xattr(), and open_fcb().

#define EA_PROP_COMPRESSION_HASH 0x20ccdf69

Definition at line 104 of file btrfs_drv.h.

Referenced by flush_fcb(), and open_fcb().

#define EA_REPARSE "user.reparse"

Definition at line 97 of file btrfs_drv.h.

#define EA_REPARSE_HASH 0xfabad1fe

Definition at line 98 of file btrfs_drv.h.

Referenced by flush_fcb(), and open_fcb().

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

Definition at line 1170 of file btrfs_drv.h.

Referenced by print_open_trees().

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

Definition at line 121 of file btrfs_drv.h.

Referenced by FatCommonQueryEa(), interp_pop_except(), interp_push_except(), and thread_proc().

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

Definition at line 1570 of file btrfs_drv.h.

Referenced by _Dispatch_type_(), allocate_cache_chunk(), create_directory_fcb(), create_stream(), create_subvol(), duplicate_fcb(), file_create2(), mknod(), and open_fcb_stream().

#define FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL 0x00020000

Definition at line 130 of file btrfs_drv.h.

Referenced by AddDevice(), and test_volume_info().

#define FILE_SUPPORTS_BLOCK_REFCOUNTING 0x08000000

Definition at line 126 of file btrfs_drv.h.

Referenced by _Dispatch_type_().

#define finally if (1)

Definition at line 122 of file btrfs_drv.h.

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

Definition at line 1169 of file btrfs_drv.h.

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

Definition at line 140 of file btrfs_drv.h.

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

Definition at line 156 of file btrfs_drv.h.

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

Definition at line 157 of file btrfs_drv.h.

#define funcname __func__

Definition at line 1117 of file btrfs_drv.h.

#define GID_NOBODY 65534

Definition at line 89 of file btrfs_drv.h.

Referenced by create_directory_fcb(), create_subvol(), file_create2(), and mknod().

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

Definition at line 1651 of file btrfs_drv.h.

Referenced by AddDevice(), allow_degraded_mount(), fs_ignored(), pdo_query_device_id(), registry_load_volume_options(), registry_mark_volume_mounted(), and registry_mark_volume_unmounted().

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

Definition at line 1642 of file btrfs_drv.h.

Referenced by create_stream(), create_subvol(), do_create_snapshot(), file_create2(), mark_fileref_dirty(), mknod(), move_across_subvols(), open_file(), open_fileref(), open_fileref_by_inode(), open_fileref_child(), set_link_information(), and set_rename_information().

#define int3 asm("int3;")

Definition at line 1648 of file btrfs_drv.h.

Referenced by delete_tree_item(), do_load_tree(), do_write_file(), excise_extents(), find_next_item(), flush_fcb(), free_fileref(), insert_tree_item(), open_fileref(), split_tree_at(), test_int_widths(), try_tree_amalgamate(), write_data(), and write_trees().

#define IO_REPARSE_TAG_LXSS_SYMLINK 0xa000001d

Definition at line 111 of file btrfs_drv.h.

Referenced by get_reparse_point(), get_reparse_tag(), and set_reparse_point().

#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 984 of file btrfs_drv.h.

Referenced by _Function_class_(), add_balance_item(), add_delete_inode_extref(), add_device(), add_root_ref(), add_to_bootstrap(), allocate_cache_chunk(), commit_batch_list_root(), create_stream(), create_subvol(), decrease_extent_refcount(), delete_root_ref(), do_create_snapshot(), drop_chunk(), drop_root(), find_chunk_usage(), find_default_subvol(), find_disk_holes(), find_extent_data_refcount(), find_extent_shared_data_refcount(), find_extent_shared_tree_refcount(), find_item_in_tree(), find_subvol(), finish_removing_device(), flush_changed_dev_stats(), flush_changed_extent(), flush_fcb(), flush_subvol(), get_orphan_name(), handle_batch_collision(), increase_extent_refcount(), insert_tree_item(), insert_tree_item_batch(), is_extent_unique(), load_dir_children(), load_stored_free_space_cache(), load_stored_free_space_tree(), look_for_balance_item(), look_for_collision(), open_fcb_stream(), remove_balance_item(), send_read_symlink(), try_clone(), update_chunk_cache(), update_chunk_usage(), update_dev_item(), update_extent_level(), update_root_backref(), wait_for_flush(), and write_trees().

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

Definition at line 1568 of file btrfs_drv.h.

Referenced by get_inode_info(), and send_inode().

#define MAX_EXTENT_SIZE 0x8000000

Definition at line 106 of file btrfs_drv.h.

Referenced by insert_extent(), insert_prealloc_extent(), rationalize_extents(), and try_extend_data().

#define NTDDI_VERSION 0x06020000

Definition at line 26 of file btrfs_drv.h.

#define READ_AHEAD_GRANULARITY COMPRESSED_EXTENT_SIZE

Definition at line 109 of file btrfs_drv.h.

Referenced by _Requires_lock_held_(), Ext2WriteFile(), FFSWriteFile(), init_file_cache(), and RfsdWriteFile().

#define S_IRGRP (S_IRUSR >> 3)

Definition at line 1688 of file btrfs_drv.h.

#define S_IROTH (S_IRGRP >> 3)

Definition at line 1700 of file btrfs_drv.h.

#define S_IRUSR 0000400

Definition at line 1671 of file btrfs_drv.h.

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

Definition at line 1667 of file btrfs_drv.h.

Referenced by fcb_alloc_size().

#define S_ISGID 0002000

Definition at line 1716 of file btrfs_drv.h.

#define S_ISUID 0004000

Definition at line 1712 of file btrfs_drv.h.

#define S_ISVTX 0001000

Definition at line 1720 of file btrfs_drv.h.

#define S_IWGRP (S_IWUSR >> 3)

Definition at line 1692 of file btrfs_drv.h.

#define S_IWOTH (S_IWGRP >> 3)

Definition at line 1704 of file btrfs_drv.h.

#define S_IWUSR 0000200

Definition at line 1675 of file btrfs_drv.h.

#define S_IXGRP (S_IXUSR >> 3)

Definition at line 1696 of file btrfs_drv.h.

#define S_IXOTH (S_IXGRP >> 3)

Definition at line 1708 of file btrfs_drv.h.

#define S_IXUSR 0000100

Definition at line 1679 of file btrfs_drv.h.

#define TRACE	(	s,
		...
	)

Definition at line 1167 of file btrfs_drv.h.

#define try if (1)

Definition at line 120 of file btrfs_drv.h.

#define UID_NOBODY 65534

Definition at line 88 of file btrfs_drv.h.

Referenced by create_directory_fcb(), create_subvol(), fcb_get_new_sd(), mknod(), and sid_to_uid().

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

Definition at line 80 of file btrfs_drv.h.

Referenced by _Function_class_(), close_file(), disk_arrival(), volume_removal(), zlib_alloc(), and zlib_free().

#define VCB_TYPE_CONTROL 2

Definition at line 620 of file btrfs_drv.h.

Referenced by _Dispatch_type_(), and _Function_class_().

#define VCB_TYPE_FS 1

Definition at line 619 of file btrfs_drv.h.

Referenced by _Dispatch_type_(), and mount_vol().

#define VCB_TYPE_PDO 4

Definition at line 622 of file btrfs_drv.h.

Referenced by _Dispatch_type_(), and add_volume_device().

#define VCB_TYPE_VOLUME 3

Definition at line 621 of file btrfs_drv.h.

Referenced by _Dispatch_type_(), AddDevice(), and mount_vol().

#define WARN	(	s,
		...
	)

Definition at line 1168 of file btrfs_drv.h.

Typedef Documentation

typedef struct _ccb ccb

typedef struct _device_extension device_extension

typedef struct _DUPLICATE_EXTENTS_DATA DUPLICATE_EXTENTS_DATA

_In_ fcb * fcb

Definition at line 1289 of file btrfs_drv.h.

typedef struct _fcb_nonpaged fcb_nonpaged

typedef struct _file_ref file_ref

typedef struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER FSCTL_GET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER FSCTL_SET_INTEGRITY_INFORMATION_BUFFER

typedef struct _LDR_DATA_TABLE_ENTRY LDR_DATA_TABLE_ENTRY

typedef struct pdo_device_extension pdo_device_extension

typedef struct _DUPLICATE_EXTENTS_DATA * PDUPLICATE_EXTENTS_DATA

typedef struct _PEB PEB

typedef struct _PEB_LDR_DATA PEB_LDR_DATA

typedef struct _FSCTL_GET_INTEGRITY_INFORMATION_BUFFER * PFSCTL_GET_INTEGRITY_INFORMATION_BUFFER

typedef struct _FSCTL_SET_INTEGRITY_INFORMATION_BUFFER * PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER

typedef struct _LDR_DATA_TABLE_ENTRY* PLDR_DATA_TABLE_ENTRY

typedef struct _PEB* PPEB

typedef struct _PEB_LDR_DATA* PPEB_LDR_DATA

typedef VOID(NTAPI * PPS_POST_PROCESS_INIT_ROUTINE)(VOID)

Definition at line 1791 of file btrfs_drv.h.

typedef struct _RTL_USER_PROCESS_PARAMETERS* PRTL_USER_PROCESS_PARAMETERS

typedef struct _root root

typedef struct _root_cache root_cache

typedef struct _RTL_USER_PROCESS_PARAMETERS RTL_USER_PROCESS_PARAMETERS

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

Definition at line 1740 of file btrfs_drv.h.

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

Definition at line 1737 of file btrfs_drv.h.

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

Definition at line 1747 of file btrfs_drv.h.

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

Definition at line 1749 of file btrfs_drv.h.

typedef BOOLEAN(* tPsIsDiskCountersEnabled)()

Definition at line 1732 of file btrfs_drv.h.

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

Definition at line 1734 of file btrfs_drv.h.

typedef struct _tree tree

typedef struct _tree_data tree_data

typedef struct _volume_device_extension volume_device_extension

typedef struct _write_data_context write_data_context

Enumeration Type Documentation

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

enum prop_compression_type

Enumerator
PropCompression_None
PropCompression_Zlib
PropCompression_LZO

Definition at line 234 of file btrfs_drv.h.

                            {
     PropCompression_None,
     PropCompression_Zlib,
     PropCompression_LZO
 };

enum rollback_type

Enumerator
ROLLBACK_INSERT_EXTENT
ROLLBACK_DELETE_EXTENT
ROLLBACK_ADD_SPACE
ROLLBACK_SUBTRACT_SPACE

Definition at line 1198 of file btrfs_drv.h.

                    {
     ROLLBACK_INSERT_EXTENT,
     ROLLBACK_DELETE_EXTENT,
     ROLLBACK_ADD_SPACE,
     ROLLBACK_SUBTRACT_SPACE
 };

enum write_data_status

Enumerator
WriteDataStatus_Pending
WriteDataStatus_Success
WriteDataStatus_Error
WriteDataStatus_Cancelling
WriteDataStatus_Cancelled
WriteDataStatus_Ignore

Definition at line 855 of file btrfs_drv.h.

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

Function Documentation

_Create_lock_level_ ( tree_lock )

_Dispatch_type_ ( IRP_MJ_WRITE )

_Dispatch_type_ ( IRP_MJ_DIRECTORY_CONTROL )

_Dispatch_type_ ( IRP_MJ_QUERY_SECURITY )

_Dispatch_type_ ( IRP_MJ_SET_SECURITY )

_Dispatch_type_ ( IRP_MJ_SET_INFORMATION )

_Dispatch_type_ ( IRP_MJ_QUERY_INFORMATION )

_Dispatch_type_ ( IRP_MJ_QUERY_EA )

_Dispatch_type_ ( IRP_MJ_SET_EA )

_Dispatch_type_ ( IRP_MJ_CREATE )

_Dispatch_type_ ( IRP_MJ_READ )

_Dispatch_type_ ( IRP_MJ_PNP )

_Dispatch_type_ ( IRP_MJ_DEVICE_CONTROL )

_Function_class_ ( KSTART_ROUTINE )

Definition at line 3027 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;
 
         ExAcquireResourceExclusiveLite(&c->lock, TRUE);
 
         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);
             ExReleaseResourceLite(&c->lock);
             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;
                 ExReleaseResourceLite(&c->lock);
                 ExReleaseResourceLite(&Vcb->chunk_lock);
                 goto end;
             }
         }
 
         ExReleaseResourceLite(&c->lock);
 
         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_ ( DRIVER_NOTIFICATION_CALLBACK_ROUTINE )

_Post_satisfies_ ( return >= n )

_Releases_lock_ ( c-> lock )

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

Definition at line 939 of file btrfs_drv.h.

                                                              {
     ExReleaseResourceLite(&Vcb->fcb_lock);
 }

_Requires_lock_held_ ( c-> lock )

pure virtual

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

Definition at line 899 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_ ( return )

NTSTATUS add_calc_job	(	device_extension *	Vcb,
		UINT8 *	data,
		UINT32	sectors,
		UINT32 *	csum,
		calc_job **	pcj
	)

Definition at line 22 of file calcthread.c.

Referenced by calc_csum(), and check_csum().

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

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.

Referenced by rationalize_extents().

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

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

Definition at line 2438 of file flushthread.c.

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

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

NTSTATUS add_dir_child	(	fcb *	fcb,
		UINT64	inode,
		BOOL	subvol,
		PANSI_STRING	utf8,
		PUNICODE_STRING	name,
		UINT8	type,
		dir_child **	pdc
	)

Definition at line 1566 of file create.c.

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

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

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

Definition at line 2350 of file write.c.

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

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

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 2719 of file write.c.

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

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

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

Definition at line 145 of file security.c.

Referenced by read_group_mappings().

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

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

Definition at line 2700 of file write.c.

Referenced by add_extent_to_fcb(), and do_write_file_prealloc().

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

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

Definition at line 811 of file treefuncs.c.

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

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

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

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

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

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

BOOL add_thread_job	(	device_extension *	Vcb,
		PIRP	Irp
	)

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

Referenced by _Dispatch_type_().

                                                      {
     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 

Enumerations
enum	prop_compression_type { PropCompression_None, PropCompression_Zlib, PropCompression_LZO }

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 }

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation