btrfs.c File Reference

#include "btrfs_drv.h"
#include "xxhash.h"
#include "crc32c.h"
#include <cpuid.h>
#include <ntddscsi.h>
#include "btrfs.h"
#include <ata.h>
#include <initguid.h>
#include <ntddstor.h>
#include <ntdddisk.h>
#include <ntddvol.h>
#include <ntstrsafe.h>

Include dependency graph for btrfs.c:

Go to the source code of this file.

Classes
struct	read_context
struct	notification_fcb

Macros
#define	INCOMPAT_SUPPORTED
#define	COMPAT_RO_SUPPORTED
#define	INIT_UNICODE_STRING(var, val)   UNICODE_STRING us##var; us##var.Buffer = (WCHAR*)val; us##var.Length = us##var.MaximumLength = sizeof(val) - sizeof(WCHAR);

Functions
	DEFINE_GUID (BtrfsBusInterface, 0x4d414874, 0x6865, 0x6761, 0x6d, 0x65, 0x83, 0x69, 0x17, 0x9a, 0x7d, 0x1d)
static NTSTATUS	close_file (_In_ PFILE_OBJECT FileObject, _In_ PIRP Irp)
static void __stdcall	do_xor_basic (uint8_t *buf1, uint8_t *buf2, uint32_t len)
BOOLEAN	WdmlibRtlIsNtDdiVersionAvailable (ULONG Version)
bool	is_top_level (_In_ PIRP Irp)
	_Function_class_ (DRIVER_UNLOAD)
static bool	get_last_inode (_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ root *r, _In_opt_ PIRP Irp)
	_Success_ (return)
	_Dispatch_type_ (IRP_MJ_CLOSE)
	_Dispatch_type_ (IRP_MJ_FLUSH_BUFFERS)
static void	calculate_total_space (_In_ device_extension *Vcb, _Out_ uint64_t *totalsize, _Out_ uint64_t *freespace)
static bool	compare_strings (const UNICODE_STRING *us1, const UNICODE_STRING *us2)
static bool	lie_about_fs_type ()
NTSTATUS	utf8_to_utf16 (WCHAR *dest, ULONG dest_max, ULONG *dest_len, char *src, ULONG src_len)
NTSTATUS	utf16_to_utf8 (char *dest, ULONG dest_max, ULONG *dest_len, WCHAR *src, ULONG src_len)
	_Dispatch_type_ (IRP_MJ_QUERY_VOLUME_INFORMATION)
	_Function_class_ (IO_COMPLETION_ROUTINE)
NTSTATUS	create_root (_In_ _Requires_exclusive_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ uint64_t id, _Out_ root **rootptr, _In_ bool no_tree, _In_ uint64_t offset, _In_opt_ PIRP Irp)
static NTSTATUS	set_label (_In_ device_extension *Vcb, _In_ FILE_FS_LABEL_INFORMATION *ffli)
	_Dispatch_type_ (IRP_MJ_SET_VOLUME_INFORMATION)
void	send_notification_fileref (_In_ file_ref *fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream)
static void	send_notification_fcb (_In_ file_ref *fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream)
	_Function_class_ (IO_WORKITEM_ROUTINE)
void	queue_notification_fcb (_In_ file_ref *fileref, _In_ ULONG filter_match, _In_ ULONG action, _In_opt_ PUNICODE_STRING stream)
void	mark_fcb_dirty (_In_ fcb *fcb)
void	mark_fileref_dirty (_In_ file_ref *fileref)
void	free_fcb (_Inout_ fcb *fcb)
void	reap_fcb (fcb *fcb)
void	reap_fcbs (device_extension *Vcb)
void	free_fileref (_Inout_ file_ref *fr)
void	reap_fileref (device_extension *Vcb, file_ref *fr)
void	reap_filerefs (device_extension *Vcb, file_ref *fr)
void	uninit (_In_ device_extension *Vcb)
static NTSTATUS	delete_fileref_fcb (_In_ file_ref *fileref, _In_opt_ PFILE_OBJECT FileObject, _In_opt_ PIRP Irp, _In_ LIST_ENTRY *rollback)
NTSTATUS	delete_fileref (_In_ file_ref *fileref, _In_opt_ PFILE_OBJECT FileObject, _In_ bool make_orphan, _In_opt_ PIRP Irp, _In_ LIST_ENTRY *rollback)
	_Dispatch_type_ (IRP_MJ_CLEANUP)
ULONG	get_file_attributes (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ root *r, _In_ uint64_t inode, _In_ uint8_t type, _In_ bool dotfile, _In_ bool ignore_xa, _In_opt_ PIRP Irp)
NTSTATUS	sync_read_phys (_In_ PDEVICE_OBJECT DeviceObject, _In_ PFILE_OBJECT FileObject, _In_ uint64_t StartingOffset, _In_ ULONG Length, _Out_writes_bytes_(Length) PUCHAR Buffer, _In_ bool override)
bool	check_superblock_checksum (superblock *sb)
static NTSTATUS	read_superblock (_In_ device_extension *Vcb, _In_ PDEVICE_OBJECT device, _In_ PFILE_OBJECT fileobj, _In_ uint64_t length)
NTSTATUS	dev_ioctl (_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG ControlCode, _In_reads_bytes_opt_(InputBufferSize) PVOID InputBuffer, _In_ ULONG InputBufferSize, _Out_writes_bytes_opt_(OutputBufferSize) PVOID OutputBuffer, _In_ ULONG OutputBufferSize, _In_ bool Override, _Out_opt_ IO_STATUS_BLOCK *iosb)
	_Requires_exclusive_lock_held_ (Vcb->tree_lock) static NTSTATUS add_root(_Inout_ device_extension *Vcb
	if (!r)
	RtlZeroMemory (r->fcbs_ptrs, sizeof(LIST_ENTRY *) *256)
	if (!r->nonpaged)
	if (tp)
else RtlZeroMemory &	r (ROOT_ITEM)
	if (!Vcb->readonly &&(r->id==BTRFS_ROOT_ROOT||r->id==BTRFS_ROOT_FSTREE||(r->id >=0x100 &&!(r->id &0xf000000000000000))))
	switch (r->id)
static NTSTATUS	look_for_roots (_Requires_exclusive_lock_held_(_Curr_->tree_lock) _In_ device_extension *Vcb, _In_opt_ PIRP Irp)
static NTSTATUS	find_disk_holes (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_ device *dev, _In_opt_ PIRP Irp)
static void	add_device_to_list (_In_ device_extension *Vcb, _In_ device *dev)
_Ret_maybenull_ device *	find_device_from_uuid (_In_ device_extension *Vcb, _In_ BTRFS_UUID *uuid)
static bool	is_device_removable (_In_ PDEVICE_OBJECT devobj)
static ULONG	get_device_change_count (_In_ PDEVICE_OBJECT devobj)
void	init_device (_In_ device_extension *Vcb, _Inout_ device *dev, _In_ bool get_nums)
static NTSTATUS	load_chunk_root (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_opt_ PIRP Irp)
void	protect_superblocks (_Inout_ chunk *c)
NTSTATUS	find_chunk_usage (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_opt_ PIRP Irp)
static NTSTATUS	load_sys_chunks (_In_ device_extension *Vcb)
_Ret_maybenull_ root *	find_default_subvol (_In_ _Requires_lock_held_(_Curr_->tree_lock) device_extension *Vcb, _In_opt_ PIRP Irp)
void	init_file_cache (_In_ PFILE_OBJECT FileObject, _In_ CC_FILE_SIZES *ccfs)
uint32_t	get_num_of_processors ()
static NTSTATUS	create_calc_threads (_In_ PDEVICE_OBJECT DeviceObject)
static bool	is_btrfs_volume (_In_ PDEVICE_OBJECT DeviceObject)
static NTSTATUS	get_device_pnp_name_guid (_In_ PDEVICE_OBJECT DeviceObject, _Out_ PUNICODE_STRING pnp_name, _In_ const GUID *guid)
NTSTATUS	get_device_pnp_name (_In_ PDEVICE_OBJECT DeviceObject, _Out_ PUNICODE_STRING pnp_name, _Out_ const GUID **guid)
	_Success_ (return >=0) static NTSTATUS check_mount_device(_In_ PDEVICE_OBJECT DeviceObject
	if (!NT_SUCCESS(Status))
	if (sb->magic !=BTRFS_MAGIC)
	if (!check_superblock_checksum(sb))
static bool	still_has_superblock (_In_ PDEVICE_OBJECT device, _In_ PFILE_OBJECT fileobj)
static void	calculate_sector_shift (device_extension *Vcb)
static NTSTATUS	mount_vol (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
static NTSTATUS	verify_device (_In_ device_extension *Vcb, _Inout_ device *dev)
static NTSTATUS	verify_volume (_In_ PDEVICE_OBJECT devobj)
	_Dispatch_type_ (IRP_MJ_FILE_SYSTEM_CONTROL)
	_Dispatch_type_ (IRP_MJ_LOCK_CONTROL)
void	do_shutdown (PIRP Irp)
	_Dispatch_type_ (IRP_MJ_SHUTDOWN)
static bool	device_still_valid (device *dev, uint64_t expected_generation)
	_Dispatch_type_ (IRP_MJ_POWER)
	_Dispatch_type_ (IRP_MJ_SYSTEM_CONTROL)
NTSTATUS	check_file_name_valid (_In_ PUNICODE_STRING us, _In_ bool posix, _In_ bool stream)
void	chunk_lock_range (_In_ device_extension *Vcb, _In_ chunk *c, _In_ uint64_t start, _In_ uint64_t length)
void	chunk_unlock_range (_In_ device_extension *Vcb, _In_ chunk *c, _In_ uint64_t start, _In_ uint64_t length)
void	log_device_error (_In_ device_extension *Vcb, _Inout_ device *dev, _In_ int error)
	_Function_class_ (KSTART_ROUTINE)
	_Function_class_ (DRIVER_ADD_DEVICE)
	_Function_class_ (DRIVER_INITIALIZE)

Variables
static const WCHAR	device_name [] = {'\\','B','t','r','f','s',0}
static const WCHAR	dosdevice_name [] = {'\\','D','o','s','D','e','v','i','c','e','s','\\','B','t','r','f','s',0}
PDRIVER_OBJECT	drvobj
PDEVICE_OBJECT	master_devobj
PDEVICE_OBJECT	busobj
uint64_t	num_reads = 0
LIST_ENTRY	uid_map_list
LIST_ENTRY	gid_map_list
LIST_ENTRY	VcbList
ERESOURCE	global_loading_lock
uint32_t	debug_log_level = 0
uint32_t	mount_compress = 0
uint32_t	mount_compress_force = 0
uint32_t	mount_compress_type = 0
uint32_t	mount_zlib_level = 3
uint32_t	mount_zstd_level = 3
uint32_t	mount_flush_interval = 30
uint32_t	mount_max_inline = 2048
uint32_t	mount_skip_balance = 0
uint32_t	mount_no_barrier = 0
uint32_t	mount_no_trim = 0
uint32_t	mount_clear_cache = 0
uint32_t	mount_allow_degraded = 0
uint32_t	mount_readonly = 0
uint32_t	mount_no_root_dir = 0
uint32_t	mount_nodatacow = 0
uint32_t	no_pnp = 0
bool	log_started = false
UNICODE_STRING	log_device
UNICODE_STRING	log_file
UNICODE_STRING	registry_path
tPsUpdateDiskCounters	fPsUpdateDiskCounters
tCcCopyReadEx	fCcCopyReadEx
tCcCopyWriteEx	fCcCopyWriteEx
tCcSetAdditionalCacheAttributesEx	fCcSetAdditionalCacheAttributesEx
tFsRtlUpdateDiskCounters	fFsRtlUpdateDiskCounters
tIoUnregisterPlugPlayNotificationEx	fIoUnregisterPlugPlayNotificationEx
tFsRtlGetEcpListFromIrp	fFsRtlGetEcpListFromIrp
tFsRtlGetNextExtraCreateParameter	fFsRtlGetNextExtraCreateParameter
tFsRtlValidateReparsePointBuffer	fFsRtlValidateReparsePointBuffer
tFsRtlCheckLockForOplockRequest	fFsRtlCheckLockForOplockRequest
tFsRtlAreThereCurrentOrInProgressFileLocks	fFsRtlAreThereCurrentOrInProgressFileLocks
bool	diskacc = false
void *	notification_entry = NULL
void *	notification_entry2 = NULL
void *	notification_entry3 = NULL
ERESOURCE	pdo_list_lock
ERESOURCE	mapping_lock
LIST_ENTRY	pdo_list
bool	finished_probing = false
HANDLE	degraded_wait_handle = NULL
HANDLE	mountmgr_thread_handle = NULL
bool	degraded_wait = true
KEVENT	mountmgr_thread_event
bool	shutting_down = false
ERESOURCE	boot_lock
bool	is_windows_8
uint64_t	boot_subvol
xor_func	do_xor = do_xor_basic
_In_ uint64_t	id = id
_In_ uint64_t _In_ uint64_t	addr
_In_ uint64_t _In_ uint64_t _In_ uint64_t	generation = generation
_In_ uint64_t _In_ uint64_t _In_ uint64_t _In_opt_ traverse_ptr *	tp
r	dirty = false
r	received = false
r	reserved = NULL
r treeholder	address = addr
r treeholder	tree = NULL
r	parent = 0
r	send_ops = 0
r	fcbs_version = 0
r	checked_for_orphans = false
r	dropped = false
InitializeListHead &	r
r	nonpaged = ExAllocatePoolWithTag(NonPagedPool, sizeof(root_nonpaged), ALLOC_TAG)
r	lastinode = 0
InsertTailList &	Vcb
return	STATUS_SUCCESS
_Out_ bool *	pno_pnp
ULONG	to_read = DeviceObject->SectorSize == 0 ? sizeof(superblock) : (ULONG)sector_align(sizeof(superblock), DeviceObject->SectorSize)
superblock *	sb = ExAllocatePoolWithTag(NonPagedPool, to_read, ALLOC_TAG)
	Status = sync_read_phys(DeviceObject, NULL, superblock_addrs[0], to_read, (PUCHAR)sb, true)
end	__pad0__

Macro Definition Documentation

COMPAT_RO_SUPPORTED

#define COMPAT_RO_SUPPORTED

Value:

                             (BTRFS_COMPAT_RO_FLAGS_FREE_SPACE_CACHE | BTRFS_COMPAT_RO_FLAGS_FREE_SPACE_CACHE_VALID | \
                             BTRFS_COMPAT_RO_FLAGS_VERITY)

Definition at line 57 of file btrfs.c.

INCOMPAT_SUPPORTED

#define INCOMPAT_SUPPORTED

Value:

                            (BTRFS_INCOMPAT_FLAGS_MIXED_BACKREF | BTRFS_INCOMPAT_FLAGS_DEFAULT_SUBVOL | BTRFS_INCOMPAT_FLAGS_MIXED_GROUPS | \
                            BTRFS_INCOMPAT_FLAGS_COMPRESS_LZO | BTRFS_INCOMPAT_FLAGS_BIG_METADATA | BTRFS_INCOMPAT_FLAGS_RAID56 | \
                            BTRFS_INCOMPAT_FLAGS_EXTENDED_IREF | BTRFS_INCOMPAT_FLAGS_SKINNY_METADATA | BTRFS_INCOMPAT_FLAGS_NO_HOLES | \
                            BTRFS_INCOMPAT_FLAGS_COMPRESS_ZSTD | BTRFS_INCOMPAT_FLAGS_METADATA_UUID | BTRFS_INCOMPAT_FLAGS_RAID1C34)

Definition at line 53 of file btrfs.c.

INIT_UNICODE_STRING

#define INIT_UNICODE_STRING	(		var,
			val
	)		UNICODE_STRING us##var; us##var.Buffer = (WCHAR*)val; us##var.Length = us##var.MaximumLength = sizeof(val) - sizeof(WCHAR);

Definition at line 679 of file btrfs.c.

Function Documentation

_Dispatch_type_() [1/10]

_Dispatch_type_

(

IRP_MJ_CLEANUP

)

Definition at line 2438 of file btrfs.c.

                                                                                       {
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PFILE_OBJECT FileObject = IrpSp->FileObject;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    fcb* fcb = FileObject->FsContext;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    TRACE("cleanup\n");
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Irp->IoStatus.Information = 0;
        Status = STATUS_SUCCESS;
        goto exit;
    } else if (DeviceObject == master_devobj) {
        TRACE("closing file system\n");
        Status = STATUS_SUCCESS;
        goto exit;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto exit;
    }
 
    if (FileObject->Flags & FO_CLEANUP_COMPLETE) {
        TRACE("FileObject %p already cleaned up\n", FileObject);
        Status = STATUS_SUCCESS;
        goto exit;
    }
 
    if (!fcb) {
        ERR("fcb was NULL\n");
        Status = STATUS_INVALID_PARAMETER;
        goto exit;
    }
 
    FsRtlCheckOplock(fcb_oplock(fcb), Irp, NULL, NULL, NULL);
 
    // We have to use the pointer to Vcb stored in the fcb, as we can receive cleanup
    // messages belonging to other devices.
 
    if (FileObject && FileObject->FsContext) {
        ccb* ccb;
        file_ref* fileref;
        bool locked = true;
 
        ccb = FileObject->FsContext2;
        fileref = ccb ? ccb->fileref : NULL;
 
        TRACE("cleanup called for FileObject %p\n", FileObject);
        TRACE("fileref %p, refcount = %li, open_count = %li\n", fileref, fileref ? fileref->refcount : 0, fileref ? fileref->open_count : 0);
 
        ExAcquireResourceSharedLite(&fcb->Vcb->tree_lock, true);
 
        ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
        IoRemoveShareAccess(FileObject, &fcb->share_access);
 
        FsRtlFastUnlockAll(&fcb->lock, FileObject, IoGetRequestorProcess(Irp), NULL);
 
        if (ccb)
            FsRtlNotifyCleanup(fcb->Vcb->NotifySync, &fcb->Vcb->DirNotifyList, ccb);
 
        if (ccb && ccb->options & FILE_DELETE_ON_CLOSE && fileref)
            fileref->delete_on_close = true;
 
        if (fileref && fileref->delete_on_close && fcb->type == BTRFS_TYPE_DIRECTORY && fcb->inode_item.st_size > 0 && fcb != fcb->Vcb->dummy_fcb)
            fileref->delete_on_close = false;
 
        if (fcb->Vcb->locked && fcb->Vcb->locked_fileobj == FileObject) {
            TRACE("unlocking volume\n");
            do_unlock_volume(fcb->Vcb);
            FsRtlNotifyVolumeEvent(FileObject, FSRTL_VOLUME_UNLOCK);
        }
 
        if (ccb && ccb->reserving) {
            fcb->subvol->reserved = NULL;
            ccb->reserving = false;
            // FIXME - flush all of subvol's fcbs
        }
 
        if (fileref) {
            LONG oc = InterlockedDecrement(&fileref->open_count);
#ifdef DEBUG_FCB_REFCOUNTS
            ERR("fileref %p: open_count now %i\n", fileref, oc);
#endif
 
            if (oc == 0 || (fileref->delete_on_close && fileref->posix_delete)) {
                if (!fcb->Vcb->removing) {
                    if (oc == 0 && fileref->fcb->inode_item.st_nlink == 0 && fileref != fcb->Vcb->root_fileref &&
                        fcb != fcb->Vcb->volume_fcb && !fcb->ads) { // last handle closed on POSIX-deleted file
                        LIST_ENTRY rollback;
 
                        InitializeListHead(&rollback);
 
                        Status = delete_fileref_fcb(fileref, FileObject, Irp, &rollback);
                        if (!NT_SUCCESS(Status)) {
                            ERR("delete_fileref_fcb returned %08lx\n", Status);
                            do_rollback(fcb->Vcb, &rollback);
                            ExReleaseResourceLite(fileref->fcb->Header.Resource);
                            ExReleaseResourceLite(&fcb->Vcb->tree_lock);
                            goto exit;
                        }
 
                        clear_rollback(&rollback);
 
                        mark_fcb_dirty(fileref->fcb);
                    } else if (fileref->delete_on_close && fileref != fcb->Vcb->root_fileref && fcb != fcb->Vcb->volume_fcb) {
                        LIST_ENTRY rollback;
 
                        InitializeListHead(&rollback);
 
                        if (!fileref->fcb->ads || fileref->dc) {
                            if (fileref->fcb->ads) {
                                send_notification_fileref(fileref->parent, fcb->type == BTRFS_TYPE_DIRECTORY ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME,
                                                        FILE_ACTION_REMOVED, &fileref->dc->name);
                            } else
                                send_notification_fileref(fileref, fcb->type == BTRFS_TYPE_DIRECTORY ? FILE_NOTIFY_CHANGE_DIR_NAME : FILE_NOTIFY_CHANGE_FILE_NAME, FILE_ACTION_REMOVED, NULL);
                        }
 
                        ExReleaseResourceLite(fcb->Header.Resource);
                        locked = false;
 
                        // fileref_lock needs to be acquired before fcb->Header.Resource
                        ExAcquireResourceExclusiveLite(&fcb->Vcb->fileref_lock, true);
 
                        Status = delete_fileref(fileref, FileObject, oc > 0 && fileref->posix_delete, Irp, &rollback);
                        if (!NT_SUCCESS(Status)) {
                            ERR("delete_fileref returned %08lx\n", Status);
                            do_rollback(fcb->Vcb, &rollback);
                            ExReleaseResourceLite(&fcb->Vcb->fileref_lock);
                            ExReleaseResourceLite(&fcb->Vcb->tree_lock);
                            goto exit;
                        }
 
                        ExReleaseResourceLite(&fcb->Vcb->fileref_lock);
 
                        clear_rollback(&rollback);
                    } else if (FileObject->Flags & FO_CACHE_SUPPORTED && FileObject->SectionObjectPointer->DataSectionObject) {
                        IO_STATUS_BLOCK iosb;
 
                        if (locked) {
                            ExReleaseResourceLite(fcb->Header.Resource);
                            locked = false;
                        }
 
                        CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, &iosb);
 
                        if (!NT_SUCCESS(iosb.Status))
                            ERR("CcFlushCache returned %08lx\n", iosb.Status);
 
                        if (!ExIsResourceAcquiredSharedLite(fcb->Header.PagingIoResource)) {
                            ExAcquireResourceExclusiveLite(fcb->Header.PagingIoResource, true);
                            ExReleaseResourceLite(fcb->Header.PagingIoResource);
                        }
 
                        CcPurgeCacheSection(FileObject->SectionObjectPointer, NULL, 0, false);
 
                        TRACE("flushed cache on close (FileObject = %p, fcb = %p, AllocationSize = %I64x, FileSize = %I64x, ValidDataLength = %I64x)\n",
                            FileObject, fcb, fcb->Header.AllocationSize.QuadPart, fcb->Header.FileSize.QuadPart, fcb->Header.ValidDataLength.QuadPart);
                    }
                }
 
                if (fcb->Vcb && fcb != fcb->Vcb->volume_fcb)
                    CcUninitializeCacheMap(FileObject, NULL, NULL);
            }
        }
 
        if (locked)
            ExReleaseResourceLite(fcb->Header.Resource);
 
        ExReleaseResourceLite(&fcb->Vcb->tree_lock);
 
        FileObject->Flags |= FO_CLEANUP_COMPLETE;
    }
 
    Status = STATUS_SUCCESS;
 
exit:
    TRACE("returning %08lx\n", Status);
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [2/10]

_Dispatch_type_

(

IRP_MJ_CLOSE

)

Definition at line 503 of file btrfs.c.

                                                                                     {
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    TRACE("close\n");
 
    top_level = is_top_level(Irp);
 
    if (DeviceObject == master_devobj) {
        TRACE("Closing file system\n");
        Status = STATUS_SUCCESS;
        goto end;
    } else if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = vol_close(DeviceObject, Irp);
        goto end;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    // FIXME - call FsRtlNotifyUninitializeSync(&Vcb->NotifySync) if unmounting
 
    Status = close_file(IrpSp->FileObject, Irp);
 
end:
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
 
    IoCompleteRequest( Irp, IO_DISK_INCREMENT );
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    TRACE("returning %08lx\n", Status);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [3/10]

_Dispatch_type_

(

IRP_MJ_FILE_SYSTEM_CONTROL

)

Definition at line 5264 of file btrfs.c.

                                                                                                   {
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS Status;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    TRACE("file system control\n");
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    } else if (!Vcb || (Vcb->type != VCB_TYPE_FS && Vcb->type != VCB_TYPE_CONTROL)) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    Status = STATUS_NOT_IMPLEMENTED;
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    Irp->IoStatus.Information = 0;
 
    switch (IrpSp->MinorFunction) {
        case IRP_MN_MOUNT_VOLUME:
            TRACE("IRP_MN_MOUNT_VOLUME\n");
 
            Status = mount_vol(DeviceObject, Irp);
            break;
 
        case IRP_MN_KERNEL_CALL:
            TRACE("IRP_MN_KERNEL_CALL\n");
 
            Status = fsctl_request(DeviceObject, &Irp, IrpSp->Parameters.FileSystemControl.FsControlCode);
            break;
 
        case IRP_MN_USER_FS_REQUEST:
            TRACE("IRP_MN_USER_FS_REQUEST\n");
 
            Status = fsctl_request(DeviceObject, &Irp, IrpSp->Parameters.FileSystemControl.FsControlCode);
            break;
 
        case IRP_MN_VERIFY_VOLUME:
            TRACE("IRP_MN_VERIFY_VOLUME\n");
 
            Status = verify_volume(DeviceObject);
 
            if (!NT_SUCCESS(Status) && Vcb->Vpb->Flags & VPB_MOUNTED) {
                ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
                Vcb->removing = true;
                ExReleaseResourceLite(&Vcb->tree_lock);
            }
 
            break;
 
        default:
            break;
    }
 
end:
    TRACE("returning %08lx\n", Status);
 
    if (Irp) {
        Irp->IoStatus.Status = Status;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [4/10]

_Dispatch_type_

(

IRP_MJ_FLUSH_BUFFERS

)

Definition at line 551 of file btrfs.c.

                                                                                             {
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
    PFILE_OBJECT FileObject = IrpSp->FileObject;
    fcb* fcb = FileObject->FsContext;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    TRACE("flush buffers\n");
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_SUCCESS;
        goto end;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_SUCCESS;
        goto end;
    }
 
    if (!fcb) {
        ERR("fcb was NULL\n");
        Status = STATUS_SUCCESS;
        goto end;
    }
 
    if (fcb == Vcb->volume_fcb) {
        Status = STATUS_SUCCESS;
        goto end;
    }
 
    FsRtlCheckOplock(fcb_oplock(fcb), Irp, NULL, NULL, NULL);
 
    Irp->IoStatus.Information = 0;
 
    fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
 
    Status = STATUS_SUCCESS;
    Irp->IoStatus.Status = Status;
 
    if (fcb->type != BTRFS_TYPE_DIRECTORY) {
        CcFlushCache(FileObject->SectionObjectPointer, NULL, 0, &Irp->IoStatus);
 
        if (fcb->Header.PagingIoResource) {
            ExAcquireResourceExclusiveLite(fcb->Header.PagingIoResource, true);
            ExReleaseResourceLite(fcb->Header.PagingIoResource);
        }
 
        Status = Irp->IoStatus.Status;
    }
 
end:
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    TRACE("returning %08lx\n", Status);
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [5/10]

_Dispatch_type_

(

IRP_MJ_LOCK_CONTROL

)

Definition at line 5345 of file btrfs.c.

                                                                                            {
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    fcb* fcb = IrpSp->FileObject ? IrpSp->FileObject->FsContext : NULL;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
 
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        goto exit;
    }
 
    TRACE("lock control\n");
 
    if (!fcb) {
        ERR("fcb was NULL\n");
        Status = STATUS_INVALID_PARAMETER;
        goto exit;
    }
 
    FsRtlCheckOplock(fcb_oplock(fcb), Irp, NULL, NULL, NULL);
 
    Status = FsRtlProcessFileLock(&fcb->lock, Irp, NULL);
 
    fcb->Header.IsFastIoPossible = fast_io_possible(fcb);
 
exit:
    TRACE("returning %08lx\n", Status);
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [6/10]

_Dispatch_type_

(

IRP_MJ_POWER

)

Definition at line 5654 of file btrfs.c.

                                                                                     {
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;
 
    // no need for FsRtlEnterFileSystem, as this only ever gets called in a system thread
 
    top_level = is_top_level(Irp);
 
    Irp->IoStatus.Information = 0;
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        volume_device_extension* vde = DeviceObject->DeviceExtension;
 
        if (IrpSp->MinorFunction == IRP_MN_QUERY_POWER && IrpSp->Parameters.Power.Type == SystemPowerState &&
            IrpSp->Parameters.Power.State.SystemState != PowerSystemWorking && vde->mounted_device) {
            device_extension* Vcb2 = vde->mounted_device->DeviceExtension;
 
            /* If power state is about to go to sleep or hibernate, do a flush. We do this on IRP_MJ_QUERY_POWER
            * rather than IRP_MJ_SET_POWER because we know that the hard disks are still awake. */
 
            if (Vcb2) {
                ExAcquireResourceExclusiveLite(&Vcb2->tree_lock, true);
 
                if (Vcb2->need_write && !Vcb2->readonly) {
                    TRACE("doing protective flush on power state change\n");
                    Status = do_write(Vcb2, NULL);
                } else
                    Status = STATUS_SUCCESS;
 
                free_trees(Vcb2);
 
                if (!NT_SUCCESS(Status))
                    ERR("do_write returned %08lx\n", Status);
 
                ExReleaseResourceLite(&Vcb2->tree_lock);
            }
        } else if (IrpSp->MinorFunction == IRP_MN_SET_POWER && IrpSp->Parameters.Power.Type == SystemPowerState &&
            IrpSp->Parameters.Power.State.SystemState == PowerSystemWorking && vde->mounted_device) {
            device_extension* Vcb2 = vde->mounted_device->DeviceExtension;
 
            /* If waking up, make sure that the FS hasn't been changed while we've been out (e.g., by dual-boot Linux) */
 
            if (Vcb2) {
                PIO_WORKITEM work_item;
 
                work_item = IoAllocateWorkItem(DeviceObject);
                if (!work_item) {
                    ERR("out of memory\n");
                } else
                    IoQueueWorkItem(work_item, check_after_wakeup, DelayedWorkQueue, Vcb2);
            }
        }
 
        PoStartNextPowerIrp(Irp);
        IoSkipCurrentIrpStackLocation(Irp);
        Status = PoCallDriver(vde->attached_device, Irp);
 
        goto exit;
    } else if (Vcb && Vcb->type == VCB_TYPE_FS) {
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
 
        goto exit;
    } else if (Vcb && Vcb->type == VCB_TYPE_BUS) {
        bus_device_extension* bde = DeviceObject->DeviceExtension;
 
        PoStartNextPowerIrp(Irp);
        IoSkipCurrentIrpStackLocation(Irp);
        Status = PoCallDriver(bde->attached_device, Irp);
 
        goto exit;
    }
 
    if (IrpSp->MinorFunction == IRP_MN_SET_POWER || IrpSp->MinorFunction == IRP_MN_QUERY_POWER)
        Irp->IoStatus.Status = STATUS_SUCCESS;
 
    Status = Irp->IoStatus.Status;
 
    PoStartNextPowerIrp(Irp);
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
exit:
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    return Status;
}

_Dispatch_type_() [7/10]

_Dispatch_type_

(

IRP_MJ_QUERY_VOLUME_INFORMATION

)

Definition at line 997 of file btrfs.c.

                                                                                                        {
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS Status;
    ULONG BytesCopied = 0;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    TRACE("query volume information\n");
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    Status = STATUS_NOT_IMPLEMENTED;
 
    switch (IrpSp->Parameters.QueryVolume.FsInformationClass) {
        case FileFsAttributeInformation:
        {
            FILE_FS_ATTRIBUTE_INFORMATION* data = Irp->AssociatedIrp.SystemBuffer;
            bool overflow = false;
#ifndef __REACTOS__
            static const WCHAR ntfs[] = L"NTFS";
#endif
            static const WCHAR btrfs[] = L"Btrfs";
            const WCHAR* fs_name;
            ULONG fs_name_len, orig_fs_name_len;
 
#ifndef __REACTOS__
            if (Irp->RequestorMode == UserMode && lie_about_fs_type()) {
                fs_name = ntfs;
                orig_fs_name_len = fs_name_len = sizeof(ntfs) - sizeof(WCHAR);
            } else {
                fs_name = btrfs;
                orig_fs_name_len = fs_name_len = sizeof(btrfs) - sizeof(WCHAR);
            }
#else
            fs_name = btrfs;
            orig_fs_name_len = fs_name_len = sizeof(btrfs) - sizeof(WCHAR);
#endif
 
            TRACE("FileFsAttributeInformation\n");
 
            if (IrpSp->Parameters.QueryVolume.Length < sizeof(FILE_FS_ATTRIBUTE_INFORMATION) - sizeof(WCHAR) + fs_name_len) {
                if (IrpSp->Parameters.QueryVolume.Length > sizeof(FILE_FS_ATTRIBUTE_INFORMATION) - sizeof(WCHAR))
                    fs_name_len = IrpSp->Parameters.QueryVolume.Length - sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + sizeof(WCHAR);
                else
                    fs_name_len = 0;
 
                overflow = true;
            }
 
            data->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES | FILE_CASE_SENSITIVE_SEARCH |
                                         FILE_UNICODE_ON_DISK | FILE_NAMED_STREAMS | FILE_SUPPORTS_HARD_LINKS | FILE_PERSISTENT_ACLS |
                                         FILE_SUPPORTS_REPARSE_POINTS | FILE_SUPPORTS_SPARSE_FILES | FILE_SUPPORTS_OBJECT_IDS |
                                         FILE_SUPPORTS_OPEN_BY_FILE_ID | FILE_SUPPORTS_EXTENDED_ATTRIBUTES | FILE_SUPPORTS_BLOCK_REFCOUNTING |
                                         FILE_SUPPORTS_POSIX_UNLINK_RENAME;
            if (Vcb->readonly)
                data->FileSystemAttributes |= FILE_READ_ONLY_VOLUME;
 
            // should also be FILE_FILE_COMPRESSION when supported
            data->MaximumComponentNameLength = 255; // FIXME - check
            data->FileSystemNameLength = orig_fs_name_len;
            RtlCopyMemory(data->FileSystemName, fs_name, fs_name_len);
 
            BytesCopied = sizeof(FILE_FS_ATTRIBUTE_INFORMATION) - sizeof(WCHAR) + fs_name_len;
            Status = overflow ? STATUS_BUFFER_OVERFLOW : STATUS_SUCCESS;
            break;
        }
 
        case FileFsDeviceInformation:
        {
            FILE_FS_DEVICE_INFORMATION* ffdi = Irp->AssociatedIrp.SystemBuffer;
 
            TRACE("FileFsDeviceInformation\n");
 
            ffdi->DeviceType = FILE_DEVICE_DISK;
 
            ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
            ffdi->Characteristics = Vcb->Vpb->RealDevice->Characteristics;
            ExReleaseResourceLite(&Vcb->tree_lock);
 
            if (Vcb->readonly)
                ffdi->Characteristics |= FILE_READ_ONLY_DEVICE;
            else
                ffdi->Characteristics &= ~FILE_READ_ONLY_DEVICE;
 
            BytesCopied = sizeof(FILE_FS_DEVICE_INFORMATION);
            Status = STATUS_SUCCESS;
 
            break;
        }
 
        case FileFsFullSizeInformation:
        {
            FILE_FS_FULL_SIZE_INFORMATION* ffsi = Irp->AssociatedIrp.SystemBuffer;
 
            TRACE("FileFsFullSizeInformation\n");
 
            calculate_total_space(Vcb, (uint64_t*)&ffsi->TotalAllocationUnits.QuadPart, (uint64_t*)&ffsi->ActualAvailableAllocationUnits.QuadPart);
            ffsi->CallerAvailableAllocationUnits.QuadPart = ffsi->ActualAvailableAllocationUnits.QuadPart;
            ffsi->SectorsPerAllocationUnit = Vcb->superblock.sector_size / 512;
            ffsi->BytesPerSector = 512;
 
            BytesCopied = sizeof(FILE_FS_FULL_SIZE_INFORMATION);
            Status = STATUS_SUCCESS;
 
            break;
        }
 
        case FileFsObjectIdInformation:
        {
            FILE_FS_OBJECTID_INFORMATION* ffoi = Irp->AssociatedIrp.SystemBuffer;
 
            TRACE("FileFsObjectIdInformation\n");
 
            RtlCopyMemory(ffoi->ObjectId, &Vcb->superblock.uuid.uuid[0], sizeof(UCHAR) * 16);
            RtlZeroMemory(ffoi->ExtendedInfo, sizeof(ffoi->ExtendedInfo));
 
            BytesCopied = sizeof(FILE_FS_OBJECTID_INFORMATION);
            Status = STATUS_SUCCESS;
 
            break;
        }
 
        case FileFsSizeInformation:
        {
            FILE_FS_SIZE_INFORMATION* ffsi = Irp->AssociatedIrp.SystemBuffer;
 
            TRACE("FileFsSizeInformation\n");
 
            calculate_total_space(Vcb, (uint64_t*)&ffsi->TotalAllocationUnits.QuadPart, (uint64_t*)&ffsi->AvailableAllocationUnits.QuadPart);
            ffsi->SectorsPerAllocationUnit = Vcb->superblock.sector_size / 512;
            ffsi->BytesPerSector = 512;
 
            BytesCopied = sizeof(FILE_FS_SIZE_INFORMATION);
            Status = STATUS_SUCCESS;
 
            break;
        }
 
        case FileFsVolumeInformation:
        {
            FILE_FS_VOLUME_INFORMATION* data = Irp->AssociatedIrp.SystemBuffer;
            FILE_FS_VOLUME_INFORMATION ffvi;
            bool overflow = false;
            ULONG label_len, orig_label_len;
 
            TRACE("FileFsVolumeInformation\n");
            TRACE("max length = %lu\n", IrpSp->Parameters.QueryVolume.Length);
 
            ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
            Status = utf8_to_utf16(NULL, 0, &label_len, Vcb->superblock.label, (ULONG)strlen(Vcb->superblock.label));
            if (!NT_SUCCESS(Status)) {
                ERR("utf8_to_utf16 returned %08lx\n", Status);
                ExReleaseResourceLite(&Vcb->tree_lock);
                break;
            }
 
            orig_label_len = label_len;
 
            if (IrpSp->Parameters.QueryVolume.Length < offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel) + label_len) {
                if (IrpSp->Parameters.QueryVolume.Length > offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel))
                    label_len = IrpSp->Parameters.QueryVolume.Length - offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel);
                else
                    label_len = 0;
 
                overflow = true;
            }
 
            TRACE("label_len = %lu\n", label_len);
 
            RtlZeroMemory(&ffvi, offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel));
 
            ffvi.VolumeSerialNumber = Vcb->superblock.uuid.uuid[12] << 24 | Vcb->superblock.uuid.uuid[13] << 16 | Vcb->superblock.uuid.uuid[14] << 8 | Vcb->superblock.uuid.uuid[15];
            ffvi.VolumeLabelLength = orig_label_len;
 
            RtlCopyMemory(data, &ffvi, min(offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel), IrpSp->Parameters.QueryVolume.Length));
 
            if (label_len > 0) {
                ULONG bytecount;
 
                Status = utf8_to_utf16(&data->VolumeLabel[0], label_len, &bytecount, Vcb->superblock.label, (ULONG)strlen(Vcb->superblock.label));
                if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL) {
                    ERR("utf8_to_utf16 returned %08lx\n", Status);
                    ExReleaseResourceLite(&Vcb->tree_lock);
                    break;
                }
 
                TRACE("label = %.*S\n", (int)(label_len / sizeof(WCHAR)), data->VolumeLabel);
            }
 
            ExReleaseResourceLite(&Vcb->tree_lock);
 
            BytesCopied = offsetof(FILE_FS_VOLUME_INFORMATION, VolumeLabel) + label_len;
            Status = overflow ? STATUS_BUFFER_OVERFLOW : STATUS_SUCCESS;
            break;
        }
 
#ifndef __REACTOS__
#ifdef _MSC_VER // not in mingw yet
        case FileFsSectorSizeInformation:
        {
            FILE_FS_SECTOR_SIZE_INFORMATION* data = Irp->AssociatedIrp.SystemBuffer;
 
            data->LogicalBytesPerSector = Vcb->superblock.sector_size;
            data->PhysicalBytesPerSectorForAtomicity = Vcb->superblock.sector_size;
            data->PhysicalBytesPerSectorForPerformance = Vcb->superblock.sector_size;
            data->FileSystemEffectivePhysicalBytesPerSectorForAtomicity = Vcb->superblock.sector_size;
            data->ByteOffsetForSectorAlignment = 0;
            data->ByteOffsetForPartitionAlignment = 0;
 
            data->Flags = SSINFO_FLAGS_ALIGNED_DEVICE | SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE;
 
            if (Vcb->trim && !Vcb->options.no_trim)
                data->Flags |= SSINFO_FLAGS_TRIM_ENABLED;
 
            BytesCopied = sizeof(FILE_FS_SECTOR_SIZE_INFORMATION);
            Status = STATUS_SUCCESS;
 
            break;
        }
#endif
#endif /* __REACTOS__ */
 
        default:
            Status = STATUS_INVALID_PARAMETER;
            WARN("unknown FsInformationClass %u\n", IrpSp->Parameters.QueryVolume.FsInformationClass);
            break;
    }
 
    if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
        Irp->IoStatus.Information = 0;
    else
        Irp->IoStatus.Information = BytesCopied;
 
end:
    Irp->IoStatus.Status = Status;
 
    IoCompleteRequest( Irp, IO_DISK_INCREMENT );
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    TRACE("query volume information returning %08lx\n", Status);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [8/10]

_Dispatch_type_

(

IRP_MJ_SET_VOLUME_INFORMATION

)

Definition at line 1447 of file btrfs.c.

                                                                                                      {
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    device_extension* Vcb = DeviceObject->DeviceExtension;
    NTSTATUS Status;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    TRACE("set volume information\n");
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    Status = STATUS_NOT_IMPLEMENTED;
 
    if (Vcb->readonly) {
        Status = STATUS_MEDIA_WRITE_PROTECTED;
        goto end;
    }
 
    if (Vcb->removing || Vcb->locked) {
        Status = STATUS_ACCESS_DENIED;
        goto end;
    }
 
    switch (IrpSp->Parameters.SetVolume.FsInformationClass) {
        case FileFsControlInformation:
            FIXME("STUB: FileFsControlInformation\n");
            break;
 
        case FileFsLabelInformation:
            TRACE("FileFsLabelInformation\n");
 
            Status = set_label(Vcb, Irp->AssociatedIrp.SystemBuffer);
            break;
 
        case FileFsObjectIdInformation:
            FIXME("STUB: FileFsObjectIdInformation\n");
            break;
 
        default:
            WARN("Unrecognized FsInformationClass 0x%x\n", IrpSp->Parameters.SetVolume.FsInformationClass);
            break;
    }
 
end:
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
 
    TRACE("returning %08lx\n", Status);
 
    IoCompleteRequest( Irp, IO_NO_INCREMENT );
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [9/10]

_Dispatch_type_

(

IRP_MJ_SHUTDOWN

)

Definition at line 5510 of file btrfs.c.

                                                                                        {
    NTSTATUS Status;
    bool top_level;
    device_extension* Vcb = DeviceObject->DeviceExtension;
 
    FsRtlEnterFileSystem();
 
    TRACE("shutdown\n");
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    }
 
    Status = STATUS_SUCCESS;
 
    do_shutdown(Irp);
 
end:
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
 
    IoCompleteRequest( Irp, IO_NO_INCREMENT );
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [10/10]

_Dispatch_type_

(

IRP_MJ_SYSTEM_CONTROL

)

Definition at line 5748 of file btrfs.c.

                                                                                              {
    NTSTATUS Status;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    top_level = is_top_level(Irp);
 
    Irp->IoStatus.Information = 0;
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        volume_device_extension* vde = DeviceObject->DeviceExtension;
 
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(vde->attached_device, Irp);
 
        goto exit;
    } else if (Vcb && Vcb->type == VCB_TYPE_FS) {
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
 
        goto exit;
    } else if (Vcb && Vcb->type == VCB_TYPE_BUS) {
        bus_device_extension* bde = DeviceObject->DeviceExtension;
 
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(bde->attached_device, Irp);
 
        goto exit;
    }
 
    Status = Irp->IoStatus.Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
exit:
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Function_class_() [1/6]

_Function_class_

(

DRIVER_ADD_DEVICE

)

Definition at line 6133 of file btrfs.c.

                                                                                               {
    LIST_ENTRY* le;
    NTSTATUS Status;
    UNICODE_STRING volname;
    ULONG i;
    WCHAR* s;
    pdo_device_extension* pdode = NULL;
    PDEVICE_OBJECT voldev;
    volume_device_extension* vde;
    UNICODE_STRING arc_name_us;
    WCHAR* anp;
 
    static const WCHAR arc_name_prefix[] = L"\\ArcName\\btrfs(";
 
    WCHAR arc_name[(sizeof(arc_name_prefix) / sizeof(WCHAR)) - 1 + 37];
 
    TRACE("(%p, %p)\n", DriverObject, PhysicalDeviceObject);
 
    UNUSED(DriverObject);
 
    ExAcquireResourceSharedLite(&pdo_list_lock, true);
 
    le = pdo_list.Flink;
    while (le != &pdo_list) {
        pdo_device_extension* pdode2 = CONTAINING_RECORD(le, pdo_device_extension, list_entry);
 
        if (pdode2->pdo == PhysicalDeviceObject) {
            pdode = pdode2;
            break;
        }
 
        le = le->Flink;
    }
 
    if (!pdode) {
        WARN("unrecognized PDO %p\n", PhysicalDeviceObject);
        Status = STATUS_NOT_SUPPORTED;
        goto end;
    }
 
    ExAcquireResourceExclusiveLite(&pdode->child_lock, true);
 
    if (pdode->vde) { // if already done, return success
        Status = STATUS_SUCCESS;
        goto end2;
    }
 
    volname.Length = volname.MaximumLength = (sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR)) + ((36 + 1) * sizeof(WCHAR));
    volname.Buffer = ExAllocatePoolWithTag(PagedPool, volname.MaximumLength, ALLOC_TAG); // FIXME - when do we free this?
 
    if (!volname.Buffer) {
        ERR("out of memory\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto end2;
    }
 
    RtlCopyMemory(volname.Buffer, BTRFS_VOLUME_PREFIX, sizeof(BTRFS_VOLUME_PREFIX) - sizeof(WCHAR));
    RtlCopyMemory(arc_name, arc_name_prefix, sizeof(arc_name_prefix) - sizeof(WCHAR));
 
    anp = &arc_name[(sizeof(arc_name_prefix) / sizeof(WCHAR)) - 1];
    s = &volname.Buffer[(sizeof(BTRFS_VOLUME_PREFIX) / sizeof(WCHAR)) - 1];
 
    for (i = 0; i < 16; i++) {
        *s = *anp = hex_digit(pdode->uuid.uuid[i] >> 4);
        s++;
        anp++;
 
        *s = *anp = hex_digit(pdode->uuid.uuid[i] & 0xf);
        s++;
        anp++;
 
        if (i == 3 || i == 5 || i == 7 || i == 9) {
            *s = *anp = '-';
            s++;
            anp++;
        }
    }
 
    *s = '}';
    *anp = ')';
 
    Status = IoCreateDevice(drvobj, sizeof(volume_device_extension), &volname, FILE_DEVICE_DISK,
                            is_windows_8 ? FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL : 0, false, &voldev);
    if (!NT_SUCCESS(Status)) {
        ERR("IoCreateDevice returned %08lx\n", Status);
        goto end2;
    }
 
    arc_name_us.Buffer = arc_name;
    arc_name_us.Length = arc_name_us.MaximumLength = sizeof(arc_name);
 
    Status = IoCreateSymbolicLink(&arc_name_us, &volname);
    if (!NT_SUCCESS(Status))
        WARN("IoCreateSymbolicLink returned %08lx\n", Status);
 
    voldev->SectorSize = PhysicalDeviceObject->SectorSize;
    voldev->Flags |= DO_DIRECT_IO;
 
    vde = voldev->DeviceExtension;
    vde->type = VCB_TYPE_VOLUME;
    vde->name = volname;
    vde->device = voldev;
    vde->mounted_device = NULL;
    vde->pdo = PhysicalDeviceObject;
    vde->pdode = pdode;
    vde->removing = false;
    vde->dead = false;
    vde->open_count = 0;
 
    Status = IoRegisterDeviceInterface(PhysicalDeviceObject, &GUID_DEVINTERFACE_VOLUME, NULL, &vde->bus_name);
    if (!NT_SUCCESS(Status))
        WARN("IoRegisterDeviceInterface returned %08lx\n", Status);
 
    vde->attached_device = IoAttachDeviceToDeviceStack(voldev, PhysicalDeviceObject);
 
    pdode->vde = vde;
 
    if (pdode->removable)
        voldev->Characteristics |= FILE_REMOVABLE_MEDIA;
 
    if (RtlCompareMemory(&boot_uuid, &pdode->uuid, sizeof(BTRFS_UUID)) == sizeof(BTRFS_UUID)) {
        voldev->Flags |= DO_SYSTEM_BOOT_PARTITION;
        PhysicalDeviceObject->Flags |= DO_SYSTEM_BOOT_PARTITION;
    }
 
    voldev->Flags &= ~DO_DEVICE_INITIALIZING;
 
    Status = IoSetDeviceInterfaceState(&vde->bus_name, true);
    if (!NT_SUCCESS(Status))
        WARN("IoSetDeviceInterfaceState returned %08lx\n", Status);
 
    Status = STATUS_SUCCESS;
 
end2:
    ExReleaseResourceLite(&pdode->child_lock);
 
end:
    ExReleaseResourceLite(&pdo_list_lock);
 
    return Status;
}

_Function_class_() [2/6]

_Function_class_

(

DRIVER_INITIALIZE

)

Definition at line 6276 of file btrfs.c.

                                                                                                    {
    NTSTATUS Status;
    PDEVICE_OBJECT DeviceObject;
    UNICODE_STRING device_nameW;
    UNICODE_STRING dosdevice_nameW;
    control_device_extension* cde;
    bus_device_extension* bde;
    HANDLE regh;
    OBJECT_ATTRIBUTES oa, system_thread_attributes;
    ULONG dispos;
    RTL_OSVERSIONINFOW ver;
 
    ver.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOW);
 
    Status = RtlGetVersion(&ver);
    if (!NT_SUCCESS(Status)) {
        ERR("RtlGetVersion returned %08lx\n", Status);
        return Status;
    }
 
    is_windows_8 = ver.dwMajorVersion > 6 || (ver.dwMajorVersion == 6 && ver.dwMinorVersion >= 2);
 
    KeInitializeSpinLock(&fve_data_lock);
 
    InitializeListHead(&uid_map_list);
    InitializeListHead(&gid_map_list);
 
#ifdef _DEBUG
    ExInitializeResourceLite(&log_lock);
#endif
    ExInitializeResourceLite(&mapping_lock);
 
    log_device.Buffer = NULL;
    log_device.Length = log_device.MaximumLength = 0;
    log_file.Buffer = NULL;
    log_file.Length = log_file.MaximumLength = 0;
 
    registry_path.Length = registry_path.MaximumLength = RegistryPath->Length;
    registry_path.Buffer = ExAllocatePoolWithTag(PagedPool, registry_path.Length, ALLOC_TAG);
 
    if (!registry_path.Buffer) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlCopyMemory(registry_path.Buffer, RegistryPath->Buffer, registry_path.Length);
 
    read_registry(&registry_path, false);
 
#ifdef _DEBUG
    if (debug_log_level > 0)
        init_logging();
 
    log_started = true;
#endif
 
    TRACE("DriverEntry\n");
 
#if !defined(__REACTOS__) && (defined(_X86_) || defined(_AMD64_))
    check_cpu();
#endif
 
    if (ver.dwMajorVersion > 6 || (ver.dwMajorVersion == 6 && ver.dwMinorVersion >= 2)) { // Windows 8 or above
        UNICODE_STRING name;
        tPsIsDiskCountersEnabled fPsIsDiskCountersEnabled;
 
        RtlInitUnicodeString(&name, L"PsIsDiskCountersEnabled");
        fPsIsDiskCountersEnabled = (tPsIsDiskCountersEnabled)MmGetSystemRoutineAddress(&name);
 
        if (fPsIsDiskCountersEnabled) {
            diskacc = fPsIsDiskCountersEnabled();
 
            RtlInitUnicodeString(&name, L"PsUpdateDiskCounters");
            fPsUpdateDiskCounters = (tPsUpdateDiskCounters)MmGetSystemRoutineAddress(&name);
 
            if (!fPsUpdateDiskCounters)
                diskacc = false;
 
            RtlInitUnicodeString(&name, L"FsRtlUpdateDiskCounters");
            fFsRtlUpdateDiskCounters = (tFsRtlUpdateDiskCounters)MmGetSystemRoutineAddress(&name);
        }
 
        RtlInitUnicodeString(&name, L"CcCopyReadEx");
        fCcCopyReadEx = (tCcCopyReadEx)MmGetSystemRoutineAddress(&name);
 
        RtlInitUnicodeString(&name, L"CcCopyWriteEx");
        fCcCopyWriteEx = (tCcCopyWriteEx)MmGetSystemRoutineAddress(&name);
 
        RtlInitUnicodeString(&name, L"CcSetAdditionalCacheAttributesEx");
        fCcSetAdditionalCacheAttributesEx = (tCcSetAdditionalCacheAttributesEx)MmGetSystemRoutineAddress(&name);
 
        RtlInitUnicodeString(&name, L"FsRtlCheckLockForOplockRequest");
        fFsRtlCheckLockForOplockRequest = (tFsRtlCheckLockForOplockRequest)MmGetSystemRoutineAddress(&name);
    } else {
        fPsUpdateDiskCounters = NULL;
        fCcCopyReadEx = NULL;
        fCcCopyWriteEx = NULL;
        fCcSetAdditionalCacheAttributesEx = NULL;
        fFsRtlUpdateDiskCounters = NULL;
        fFsRtlCheckLockForOplockRequest = NULL;
    }
 
    if (ver.dwMajorVersion > 6 || (ver.dwMajorVersion == 6 && ver.dwMinorVersion >= 1)) { // Windows 7 or above
        UNICODE_STRING name;
 
        RtlInitUnicodeString(&name, L"IoUnregisterPlugPlayNotificationEx");
        fIoUnregisterPlugPlayNotificationEx = (tIoUnregisterPlugPlayNotificationEx)MmGetSystemRoutineAddress(&name);
 
        RtlInitUnicodeString(&name, L"FsRtlAreThereCurrentOrInProgressFileLocks");
        fFsRtlAreThereCurrentOrInProgressFileLocks = (tFsRtlAreThereCurrentOrInProgressFileLocks)MmGetSystemRoutineAddress(&name);
    } else {
        fIoUnregisterPlugPlayNotificationEx = NULL;
        fFsRtlAreThereCurrentOrInProgressFileLocks = NULL;
    }
 
    if (ver.dwMajorVersion >= 6) { // Windows Vista or above
        UNICODE_STRING name;
 
        RtlInitUnicodeString(&name, L"FsRtlGetEcpListFromIrp");
        fFsRtlGetEcpListFromIrp = (tFsRtlGetEcpListFromIrp)MmGetSystemRoutineAddress(&name);
 
        RtlInitUnicodeString(&name, L"FsRtlGetNextExtraCreateParameter");
        fFsRtlGetNextExtraCreateParameter = (tFsRtlGetNextExtraCreateParameter)MmGetSystemRoutineAddress(&name);
 
        RtlInitUnicodeString(&name, L"FsRtlValidateReparsePointBuffer");
        fFsRtlValidateReparsePointBuffer = (tFsRtlValidateReparsePointBuffer)MmGetSystemRoutineAddress(&name);
    } else {
        fFsRtlGetEcpListFromIrp = NULL;
        fFsRtlGetNextExtraCreateParameter = NULL;
        fFsRtlValidateReparsePointBuffer = compat_FsRtlValidateReparsePointBuffer;
    }
 
    drvobj = DriverObject;
 
    DriverObject->DriverUnload = DriverUnload;
 
    DriverObject->DriverExtension->AddDevice = AddDevice;
 
    DriverObject->MajorFunction[IRP_MJ_CREATE]                   = drv_create;
    DriverObject->MajorFunction[IRP_MJ_CLOSE]                    = drv_close;
    DriverObject->MajorFunction[IRP_MJ_READ]                     = drv_read;
    DriverObject->MajorFunction[IRP_MJ_WRITE]                    = drv_write;
    DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION]        = drv_query_information;
    DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION]          = drv_set_information;
    DriverObject->MajorFunction[IRP_MJ_QUERY_EA]                 = drv_query_ea;
    DriverObject->MajorFunction[IRP_MJ_SET_EA]                   = drv_set_ea;
    DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS]            = drv_flush_buffers;
    DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = drv_query_volume_information;
    DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION]   = drv_set_volume_information;
    DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL]        = drv_directory_control;
    DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL]      = drv_file_system_control;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]           = drv_device_control;
    DriverObject->MajorFunction[IRP_MJ_SHUTDOWN]                 = drv_shutdown;
    DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL]             = drv_lock_control;
    DriverObject->MajorFunction[IRP_MJ_CLEANUP]                  = drv_cleanup;
    DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY]           = drv_query_security;
    DriverObject->MajorFunction[IRP_MJ_SET_SECURITY]             = drv_set_security;
    DriverObject->MajorFunction[IRP_MJ_POWER]                    = drv_power;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL]           = drv_system_control;
    DriverObject->MajorFunction[IRP_MJ_PNP]                      = drv_pnp;
 
    init_fast_io_dispatch(&DriverObject->FastIoDispatch);
 
    device_nameW.Buffer = (WCHAR*)device_name;
    device_nameW.Length = device_nameW.MaximumLength = sizeof(device_name) - sizeof(WCHAR);
    dosdevice_nameW.Buffer = (WCHAR*)dosdevice_name;
    dosdevice_nameW.Length = dosdevice_nameW.MaximumLength = sizeof(dosdevice_name) - sizeof(WCHAR);
 
    Status = IoCreateDevice(DriverObject, sizeof(control_device_extension), &device_nameW, FILE_DEVICE_DISK_FILE_SYSTEM,
                            FILE_DEVICE_SECURE_OPEN, false, &DeviceObject);
    if (!NT_SUCCESS(Status)) {
        ERR("IoCreateDevice returned %08lx\n", Status);
        return Status;
    }
 
    master_devobj = DeviceObject;
    cde = (control_device_extension*)master_devobj->DeviceExtension;
 
    RtlZeroMemory(cde, sizeof(control_device_extension));
 
    cde->type = VCB_TYPE_CONTROL;
 
    DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
    Status = IoCreateSymbolicLink(&dosdevice_nameW, &device_nameW);
    if (!NT_SUCCESS(Status)) {
        ERR("IoCreateSymbolicLink returned %08lx\n", Status);
        return Status;
    }
 
    init_cache();
 
    InitializeListHead(&VcbList);
    ExInitializeResourceLite(&global_loading_lock);
    ExInitializeResourceLite(&pdo_list_lock);
 
    InitializeListHead(&pdo_list);
 
    InitializeObjectAttributes(&oa, RegistryPath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
    Status = ZwCreateKey(&regh, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS | KEY_NOTIFY, &oa, 0, NULL, REG_OPTION_NON_VOLATILE, &dispos);
    if (!NT_SUCCESS(Status)) {
        ERR("ZwCreateKey returned %08lx\n", Status);
        return Status;
    }
 
    watch_registry(regh);
 
    Status = IoCreateDevice(DriverObject, sizeof(bus_device_extension), NULL, FILE_DEVICE_UNKNOWN,
                            FILE_DEVICE_SECURE_OPEN, false, &busobj);
    if (!NT_SUCCESS(Status)) {
        ERR("IoCreateDevice returned %08lx\n", Status);
        return Status;
    }
 
    bde = (bus_device_extension*)busobj->DeviceExtension;
 
    RtlZeroMemory(bde, sizeof(bus_device_extension));
 
    bde->type = VCB_TYPE_BUS;
 
    Status = IoReportDetectedDevice(drvobj, InterfaceTypeUndefined, 0xFFFFFFFF, 0xFFFFFFFF,
                                    NULL, NULL, 0, &bde->buspdo);
    if (!NT_SUCCESS(Status)) {
        ERR("IoReportDetectedDevice returned %08lx\n", Status);
        return Status;
    }
 
    Status = IoRegisterDeviceInterface(bde->buspdo, &BtrfsBusInterface, NULL, &bde->bus_name);
    if (!NT_SUCCESS(Status))
        WARN("IoRegisterDeviceInterface returned %08lx\n", Status);
 
    bde->attached_device = IoAttachDeviceToDeviceStack(busobj, bde->buspdo);
 
    busobj->Flags &= ~DO_DEVICE_INITIALIZING;
 
    Status = IoSetDeviceInterfaceState(&bde->bus_name, true);
    if (!NT_SUCCESS(Status))
        WARN("IoSetDeviceInterfaceState returned %08lx\n", Status);
 
    IoInvalidateDeviceRelations(bde->buspdo, BusRelations);
 
    InitializeObjectAttributes(&system_thread_attributes, NULL, OBJ_KERNEL_HANDLE, NULL, NULL);
 
    Status = PsCreateSystemThread(&degraded_wait_handle, 0, &system_thread_attributes, NULL, NULL, degraded_wait_thread, NULL);
    if (!NT_SUCCESS(Status))
        WARN("PsCreateSystemThread returned %08lx\n", Status);
 
    ExInitializeResourceLite(&boot_lock);
 
    Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange, PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                            (PVOID)&GUID_DEVINTERFACE_VOLUME, DriverObject, volume_notification, NULL, &notification_entry2);
    if (!NT_SUCCESS(Status))
        ERR("IoRegisterPlugPlayNotification returned %08lx\n", Status);
 
    Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange, PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                            (PVOID)&GUID_DEVINTERFACE_HIDDEN_VOLUME, DriverObject, volume_notification, NULL, &notification_entry3);
    if (!NT_SUCCESS(Status))
        ERR("IoRegisterPlugPlayNotification returned %08lx\n", Status);
 
    Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange, PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
                                            (PVOID)&GUID_DEVINTERFACE_DISK, DriverObject, pnp_notification, DriverObject, &notification_entry);
    if (!NT_SUCCESS(Status))
        ERR("IoRegisterPlugPlayNotification returned %08lx\n", Status);
 
    finished_probing = true;
 
    KeInitializeEvent(&mountmgr_thread_event, NotificationEvent, false);
 
    // Status = PsCreateSystemThread(&mountmgr_thread_handle, 0, &system_thread_attributes, NULL, NULL, mountmgr_thread, NULL);
    // if (!NT_SUCCESS(Status))
    //     WARN("PsCreateSystemThread returned %08lx\n", Status);
 
    IoRegisterFileSystem(DeviceObject);
 
    check_system_root();
 
    return STATUS_SUCCESS;
}

_Function_class_() [3/6]

_Function_class_

(

DRIVER_UNLOAD

)

Definition at line 330 of file btrfs.c.

                                                                     {
    UNICODE_STRING dosdevice_nameW;
 
    TRACE("(%p)\n", DriverObject);
 
    dosdevice_nameW.Buffer = (WCHAR*)dosdevice_name;
    dosdevice_nameW.Length = dosdevice_nameW.MaximumLength = sizeof(dosdevice_name) - sizeof(WCHAR);
 
    IoDeleteSymbolicLink(&dosdevice_nameW);
    IoDeleteDevice(DriverObject->DeviceObject);
 
    while (!IsListEmpty(&uid_map_list)) {
        LIST_ENTRY* le = RemoveHeadList(&uid_map_list);
        uid_map* um = CONTAINING_RECORD(le, uid_map, listentry);
 
        ExFreePool(um->sid);
 
        ExFreePool(um);
    }
 
    while (!IsListEmpty(&gid_map_list)) {
        gid_map* gm = CONTAINING_RECORD(RemoveHeadList(&gid_map_list), gid_map, listentry);
 
        ExFreePool(gm->sid);
        ExFreePool(gm);
    }
 
    // FIXME - free volumes and their devpaths
 
#ifdef _DEBUG
    if (comfo)
        ObDereferenceObject(comfo);
 
    if (log_handle)
        ZwClose(log_handle);
#endif
 
    ExDeleteResourceLite(&global_loading_lock);
    ExDeleteResourceLite(&pdo_list_lock);
 
    if (log_device.Buffer)
        ExFreePool(log_device.Buffer);
 
    if (log_file.Buffer)
        ExFreePool(log_file.Buffer);
 
    if (registry_path.Buffer)
        ExFreePool(registry_path.Buffer);
 
#ifdef _DEBUG
    ExDeleteResourceLite(&log_lock);
#endif
    ExDeleteResourceLite(&mapping_lock);
}

_Function_class_() [4/6]

_Function_class_

(

IO_COMPLETION_ROUTINE

)

Definition at line 1259 of file btrfs.c.

                                                                                                              {
    read_context* context = conptr;
 
    UNUSED(DeviceObject);
 
    context->iosb = Irp->IoStatus;
    KeSetEvent(&context->Event, 0, false);
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

_Function_class_() [5/6]

_Function_class_

(

IO_WORKITEM_ROUTINE

)

Definition at line 1648 of file btrfs.c.

                                                                                     {
    notification_fcb* nf = con;
 
    UNUSED(DeviceObject);
 
    ExAcquireResourceSharedLite(&nf->fileref->fcb->Vcb->tree_lock, TRUE); // protect us from fileref being reaped
 
    send_notification_fcb(nf->fileref, nf->filter_match, nf->action, nf->stream);
 
    free_fileref(nf->fileref);
 
    ExReleaseResourceLite(&nf->fileref->fcb->Vcb->tree_lock);
 
    IoFreeWorkItem(nf->work_item);
 
    ExFreePool(nf);
}

_Function_class_() [6/6]

_Function_class_

(

KSTART_ROUTINE

)

Definition at line 6110 of file btrfs.c.

                                                               {
    KTIMER timer;
    LARGE_INTEGER delay;
 
    UNUSED(context);
 
    KeInitializeTimer(&timer);
 
    delay.QuadPart = -30000000; // wait three seconds
    KeSetTimer(&timer, delay, NULL);
    KeWaitForSingleObject(&timer, Executive, KernelMode, false, NULL);
 
    TRACE("timer expired\n");
 
    degraded_wait = false;
 
    ZwClose(degraded_wait_handle);
    degraded_wait_handle = NULL;
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}

_Requires_exclusive_lock_held_()

_Requires_exclusive_lock_held_

(

Vcb->

tree_lock

)

_Success_() [1/2]

_Success_

(

return >=

0

)

_Success_() [2/2]

_Success_

(

return

)

Definition at line 427 of file btrfs.c.

                                                                                                                                                 {
    DIR_ITEM* xa = (DIR_ITEM*)item;
    USHORT xasize;
 
    while (true) {
        if (size < sizeof(DIR_ITEM) || size < (sizeof(DIR_ITEM) - 1 + xa->m + xa->n)) {
            WARN("DIR_ITEM is truncated\n");
            return false;
        }
 
        if (xa->n == strlen(name) && RtlCompareMemory(name, xa->name, xa->n) == xa->n) {
            TRACE("found xattr %s\n", name);
 
            *datalen = xa->m;
 
            if (xa->m > 0) {
                *data = ExAllocatePoolWithTag(PagedPool, xa->m, ALLOC_TAG);
                if (!*data) {
                    ERR("out of memory\n");
                    return false;
                }
 
                RtlCopyMemory(*data, &xa->name[xa->n], xa->m);
            } else
                *data = NULL;
 
            return true;
        }
 
        xasize = sizeof(DIR_ITEM) - 1 + xa->m + xa->n;
 
        if (size > xasize) {
            size -= xasize;
            xa = (DIR_ITEM*)&xa->name[xa->m + xa->n];
        } else
            break;
    }
 
    TRACE("xattr %s not found\n", name);
 
    return false;
}

add_device_to_list()

static void add_device_to_list ( _In_ device_extension *  Vcb, _In_ device *  dev  )

static

Definition at line 3279 of file btrfs.c.

                                                                             {
    LIST_ENTRY* le;
 
    le = Vcb->devices.Flink;
 
    while (le != &Vcb->devices) {
        device* dev2 = CONTAINING_RECORD(le, device, list_entry);
 
        if (dev2->devitem.dev_id > dev->devitem.dev_id) {
            InsertHeadList(le->Blink, &dev->list_entry);
            return;
        }
 
        le = le->Flink;
    }
 
    InsertTailList(&Vcb->devices, &dev->list_entry);
}

Referenced by find_device_from_uuid(), and load_chunk_root().

calculate_sector_shift()

static void calculate_sector_shift ( device_extension *  Vcb )

static

Definition at line 4364 of file btrfs.c.

                                                          {
    uint32_t ss = Vcb->superblock.sector_size;
 
    Vcb->sector_shift = 0;
 
    while (!(ss & 1)) {
        Vcb->sector_shift++;
        ss >>= 1;
    }
}

Referenced by mount_vol().

calculate_total_space()

static void calculate_total_space ( _In_ device_extension *  Vcb, _Out_ uint64_t *  totalsize, _Out_ uint64_t *  freespace  )

static

Definition at line 619 of file btrfs.c.

                                                                                                                    {
    uint64_t nfactor, dfactor, sectors_used;
 
    if (Vcb->data_flags & BLOCK_FLAG_DUPLICATE || Vcb->data_flags & BLOCK_FLAG_RAID1 || Vcb->data_flags & BLOCK_FLAG_RAID10) {
        nfactor = 1;
        dfactor = 2;
    } else if (Vcb->data_flags & BLOCK_FLAG_RAID5) {
        nfactor = Vcb->superblock.num_devices - 1;
        dfactor = Vcb->superblock.num_devices;
    } else if (Vcb->data_flags & BLOCK_FLAG_RAID6) {
        nfactor = Vcb->superblock.num_devices - 2;
        dfactor = Vcb->superblock.num_devices;
    } else if (Vcb->data_flags & BLOCK_FLAG_RAID1C3) {
        nfactor = 1;
        dfactor = 3;
    } else if (Vcb->data_flags & BLOCK_FLAG_RAID1C4) {
        nfactor = 1;
        dfactor = 4;
    } else {
        nfactor = 1;
        dfactor = 1;
    }
 
    sectors_used = (Vcb->superblock.bytes_used >> Vcb->sector_shift) * nfactor / dfactor;
 
    *totalsize = (Vcb->superblock.total_bytes >> Vcb->sector_shift) * nfactor / dfactor;
    *freespace = sectors_used > *totalsize ? 0 : (*totalsize - sectors_used);
}

Referenced by _Dispatch_type_().

check_file_name_valid()

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

Definition at line 5797 of file btrfs.c.

                                                                                           {
    ULONG i;
 
    if (us->Length < sizeof(WCHAR))
        return STATUS_OBJECT_NAME_INVALID;
 
    if (us->Length > 255 * sizeof(WCHAR))
        return STATUS_OBJECT_NAME_INVALID;
 
    for (i = 0; i < us->Length / sizeof(WCHAR); i++) {
        if (us->Buffer[i] == '/' || us->Buffer[i] == 0 ||
            (!posix && (us->Buffer[i] == '/' || us->Buffer[i] == ':')) ||
            (!posix && !stream && (us->Buffer[i] == '<' || us->Buffer[i] == '>' || us->Buffer[i] == '"' ||
            us->Buffer[i] == '|' || us->Buffer[i] == '?' || us->Buffer[i] == '*' || (us->Buffer[i] >= 1 && us->Buffer[i] <= 31))))
            return STATUS_OBJECT_NAME_INVALID;
 
        /* Don't allow unpaired surrogates ("WTF-16") */
 
        if ((us->Buffer[i] & 0xfc00) == 0xdc00 && (i == 0 || ((us->Buffer[i-1] & 0xfc00) != 0xd800)))
            return STATUS_OBJECT_NAME_INVALID;
 
        if ((us->Buffer[i] & 0xfc00) == 0xd800 && (i == (us->Length / sizeof(WCHAR)) - 1 || ((us->Buffer[i+1] & 0xfc00) != 0xdc00)))
            return STATUS_OBJECT_NAME_INVALID;
    }
 
    if (us->Buffer[0] == '.' && (us->Length == sizeof(WCHAR) || (us->Length == 2 * sizeof(WCHAR) && us->Buffer[1] == '.')))
        return STATUS_OBJECT_NAME_INVALID;
 
    /* The Linux driver expects filenames with a maximum length of 255 bytes - make sure
     * that our UTF-8 length won't be longer than that. */
    if (us->Length >= 85 * sizeof(WCHAR)) {
        NTSTATUS Status;
        ULONG utf8len;
 
        Status = utf16_to_utf8(NULL, 0, &utf8len, us->Buffer, us->Length);
        if (!NT_SUCCESS(Status))
            return Status;
 
        if (utf8len > 255)
            return STATUS_OBJECT_NAME_INVALID;
        else if (stream && utf8len > 250) // minus five bytes for "user."
            return STATUS_OBJECT_NAME_INVALID;
    }
 
    return STATUS_SUCCESS;
}

Referenced by create_snapshot(), create_stream(), create_subvol(), file_create(), find_file_in_dir(), rename_file_to_stream(), rename_stream(), set_link_information(), and set_rename_information().

check_superblock_checksum()

bool check_superblock_checksum

(

superblock *

sb

)

Definition at line 2825 of file btrfs.c.

                                               {
    switch (sb->csum_type) {
        case CSUM_TYPE_CRC32C: {
            uint32_t crc32 = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
 
            if (crc32 == *((uint32_t*)sb->checksum))
                return true;
 
            WARN("crc32 was %08x, expected %08x\n", crc32, *((uint32_t*)sb->checksum));
 
            break;
        }
 
        case CSUM_TYPE_XXHASH: {
            uint64_t hash = XXH64(&sb->uuid, sizeof(superblock) - sizeof(sb->checksum), 0);
 
            if (hash == *((uint64_t*)sb->checksum))
                return true;
 
            WARN("superblock hash was %I64x, expected %I64x\n", hash, *((uint64_t*)sb->checksum));
 
            break;
        }
 
        case CSUM_TYPE_SHA256: {
            uint8_t hash[SHA256_HASH_SIZE];
 
            calc_sha256(hash, &sb->uuid, sizeof(superblock) - sizeof(sb->checksum));
 
            if (RtlCompareMemory(hash, sb, SHA256_HASH_SIZE) == SHA256_HASH_SIZE)
                return true;
 
            WARN("superblock hash was invalid\n");
 
            break;
        }
 
        case CSUM_TYPE_BLAKE2: {
            uint8_t hash[BLAKE2_HASH_SIZE];
 
            blake2b(hash, sizeof(hash), &sb->uuid, sizeof(superblock) - sizeof(sb->checksum));
 
            if (RtlCompareMemory(hash, sb, BLAKE2_HASH_SIZE) == BLAKE2_HASH_SIZE)
                return true;
 
            WARN("superblock hash was invalid\n");
 
            break;
        }
 
        default:
            WARN("unrecognized csum type %x\n", sb->csum_type);
    }
 
    return false;
}

Referenced by device_still_valid(), is_device_part_of_mounted_btrfs_raid(), read_superblock(), still_has_superblock(), test_vol(), and verify_device().

chunk_lock_range()

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

Definition at line 5844 of file btrfs.c.

                                                                                                            {
    LIST_ENTRY* le;
    bool locked;
    range_lock* rl;
 
    rl = ExAllocateFromNPagedLookasideList(&Vcb->range_lock_lookaside);
    if (!rl) {
        ERR("out of memory\n");
        return;
    }
 
    rl->start = start;
    rl->length = length;
    rl->thread = PsGetCurrentThread();
 
    while (true) {
        locked = false;
 
        ExAcquireResourceExclusiveLite(&c->range_locks_lock, true);
 
        le = c->range_locks.Flink;
        while (le != &c->range_locks) {
            range_lock* rl2 = CONTAINING_RECORD(le, range_lock, list_entry);
 
            if (rl2->start < start + length && rl2->start + rl2->length > start && rl2->thread != PsGetCurrentThread()) {
                locked = true;
                break;
            }
 
            le = le->Flink;
        }
 
        if (!locked) {
            InsertTailList(&c->range_locks, &rl->list_entry);
 
            ExReleaseResourceLite(&c->range_locks_lock);
            return;
        }
 
        KeClearEvent(&c->range_locks_event);
 
        ExReleaseResourceLite(&c->range_locks_lock);
 
        KeWaitForSingleObject(&c->range_locks_event, UserRequest, KernelMode, false, NULL);
    }
}

Referenced by read_data(), and scrub_chunk_raid56_stripe_run().

chunk_unlock_range()

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

Definition at line 5891 of file btrfs.c.

                                                                                                              {
    LIST_ENTRY* le;
 
    ExAcquireResourceExclusiveLite(&c->range_locks_lock, true);
 
    le = c->range_locks.Flink;
    while (le != &c->range_locks) {
        range_lock* rl = CONTAINING_RECORD(le, range_lock, list_entry);
 
        if (rl->start == start && rl->length == length) {
            RemoveEntryList(&rl->list_entry);
            ExFreeToNPagedLookasideList(&Vcb->range_lock_lookaside, rl);
            break;
        }
 
        le = le->Flink;
    }
 
    KeSetEvent(&c->range_locks_event, 0, false);
 
    ExReleaseResourceLite(&c->range_locks_lock);
}

Referenced by read_data(), and scrub_chunk_raid56_stripe_run().

close_file()

static NTSTATUS close_file ( _In_ PFILE_OBJECT  FileObject, _In_ PIRP  Irp  )

static

Definition at line 1925 of file btrfs.c.

                                                                        {
    fcb* fcb;
    ccb* ccb;
    file_ref* fileref = NULL;
    LONG open_files;
 
    UNUSED(Irp);
 
    TRACE("FileObject = %p\n", FileObject);
 
    fcb = FileObject->FsContext;
    if (!fcb) {
        TRACE("FCB was NULL, returning success\n");
        return STATUS_SUCCESS;
    }
 
    open_files = InterlockedDecrement(&fcb->Vcb->open_files);
 
    ccb = FileObject->FsContext2;
 
    TRACE("close called for fcb %p)\n", fcb);
 
    // FIXME - make sure notification gets sent if file is being deleted
 
    if (ccb) {
        if (ccb->query_string.Buffer)
            RtlFreeUnicodeString(&ccb->query_string);
 
        if (ccb->filename.Buffer)
            ExFreePool(ccb->filename.Buffer);
 
        // FIXME - use refcounts for fileref
        fileref = ccb->fileref;
 
        if (fcb->Vcb->running_sends > 0) {
            bool send_cancelled = false;
 
            ExAcquireResourceExclusiveLite(&fcb->Vcb->send_load_lock, true);
 
            if (ccb->send) {
                ccb->send->cancelling = true;
                send_cancelled = true;
                KeSetEvent(&ccb->send->cleared_event, 0, false);
            }
 
            ExReleaseResourceLite(&fcb->Vcb->send_load_lock);
 
            if (send_cancelled) {
                while (ccb->send) {
                    ExAcquireResourceExclusiveLite(&fcb->Vcb->send_load_lock, true);
                    ExReleaseResourceLite(&fcb->Vcb->send_load_lock);
                }
            }
        }
 
        ExFreePool(ccb);
    }
 
    CcUninitializeCacheMap(FileObject, NULL, NULL);
 
    if (open_files == 0 && fcb->Vcb->removing) {
        uninit(fcb->Vcb);
        return STATUS_SUCCESS;
    }
 
    if (!(fcb->Vcb->Vpb->Flags & VPB_MOUNTED))
        return STATUS_SUCCESS;
 
    if (fileref)
        free_fileref(fileref);
    else
        free_fcb(fcb);
 
    return STATUS_SUCCESS;
}

compare_strings()

static bool compare_strings ( const UNICODE_STRING *  us1, const UNICODE_STRING *  us2  )

static

Definition at line 650 of file btrfs.c.

                                                                                  {
    if (us1->Length != us2->Length)
        return false;
 
    WCHAR* s1 = us1->Buffer;
    WCHAR* s2 = us2->Buffer;
 
    for (unsigned int i = 0; i < us1->Length; i++) {
        WCHAR c1 = *s1;
        WCHAR c2 = *s2;
 
        if (c1 != c2) {
            if (c1 >= 'a' && c1 <= 'z')
                c1 = c1 - 'a' + 'A';
 
            if (c2 >= 'a' && c2 <= 'z')
                c2 = c2 - 'a' + 'A';
 
            if (c1 != c2)
                return false;
        }
 
        s1++;
        s2++;
    }
 
    return true;
}

Referenced by lie_about_fs_type().

create_calc_threads()

static NTSTATUS create_calc_threads ( _In_ PDEVICE_OBJECT  DeviceObject )

static

Definition at line 4094 of file btrfs.c.

                                                                      {
    device_extension* Vcb = DeviceObject->DeviceExtension;
    OBJECT_ATTRIBUTES oa;
    ULONG i;
 
    Vcb->calcthreads.num_threads = get_num_of_processors();
 
    Vcb->calcthreads.threads = ExAllocatePoolWithTag(NonPagedPool, sizeof(drv_calc_thread) * Vcb->calcthreads.num_threads, ALLOC_TAG);
    if (!Vcb->calcthreads.threads) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    InitializeListHead(&Vcb->calcthreads.job_list);
    KeInitializeSpinLock(&Vcb->calcthreads.spinlock);
    KeInitializeEvent(&Vcb->calcthreads.event, NotificationEvent, false);
 
    RtlZeroMemory(Vcb->calcthreads.threads, sizeof(drv_calc_thread) * Vcb->calcthreads.num_threads);
 
    InitializeObjectAttributes(&oa, NULL, OBJ_KERNEL_HANDLE, NULL, NULL);
 
    for (i = 0; i < Vcb->calcthreads.num_threads; i++) {
        NTSTATUS Status;
 
        Vcb->calcthreads.threads[i].DeviceObject = DeviceObject;
        Vcb->calcthreads.threads[i].number = i;
        KeInitializeEvent(&Vcb->calcthreads.threads[i].finished, NotificationEvent, false);
 
        Status = PsCreateSystemThread(&Vcb->calcthreads.threads[i].handle, 0, &oa, NULL, NULL, calc_thread, &Vcb->calcthreads.threads[i]);
        if (!NT_SUCCESS(Status)) {
            ULONG j;
 
            ERR("PsCreateSystemThread returned %08lx\n", Status);
 
            for (j = 0; j < i; j++) {
                Vcb->calcthreads.threads[i].quit = true;
            }
 
            KeSetEvent(&Vcb->calcthreads.event, 0, false);
 
            return Status;
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by mount_vol().

create_root()

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

Definition at line 1271 of file btrfs.c.

                                                                                                       {
    NTSTATUS Status;
    root* r;
    ROOT_ITEM* ri;
    traverse_ptr tp;
 
    r = ExAllocatePoolWithTag(PagedPool, sizeof(root), ALLOC_TAG);
    if (!r) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    r->nonpaged = ExAllocatePoolWithTag(NonPagedPool, sizeof(root_nonpaged), ALLOC_TAG);
    if (!r->nonpaged) {
        ERR("out of memory\n");
        ExFreePool(r);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    ri = ExAllocatePoolWithTag(PagedPool, sizeof(ROOT_ITEM), ALLOC_TAG);
    if (!ri) {
        ERR("out of memory\n");
 
        ExFreePool(r->nonpaged);
        ExFreePool(r);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    r->id = id;
    r->treeholder.address = 0;
    r->treeholder.generation = Vcb->superblock.generation;
    r->treeholder.tree = NULL;
    r->lastinode = 0;
    r->dirty = false;
    r->received = false;
    r->reserved = NULL;
    r->parent = 0;
    r->send_ops = 0;
    RtlZeroMemory(&r->root_item, sizeof(ROOT_ITEM));
    r->root_item.num_references = 1;
    r->fcbs_version = 0;
    r->checked_for_orphans = true;
    r->dropped = false;
    InitializeListHead(&r->fcbs);
    RtlZeroMemory(r->fcbs_ptrs, sizeof(LIST_ENTRY*) * 256);
 
    RtlCopyMemory(ri, &r->root_item, sizeof(ROOT_ITEM));
 
    // We ask here for a traverse_ptr to the item we're inserting, so we can
    // copy some of the tree's variables
 
    Status = insert_tree_item(Vcb, Vcb->root_root, id, TYPE_ROOT_ITEM, offset, ri, sizeof(ROOT_ITEM), &tp, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("insert_tree_item returned %08lx\n", Status);
        ExFreePool(ri);
        ExFreePool(r->nonpaged);
        ExFreePool(r);
        return Status;
    }
 
    ExInitializeResourceLite(&r->nonpaged->load_tree_lock);
 
    InsertTailList(&Vcb->roots, &r->list_entry);
 
    if (!no_tree) {
        tree* t = ExAllocatePoolWithTag(PagedPool, sizeof(tree), ALLOC_TAG);
        if (!t) {
            ERR("out of memory\n");
 
            delete_tree_item(Vcb, &tp);
 
            ExFreePool(r->nonpaged);
            ExFreePool(r);
            ExFreePool(ri);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        t->nonpaged = NULL;
 
        t->is_unique = true;
        t->uniqueness_determined = true;
        t->buf = NULL;
 
        r->treeholder.tree = t;
 
        RtlZeroMemory(&t->header, sizeof(tree_header));
        t->header.fs_uuid = tp.tree->header.fs_uuid;
        t->header.address = 0;
        t->header.flags = HEADER_FLAG_MIXED_BACKREF | 1; // 1 == "written"? Why does the Linux driver record this?
        t->header.chunk_tree_uuid = tp.tree->header.chunk_tree_uuid;
        t->header.generation = Vcb->superblock.generation;
        t->header.tree_id = id;
        t->header.num_items = 0;
        t->header.level = 0;
 
        t->has_address = false;
        t->size = 0;
        t->Vcb = Vcb;
        t->parent = NULL;
        t->paritem = NULL;
        t->root = r;
 
        InitializeListHead(&t->itemlist);
 
        t->new_address = 0;
        t->has_new_address = false;
        t->updated_extents = false;
 
        InsertTailList(&Vcb->trees, &t->list_entry);
        t->list_entry_hash.Flink = NULL;
 
        t->write = true;
        Vcb->need_write = true;
    }
 
    *rootptr = r;
 
    return STATUS_SUCCESS;
}

Referenced by create_subvol(), do_create_snapshot(), flush_subvol(), and look_for_roots().

DEFINE_GUID()

DEFINE_GUID	(	BtrfsBusInterface	,
		0x4d414874	,
		0x6865	,
		0x6761	,
		0x6d	,
		0x65	,
		0x83	,
		0x69	,
		0x17	,
		0x9a	,
		0x7d	,
		0x1d
	)

delete_fileref()

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

Definition at line 2270 of file btrfs.c.

                                                                                                                                                       {
    LARGE_INTEGER newlength, time;
    BTRFS_TIME now;
    NTSTATUS Status;
    ULONG utf8len = 0;
 
    KeQuerySystemTime(&time);
    win_time_to_unix(time, &now);
 
    ExAcquireResourceExclusiveLite(fileref->fcb->Header.Resource, true);
 
    if (fileref->deleted) {
        ExReleaseResourceLite(fileref->fcb->Header.Resource);
        return STATUS_SUCCESS;
    }
 
    if (fileref->fcb->subvol->send_ops > 0) {
        ExReleaseResourceLite(fileref->fcb->Header.Resource);
        return STATUS_ACCESS_DENIED;
    }
 
    fileref->deleted = true;
    mark_fileref_dirty(fileref);
 
    // delete INODE_ITEM (0x1)
 
    TRACE("nlink = %u\n", fileref->fcb->inode_item.st_nlink);
 
    if (!fileref->fcb->ads) {
        if (fileref->parent->fcb->subvol == fileref->fcb->subvol) {
            LIST_ENTRY* le;
 
            mark_fcb_dirty(fileref->fcb);
 
            fileref->fcb->inode_item_changed = true;
 
            if (fileref->fcb->inode_item.st_nlink > 1 || make_orphan) {
                fileref->fcb->inode_item.st_nlink--;
                fileref->fcb->inode_item.transid = fileref->fcb->Vcb->superblock.generation;
                fileref->fcb->inode_item.sequence++;
                fileref->fcb->inode_item.st_ctime = now;
            } else {
                Status = delete_fileref_fcb(fileref, FileObject, Irp, rollback);
                if (!NT_SUCCESS(Status)) {
                    ERR("delete_fileref_fcb returned %08lx\n", Status);
                    ExReleaseResourceLite(fileref->fcb->Header.Resource);
                    return Status;
                }
            }
 
            if (fileref->dc) {
                le = fileref->fcb->hardlinks.Flink;
                while (le != &fileref->fcb->hardlinks) {
                    hardlink* hl = CONTAINING_RECORD(le, hardlink, list_entry);
 
                    if (hl->parent == fileref->parent->fcb->inode && hl->index == fileref->dc->index) {
                        RemoveEntryList(&hl->list_entry);
 
                        if (hl->name.Buffer)
                            ExFreePool(hl->name.Buffer);
 
                        if (hl->utf8.Buffer)
                            ExFreePool(hl->utf8.Buffer);
 
                        ExFreePool(hl);
                        break;
                    }
 
                    le = le->Flink;
                }
            }
        } else if (fileref->fcb->subvol->parent == fileref->parent->fcb->subvol->id) { // valid subvolume
            if (fileref->fcb->subvol->root_item.num_references > 1) {
                fileref->fcb->subvol->root_item.num_references--;
 
                mark_fcb_dirty(fileref->fcb); // so ROOT_ITEM gets updated
            } else {
                LIST_ENTRY* le;
 
                // FIXME - we need a lock here
 
                RemoveEntryList(&fileref->fcb->subvol->list_entry);
 
                InsertTailList(&fileref->fcb->Vcb->drop_roots, &fileref->fcb->subvol->list_entry);
 
                le = fileref->children.Flink;
                while (le != &fileref->children) {
                    file_ref* fr2 = CONTAINING_RECORD(le, file_ref, list_entry);
 
                    if (fr2->fcb->ads) {
                        fr2->fcb->deleted = true;
                        mark_fcb_dirty(fr2->fcb);
                    }
 
                    le = le->Flink;
                }
            }
        }
    } else {
        fileref->fcb->deleted = true;
        mark_fcb_dirty(fileref->fcb);
    }
 
    // remove dir_child from parent
 
    if (fileref->dc) {
        TRACE("delete file %.*S\n", (int)(fileref->dc->name.Length / sizeof(WCHAR)), fileref->dc->name.Buffer);
 
        ExAcquireResourceExclusiveLite(&fileref->parent->fcb->nonpaged->dir_children_lock, true);
        RemoveEntryList(&fileref->dc->list_entry_index);
 
        if (!fileref->fcb->ads)
            remove_dir_child_from_hash_lists(fileref->parent->fcb, fileref->dc);
 
        ExReleaseResourceLite(&fileref->parent->fcb->nonpaged->dir_children_lock);
 
        if (!fileref->oldutf8.Buffer)
            fileref->oldutf8 = fileref->dc->utf8;
        else
            ExFreePool(fileref->dc->utf8.Buffer);
 
        utf8len = fileref->dc->utf8.Length;
 
        fileref->oldindex = fileref->dc->index;
 
        ExFreePool(fileref->dc->name.Buffer);
        ExFreePool(fileref->dc->name_uc.Buffer);
        ExFreePool(fileref->dc);
 
        fileref->dc = NULL;
    }
 
    // update INODE_ITEM of parent
 
    ExAcquireResourceExclusiveLite(fileref->parent->fcb->Header.Resource, true);
 
    fileref->parent->fcb->inode_item.transid = fileref->fcb->Vcb->superblock.generation;
    fileref->parent->fcb->inode_item.sequence++;
    fileref->parent->fcb->inode_item.st_ctime = now;
 
    if (!fileref->fcb->ads) {
        TRACE("fileref->parent->fcb->inode_item.st_size (inode %I64x) was %I64x\n", fileref->parent->fcb->inode, fileref->parent->fcb->inode_item.st_size);
        fileref->parent->fcb->inode_item.st_size -= utf8len * 2;
        TRACE("fileref->parent->fcb->inode_item.st_size (inode %I64x) now %I64x\n", fileref->parent->fcb->inode, fileref->parent->fcb->inode_item.st_size);
        fileref->parent->fcb->inode_item.st_mtime = now;
    }
 
    fileref->parent->fcb->inode_item_changed = true;
    ExReleaseResourceLite(fileref->parent->fcb->Header.Resource);
 
    if (!fileref->fcb->ads && fileref->parent->dc)
        send_notification_fcb(fileref->parent, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_ACTION_MODIFIED, NULL);
 
    mark_fcb_dirty(fileref->parent->fcb);
 
    fileref->fcb->subvol->root_item.ctransid = fileref->fcb->Vcb->superblock.generation;
    fileref->fcb->subvol->root_item.ctime = now;
 
    newlength.QuadPart = 0;
 
    if (FileObject && !CcUninitializeCacheMap(FileObject, &newlength, NULL))
        TRACE("CcUninitializeCacheMap failed\n");
 
    ExReleaseResourceLite(fileref->fcb->Header.Resource);
 
    return STATUS_SUCCESS;
}

Referenced by _Dispatch_type_(), move_across_subvols(), open_file3(), rename_file_to_stream(), rename_stream(), set_link_information(), and set_rename_information().

delete_fileref_fcb()

static NTSTATUS delete_fileref_fcb ( _In_ file_ref *  fileref, _In_opt_ PFILE_OBJECT  FileObject, _In_opt_ PIRP  Irp, _In_ LIST_ENTRY *  rollback  )

static

Definition at line 2214 of file btrfs.c.

                                                                                                                                           {
    NTSTATUS Status;
    LIST_ENTRY* le;
 
    // excise extents
 
    if (fileref->fcb->type != BTRFS_TYPE_DIRECTORY && fileref->fcb->inode_item.st_size > 0) {
        Status = excise_extents(fileref->fcb->Vcb, fileref->fcb, 0, sector_align(fileref->fcb->inode_item.st_size, fileref->fcb->Vcb->superblock.sector_size), Irp, rollback);
        if (!NT_SUCCESS(Status)) {
            ERR("excise_extents returned %08lx\n", Status);
            return Status;
        }
    }
 
    fileref->fcb->Header.AllocationSize.QuadPart = 0;
    fileref->fcb->Header.FileSize.QuadPart = 0;
    fileref->fcb->Header.ValidDataLength.QuadPart = 0;
 
    if (FileObject) {
        CC_FILE_SIZES ccfs;
 
        ccfs.AllocationSize = fileref->fcb->Header.AllocationSize;
        ccfs.FileSize = fileref->fcb->Header.FileSize;
        ccfs.ValidDataLength = fileref->fcb->Header.ValidDataLength;
 
        Status = STATUS_SUCCESS;
 
        _SEH2_TRY {
            CcSetFileSizes(FileObject, &ccfs);
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
            Status = _SEH2_GetExceptionCode();
        } _SEH2_END;
 
        if (!NT_SUCCESS(Status)) {
            ERR("CcSetFileSizes threw exception %08lx\n", Status);
            return Status;
        }
    }
 
    fileref->fcb->deleted = true;
 
    le = fileref->children.Flink;
    while (le != &fileref->children) {
        file_ref* fr2 = CONTAINING_RECORD(le, file_ref, list_entry);
 
        if (fr2->fcb->ads) {
            fr2->fcb->deleted = true;
            mark_fcb_dirty(fr2->fcb);
        }
 
        le = le->Flink;
    }
 
    return STATUS_SUCCESS;
}

Referenced by _Dispatch_type_(), and delete_fileref().

dev_ioctl()

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

Definition at line 2954 of file btrfs.c.

                                                                                                                                                                  {
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp;
    IO_STATUS_BLOCK IoStatus;
 
    KeInitializeEvent(&Event, NotificationEvent, false);
 
    Irp = IoBuildDeviceIoControlRequest(ControlCode,
                                        DeviceObject,
                                        InputBuffer,
                                        InputBufferSize,
                                        OutputBuffer,
                                        OutputBufferSize,
                                        false,
                                        &Event,
                                        &IoStatus);
 
    if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
 
    if (Override) {
        IrpSp = IoGetNextIrpStackLocation(Irp);
        IrpSp->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
    }
 
    Status = IoCallDriver(DeviceObject, Irp);
 
    if (Status == STATUS_PENDING) {
        KeWaitForSingleObject(&Event, Executive, KernelMode, false, NULL);
        Status = IoStatus.Status;
    }
 
    if (iosb)
        *iosb = IoStatus;
 
    return Status;
}

Referenced by _Function_class_(), add_device(), disk_arrival(), finish_removing_device(), get_device_change_count(), get_devices(), init_device(), is_btrfs_volume(), is_device_removable(), is_volume_mounted(), mount_vol(), mountmgr_add_drive_letter(), mountmgr_notification(), mountmgr_process_drive(), probe_volume(), query_filesystems(), remove_drive_letter(), remove_volume_child(), resize_device(), test_vol(), trim_unalloc_space(), trim_whole_device(), verify_device(), verify_vcb(), vol_check_verify(), vol_get_disk_extents(), vol_is_writable(), and volume_arrival().

device_still_valid()

static bool device_still_valid ( device *  dev, uint64_t  expected_generation  )

static

Definition at line 5546 of file btrfs.c.

                                                                          {
    NTSTATUS Status;
    unsigned int to_read;
    superblock* sb;
 
    to_read = (unsigned int)(dev->devobj->SectorSize == 0 ? sizeof(superblock) : sector_align(sizeof(superblock), dev->devobj->SectorSize));
 
    sb = ExAllocatePoolWithTag(NonPagedPool, to_read, ALLOC_TAG);
    if (!sb) {
        ERR("out of memory\n");
        return false;
    }
 
    Status = sync_read_phys(dev->devobj, dev->fileobj, superblock_addrs[0], to_read, (PUCHAR)sb, false);
    if (!NT_SUCCESS(Status)) {
        ERR("sync_read_phys returned %08lx\n", Status);
        ExFreePool(sb);
        return false;
    }
 
    if (sb->magic != BTRFS_MAGIC) {
        ERR("magic not found\n");
        ExFreePool(sb);
        return false;
    }
 
    if (!check_superblock_checksum(sb)) {
        ExFreePool(sb);
        return false;
    }
 
    if (sb->generation > expected_generation) {
        ERR("generation was %I64x, expected %I64x\n", sb->generation, expected_generation);
        ExFreePool(sb);
        return false;
    }
 
    ExFreePool(sb);
 
    return true;
}

do_shutdown()

void do_shutdown

(

PIRP

Irp

)

Definition at line 5392 of file btrfs.c.

                           {
    LIST_ENTRY* le;
    bus_device_extension* bde;
 
    shutting_down = true;
    KeSetEvent(&mountmgr_thread_event, 0, false);
 
    le = VcbList.Flink;
    while (le != &VcbList) {
        LIST_ENTRY* le2 = le->Flink;
 
        device_extension* Vcb = CONTAINING_RECORD(le, device_extension, list_entry);
        volume_device_extension* vde = Vcb->vde;
        PDEVICE_OBJECT devobj = vde ? vde->device : NULL;
 
        TRACE("shutting down Vcb %p\n", Vcb);
 
        if (vde)
            InterlockedIncrement(&vde->open_count);
 
        if (devobj)
            ObReferenceObject(devobj);
 
        dismount_volume(Vcb, true, Irp);
 
        if (vde) {
            NTSTATUS Status;
            UNICODE_STRING mmdevpath;
            PDEVICE_OBJECT mountmgr;
            PFILE_OBJECT mountmgrfo;
            KIRQL irql;
            PVPB newvpb;
 
            RtlInitUnicodeString(&mmdevpath, MOUNTMGR_DEVICE_NAME);
            Status = IoGetDeviceObjectPointer(&mmdevpath, FILE_READ_ATTRIBUTES, &mountmgrfo, &mountmgr);
            if (!NT_SUCCESS(Status))
                ERR("IoGetDeviceObjectPointer returned %08lx\n", Status);
            else {
                remove_drive_letter(mountmgr, &vde->name);
 
                ObDereferenceObject(mountmgrfo);
            }
 
            vde->removing = true;
 
            newvpb = ExAllocatePoolWithTag(NonPagedPool, sizeof(VPB), ALLOC_TAG);
            if (!newvpb) {
                ERR("out of memory\n");
                return;
            }
 
            RtlZeroMemory(newvpb, sizeof(VPB));
 
            newvpb->Type = IO_TYPE_VPB;
            newvpb->Size = sizeof(VPB);
            newvpb->RealDevice = newvpb->DeviceObject = vde->device;
            newvpb->Flags = VPB_DIRECT_WRITES_ALLOWED;
 
            IoAcquireVpbSpinLock(&irql);
            vde->device->Vpb = newvpb;
            IoReleaseVpbSpinLock(irql);
 
            if (InterlockedDecrement(&vde->open_count) == 0)
                free_vol(vde);
        }
 
        if (devobj)
            ObDereferenceObject(devobj);
 
        le = le2;
    }
 
#ifdef _DEBUG
    if (comfo) {
        ObDereferenceObject(comfo);
        comdo = NULL;
        comfo = NULL;
    }
#endif
 
    IoUnregisterFileSystem(master_devobj);
 
    if (notification_entry2) {
        if (fIoUnregisterPlugPlayNotificationEx)
            fIoUnregisterPlugPlayNotificationEx(notification_entry2);
        else
            IoUnregisterPlugPlayNotification(notification_entry2);
 
        notification_entry2 = NULL;
    }
 
    if (notification_entry3) {
        if (fIoUnregisterPlugPlayNotificationEx)
            fIoUnregisterPlugPlayNotificationEx(notification_entry3);
        else
            IoUnregisterPlugPlayNotification(notification_entry3);
 
        notification_entry3 = NULL;
    }
 
    if (notification_entry) {
        if (fIoUnregisterPlugPlayNotificationEx)
            fIoUnregisterPlugPlayNotificationEx(notification_entry);
        else
            IoUnregisterPlugPlayNotification(notification_entry);
 
        notification_entry = NULL;
    }
 
    bde = busobj->DeviceExtension;
 
    if (bde->attached_device)
        IoDetachDevice(bde->attached_device);
 
    IoDeleteDevice(busobj);
    IoDeleteDevice(master_devobj);
}

Referenced by _Dispatch_type_(), and ioctl_unload().

do_xor_basic()

static void __stdcall do_xor_basic ( uint8_t *  buf1, uint8_t *  buf2, uint32_t  len  )

static

Definition at line 287 of file btrfs.c.

                                                                               {
    uint32_t j;
 
#if defined(_ARM_) || defined(_ARM64_)
    uint64x2_t x1, x2;
 
    if (((uintptr_t)buf1 & 0xf) == 0 && ((uintptr_t)buf2 & 0xf) == 0) {
        while (len >= 16) {
            x1 = vld1q_u64((const uint64_t*)buf1);
            x2 = vld1q_u64((const uint64_t*)buf2);
            x1 = veorq_u64(x1, x2);
            vst1q_u64((uint64_t*)buf1, x1);
 
            buf1 += 16;
            buf2 += 16;
            len -= 16;
        }
    }
#endif
 
#if defined(_AMD64_) || defined(_ARM64_)
    while (len > 8) {
        *(uint64_t*)buf1 ^= *(uint64_t*)buf2;
        buf1 += 8;
        buf2 += 8;
        len -= 8;
    }
#endif
 
    while (len > 4) {
        *(uint32_t*)buf1 ^= *(uint32_t*)buf2;
        buf1 += 4;
        buf2 += 4;
        len -= 4;
    }
 
    for (j = 0; j < len; j++) {
        *buf1 ^= *buf2;
        buf1++;
        buf2++;
    }
}

find_chunk_usage()

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

Definition at line 3876 of file btrfs.c.

                                                                                                                 {
    LIST_ENTRY* le = Vcb->chunks.Flink;
    chunk* c;
    KEY searchkey;
    traverse_ptr tp;
    BLOCK_GROUP_ITEM* bgi;
    NTSTATUS Status;
 
    searchkey.obj_type = TYPE_BLOCK_GROUP_ITEM;
 
    Vcb->superblock.bytes_used = 0;
 
    while (le != &Vcb->chunks) {
        c = CONTAINING_RECORD(le, chunk, list_entry);
 
        searchkey.obj_id = c->offset;
        searchkey.offset = c->chunk_item->size;
 
        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("error - find_item