flushthread.c File Reference

#include "btrfs_drv.h"
#include "xxhash.h"
#include "crc32c.h"
#include <ata.h>
#include <ntddscsi.h>
#include <ntddstor.h>

Include dependency graph for flushthread.c:

Go to the source code of this file.

Classes
struct	write_context
struct	EXTENT_ITEM_TREE2
struct	EXTENT_ITEM_SKINNY_METADATA
struct	ioctl_context_stripe
struct	ioctl_context
struct	write_superblocks_stripe
struct	_write_superblocks_context
struct	extent_range

Macros
#define	MAX_CSUM_SIZE   (4096 - sizeof(tree_header) - (2 * sizeof(leaf_node)))
#define	BATCH_ITEM_LIMIT   1000

Typedefs
typedef struct _write_superblocks_context	write_superblocks_context

Functions
static NTSTATUS	create_chunk (device_extension *Vcb, chunk *c, PIRP Irp)
static NTSTATUS	update_tree_extents (device_extension *Vcb, tree *t, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	insert_tree_item_batch (LIST_ENTRY *batchlist, device_extension *Vcb, root *r, uint64_t objid, uint8_t objtype, uint64_t offset, _In_opt_ _When_(return >=0, __drv_aliasesMem) void *data, uint16_t datalen, enum batch_operation operation)
	_Function_class_ (IO_COMPLETION_ROUTINE)
NTSTATUS	write_data_phys (_In_ PDEVICE_OBJECT device, _In_ PFILE_OBJECT fileobj, _In_ uint64_t address, _In_reads_bytes_(length) void *data, _In_ uint32_t length)
static void	add_trim_entry (device *dev, uint64_t address, uint64_t size)
static void	clean_space_cache_chunk (device_extension *Vcb, chunk *c)
static void	clean_space_cache (device_extension *Vcb)
static bool	trees_consistent (device_extension *Vcb)
static NTSTATUS	add_parents (device_extension *Vcb, PIRP Irp)
static void	add_parents_to_cache (tree *t)
static bool	insert_tree_extent_skinny (device_extension *Vcb, uint8_t level, uint64_t root_id, chunk *c, uint64_t address, PIRP Irp, LIST_ENTRY *rollback)
bool	find_metadata_address_in_chunk (device_extension *Vcb, chunk *c, uint64_t *address)
static bool	insert_tree_extent (device_extension *Vcb, uint8_t level, uint64_t root_id, chunk *c, uint64_t *new_address, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	get_tree_new_address (device_extension *Vcb, tree *t, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	reduce_tree_extent (device_extension *Vcb, uint64_t address, tree *t, uint64_t parent_root, uint8_t level, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	add_changed_extent_ref_edr (changed_extent *ce, EXTENT_DATA_REF *edr, bool old)
static NTSTATUS	add_changed_extent_ref_sdr (changed_extent *ce, SHARED_DATA_REF *sdr, bool old)
static bool	shared_tree_is_unique (device_extension *Vcb, tree *t, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	allocate_tree_extents (device_extension *Vcb, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	update_root_root (device_extension *Vcb, bool no_cache, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	do_tree_writes (device_extension *Vcb, LIST_ENTRY *tree_writes, bool no_free)
void	calc_tree_checksum (device_extension *Vcb, tree_header *th)
static NTSTATUS	write_trees (device_extension *Vcb, PIRP Irp)
static void	update_backup_superblock (device_extension *Vcb, superblock_backup *sb, PIRP Irp)
static void	calc_superblock_checksum (superblock *sb)
static NTSTATUS	write_superblock (device_extension *Vcb, device *device, write_superblocks_context *context)
static NTSTATUS	write_superblocks (device_extension *Vcb, PIRP Irp)
static NTSTATUS	flush_changed_extent (device_extension *Vcb, chunk *c, changed_extent *ce, PIRP Irp, LIST_ENTRY *rollback)
void	add_checksum_entry (device_extension *Vcb, uint64_t address, ULONG length, void *csum, PIRP Irp)
static NTSTATUS	update_chunk_usage (device_extension *Vcb, PIRP Irp, LIST_ENTRY *rollback)
static void	get_first_item (tree *t, KEY *key)
static NTSTATUS	split_tree_at (device_extension *Vcb, tree *t, tree_data *newfirstitem, uint32_t numitems, uint32_t size)
static NTSTATUS	split_tree (device_extension *Vcb, tree *t)
bool	is_tree_unique (device_extension *Vcb, tree *t, PIRP Irp)
static NTSTATUS	try_tree_amalgamate (device_extension *Vcb, tree *t, bool *done, bool *done_deletions, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	update_extent_level (device_extension *Vcb, uint64_t address, tree *t, uint8_t level, PIRP Irp)
static NTSTATUS	update_tree_extents_recursive (device_extension *Vcb, tree *t, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	do_splits (device_extension *Vcb, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	remove_root_extents (device_extension *Vcb, root *r, tree_holder *th, uint8_t level, tree *parent, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	drop_root (device_extension *Vcb, root *r, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	drop_roots (device_extension *Vcb, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	update_dev_item (device_extension *Vcb, device *device, PIRP Irp)
static void	regen_bootstrap (device_extension *Vcb)
static NTSTATUS	add_to_bootstrap (device_extension *Vcb, uint64_t obj_id, uint8_t obj_type, uint64_t offset, void *data, uint16_t size)
static void	remove_from_bootstrap (device_extension *Vcb, uint64_t obj_id, uint8_t obj_type, uint64_t offset)
static NTSTATUS	set_xattr (device_extension *Vcb, LIST_ENTRY *batchlist, root *subvol, uint64_t inode, char *name, uint16_t namelen, uint32_t crc32, uint8_t *data, uint16_t datalen)
static NTSTATUS	delete_xattr (device_extension *Vcb, LIST_ENTRY *batchlist, root *subvol, uint64_t inode, char *name, uint16_t namelen, uint32_t crc32)
static NTSTATUS	insert_sparse_extent (fcb *fcb, LIST_ENTRY *batchlist, uint64_t start, uint64_t length)
static NTSTATUS	split_batch_item_list (batch_item_ind *bii)
static void	rationalize_extents (fcb *fcb, PIRP Irp)
NTSTATUS	flush_fcb (fcb *fcb, bool cache, LIST_ENTRY *batchlist, PIRP Irp)
void	add_trim_entry_avoid_sb (device_extension *Vcb, device *dev, uint64_t address, uint64_t size)
static NTSTATUS	drop_chunk (device_extension *Vcb, chunk *c, LIST_ENTRY *batchlist, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	partial_stripe_read (device_extension *Vcb, chunk *c, partial_stripe *ps, uint64_t startoff, uint16_t parity, ULONG offset, ULONG len)
NTSTATUS	flush_partial_stripe (device_extension *Vcb, chunk *c, partial_stripe *ps)
static NTSTATUS	update_chunks (device_extension *Vcb, LIST_ENTRY *batchlist, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	delete_root_ref (device_extension *Vcb, uint64_t subvolid, uint64_t parsubvolid, uint64_t parinode, PANSI_STRING utf8, PIRP Irp)
static NTSTATUS	add_root_ref (_In_ device_extension *Vcb, _In_ uint64_t subvolid, _In_ uint64_t parsubvolid, _In_ __drv_aliasesMem ROOT_REF *rr, _In_opt_ PIRP Irp)
static NTSTATUS	update_root_backref (device_extension *Vcb, uint64_t subvolid, uint64_t parsubvolid, PIRP Irp)
static NTSTATUS	add_root_item_to_cache (device_extension *Vcb, uint64_t root, PIRP Irp)
static NTSTATUS	flush_fileref (file_ref *fileref, LIST_ENTRY *batchlist, PIRP Irp)
static void	flush_disk_caches (device_extension *Vcb)
static NTSTATUS	flush_changed_dev_stats (device_extension *Vcb, device *dev, PIRP Irp)
static NTSTATUS	flush_subvol (device_extension *Vcb, root *r, PIRP Irp)
static NTSTATUS	test_not_full (device_extension *Vcb)
static NTSTATUS	check_for_orphans_root (device_extension *Vcb, root *r, PIRP Irp)
static NTSTATUS	check_for_orphans (device_extension *Vcb, PIRP Irp)
static NTSTATUS	do_write2 (device_extension *Vcb, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	do_write (device_extension *Vcb, PIRP Irp)
static void	do_flush (device_extension *Vcb)
	_Function_class_ (KSTART_ROUTINE)

Macro Definition Documentation

BATCH_ITEM_LIMIT

#define BATCH_ITEM_LIMIT   1000

Definition at line 32 of file flushthread.c.

MAX_CSUM_SIZE

#define MAX_CSUM_SIZE   (4096 - sizeof(tree_header) - (2 * sizeof(leaf_node)))

Definition at line 28 of file flushthread.c.

Typedef Documentation

write_superblocks_context

typedef struct _write_superblocks_context write_superblocks_context

Function Documentation

_Function_class_() [1/2]

_Function_class_

(

IO_COMPLETION_ROUTINE

)

Definition at line 58 of file flushthread.c.

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

_Function_class_() [2/2]

_Function_class_

(

KSTART_ROUTINE

)

Definition at line 7914 of file flushthread.c.

                                           {
    DEVICE_OBJECT* devobj = context;
    device_extension* Vcb = devobj->DeviceExtension;
    LARGE_INTEGER due_time;
 
    ObReferenceObject(devobj);
 
    KeInitializeTimer(&Vcb->flush_thread_timer);
 
    due_time.QuadPart = (uint64_t)Vcb->options.flush_interval * -10000000;
 
    KeSetTimer(&Vcb->flush_thread_timer, due_time, NULL);
 
    while (true) {
        KeWaitForSingleObject(&Vcb->flush_thread_timer, Executive, KernelMode, false, NULL);
 
        if (!(devobj->Vpb->Flags & VPB_MOUNTED) || Vcb->removing)
            break;
 
        if (!Vcb->locked)
            do_flush(Vcb);
 
        KeSetTimer(&Vcb->flush_thread_timer, due_time, NULL);
    }
 
    ObDereferenceObject(devobj);
    KeCancelTimer(&Vcb->flush_thread_timer);
 
    KeSetEvent(&Vcb->flush_thread_finished, 0, false);
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}

add_changed_extent_ref_edr()

static NTSTATUS add_changed_extent_ref_edr ( changed_extent *  ce, EXTENT_DATA_REF *  edr, bool  old  )

static

Definition at line 1007 of file flushthread.c.

                                                                                               {
    LIST_ENTRY *le2, *list;
    changed_extent_ref* cer;
 
    list = old ? &ce->old_refs : &ce->refs;
 
    le2 = list->Flink;
    while (le2 != list) {
        cer = CONTAINING_RECORD(le2, changed_extent_ref, list_entry);
 
        if (cer->type == TYPE_EXTENT_DATA_REF && cer->edr.root == edr->root && cer->edr.objid == edr->objid && cer->edr.offset == edr->offset) {
            cer->edr.count += edr->count;
            goto end;
        }
 
        le2 = le2->Flink;
    }
 
    cer = ExAllocatePoolWithTag(PagedPool, sizeof(changed_extent_ref), ALLOC_TAG);
    if (!cer) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    cer->type = TYPE_EXTENT_DATA_REF;
    RtlCopyMemory(&cer->edr, edr, sizeof(EXTENT_DATA_REF));
    InsertTailList(list, &cer->list_entry);
 
end:
    if (old)
        ce->old_count += edr->count;
    else
        ce->count += edr->count;
 
    return STATUS_SUCCESS;
}

Referenced by update_tree_extents().

add_changed_extent_ref_sdr()

static NTSTATUS add_changed_extent_ref_sdr ( changed_extent *  ce, SHARED_DATA_REF *  sdr, bool  old  )

static

Definition at line 1044 of file flushthread.c.

                                                                                               {
    LIST_ENTRY *le2, *list;
    changed_extent_ref* cer;
 
    list = old ? &ce->old_refs : &ce->refs;
 
    le2 = list->Flink;
    while (le2 != list) {
        cer = CONTAINING_RECORD(le2, changed_extent_ref, list_entry);
 
        if (cer->type == TYPE_SHARED_DATA_REF && cer->sdr.offset == sdr->offset) {
            cer->sdr.count += sdr->count;
            goto end;
        }
 
        le2 = le2->Flink;
    }
 
    cer = ExAllocatePoolWithTag(PagedPool, sizeof(changed_extent_ref), ALLOC_TAG);
    if (!cer) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    cer->type = TYPE_SHARED_DATA_REF;
    RtlCopyMemory(&cer->sdr, sdr, sizeof(SHARED_DATA_REF));
    InsertTailList(list, &cer->list_entry);
 
end:
    if (old)
        ce->old_count += sdr->count;
    else
        ce->count += sdr->count;
 
    return STATUS_SUCCESS;
}

Referenced by update_tree_extents().

add_checksum_entry()

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

Definition at line 2602 of file flushthread.c.

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

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

add_parents()

static NTSTATUS add_parents ( device_extension *  Vcb, PIRP  Irp  )

static

Definition at line 615 of file flushthread.c.

                                                             {
    ULONG level;
    LIST_ENTRY* le;
 
    for (level = 0; level <= 255; level++) {
        bool nothing_found = true;
 
        TRACE("level = %lu\n", level);
 
        le = Vcb->trees.Flink;
        while (le != &Vcb->trees) {
            tree* t = CONTAINING_RECORD(le, tree, list_entry);
 
            if (t->write && t->header.level == level) {
                TRACE("tree %p: root = %I64x, level = %x, parent = %p\n", t, t->header.tree_id, t->header.level, t->parent);
 
                nothing_found = false;
 
                if (t->parent) {
                    if (!t->parent->write)
                        TRACE("adding tree %p (level %x)\n", t->parent, t->header.level);
 
                    t->parent->write = true;
                } else if (t->root != Vcb->root_root && t->root != Vcb->chunk_root) {
                    KEY searchkey;
                    traverse_ptr tp;
                    NTSTATUS Status;
 
                    searchkey.obj_id = t->root->id;
                    searchkey.obj_type = TYPE_ROOT_ITEM;
                    searchkey.offset = 0xffffffffffffffff;
 
                    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
                    if (!NT_SUCCESS(Status)) {
                        ERR("error - find_item returned %08lx\n", Status);
                        return Status;
                    }
 
                    if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
                        ERR("could not find ROOT_ITEM for tree %I64x\n", searchkey.obj_id);
                        return STATUS_INTERNAL_ERROR;
                    }
 
                    if (tp.item->size < sizeof(ROOT_ITEM)) { // if not full length, delete and create new entry
                        ROOT_ITEM* ri = ExAllocatePoolWithTag(PagedPool, sizeof(ROOT_ITEM), ALLOC_TAG);
 
                        if (!ri) {
                            ERR("out of memory\n");
                            return STATUS_INSUFFICIENT_RESOURCES;
                        }
 
                        RtlCopyMemory(ri, &t->root->root_item, sizeof(ROOT_ITEM));
 
                        Status = delete_tree_item(Vcb, &tp);
                        if (!NT_SUCCESS(Status)) {
                            ERR("delete_tree_item returned %08lx\n", Status);
                            ExFreePool(ri);
                            return Status;
                        }
 
                        Status = insert_tree_item(Vcb, Vcb->root_root, tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, ri, sizeof(ROOT_ITEM), NULL, Irp);
                        if (!NT_SUCCESS(Status)) {
                            ERR("insert_tree_item returned %08lx\n", Status);
                            ExFreePool(ri);
                            return Status;
                        }
                    }
 
                    tree* t2 = tp.tree;
                    while (t2) {
                        t2->write = true;
 
                        t2 = t2->parent;
                    }
                }
            }
 
            le = le->Flink;
        }
 
        if (nothing_found)
            break;
    }
 
    return STATUS_SUCCESS;
}

Referenced by do_write2().

add_parents_to_cache()

static void add_parents_to_cache ( tree *  t )

static

Definition at line 702 of file flushthread.c.

                                          {
    while (t->parent) {
        t = t->parent;
        t->write = true;
    }
}

Referenced by insert_tree_extent(), and insert_tree_extent_skinny().

add_root_item_to_cache()

static NTSTATUS add_root_item_to_cache ( device_extension *  Vcb, uint64_t  root, PIRP  Irp  )

static

Definition at line 6472 of file flushthread.c.

                                                                                       {
    KEY searchkey;
    traverse_ptr tp;
    NTSTATUS Status;
 
    searchkey.obj_id = root;
    searchkey.obj_type = TYPE_ROOT_ITEM;
    searchkey.offset = 0xffffffffffffffff;
 
    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("error - find_item returned %08lx\n", Status);
        return Status;
    }
 
    if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
        ERR("could not find ROOT_ITEM for tree %I64x\n", searchkey.obj_id);
        return STATUS_INTERNAL_ERROR;
    }
 
    if (tp.item->size < sizeof(ROOT_ITEM)) { // if not full length, create new entry with new bits zeroed
        ROOT_ITEM* ri = ExAllocatePoolWithTag(PagedPool, sizeof(ROOT_ITEM), ALLOC_TAG);
        if (!ri) {
            ERR("out of memory\n");
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        if (tp.item->size > 0)
            RtlCopyMemory(ri, tp.item->data, tp.item->size);
 
        RtlZeroMemory(((uint8_t*)ri) + tp.item->size, sizeof(ROOT_ITEM) - tp.item->size);
 
        Status = delete_tree_item(Vcb, &tp);
        if (!NT_SUCCESS(Status)) {
            ERR("delete_tree_item returned %08lx\n", Status);
            ExFreePool(ri);
            return Status;
        }
 
        Status = insert_tree_item(Vcb, Vcb->root_root, searchkey.obj_id, searchkey.obj_type, tp.item->key.offset, ri, sizeof(ROOT_ITEM), NULL, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("insert_tree_item returned %08lx\n", Status);
            ExFreePool(ri);
            return Status;
        }
    } else {
        tp.tree->write = true;
    }
 
    return STATUS_SUCCESS;
}

Referenced by do_write2().

add_root_ref()

static NTSTATUS add_root_ref ( _In_ device_extension *  Vcb, _In_ uint64_t  subvolid, _In_ uint64_t  parsubvolid, _In_ __drv_aliasesMem ROOT_REF *  rr, _In_opt_ PIRP  Irp  )

static

Definition at line 6343 of file flushthread.c.

                                                                                                                                                                   {
    KEY searchkey;
    traverse_ptr tp;
    NTSTATUS Status;
 
    searchkey.obj_id = parsubvolid;
    searchkey.obj_type = TYPE_ROOT_REF;
    searchkey.offset = subvolid;
 
    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("error - find_item returned %08lx\n", Status);
        return Status;
    }
 
    if (!keycmp(searchkey, tp.item->key)) {
        uint16_t rrsize = tp.item->size + (uint16_t)offsetof(ROOT_REF, name[0]) + rr->n;
        uint8_t* rr2;
 
        rr2 = ExAllocatePoolWithTag(PagedPool, rrsize, ALLOC_TAG);
        if (!rr2) {
            ERR("out of memory\n");
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        if (tp.item->size > 0)
            RtlCopyMemory(rr2, tp.item->data, tp.item->size);
 
        RtlCopyMemory(rr2 + tp.item->size, rr, offsetof(ROOT_REF, name[0]) + rr->n);
        ExFreePool(rr);
 
        Status = delete_tree_item(Vcb, &tp);
        if (!NT_SUCCESS(Status)) {
            ERR("delete_tree_item returned %08lx\n", Status);
            ExFreePool(rr2);
            return Status;
        }
 
        Status = insert_tree_item(Vcb, Vcb->root_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, rr2, rrsize, NULL, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("insert_tree_item returned %08lx\n", Status);
            ExFreePool(rr2);
            return Status;
        }
    } else {
        Status = insert_tree_item(Vcb, Vcb->root_root, searchkey.obj_id, searchkey.obj_type, searchkey.offset, rr, (uint16_t)offsetof(ROOT_REF, name[0]) + rr->n, NULL, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("insert_tree_item returned %08lx\n", Status);
            ExFreePool(rr);
            return Status;
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by flush_fileref().

add_to_bootstrap()

static NTSTATUS add_to_bootstrap ( device_extension *  Vcb, uint64_t  obj_id, uint8_t  obj_type, uint64_t  offset, void *  data, uint16_t  size  )

static

Definition at line 4160 of file flushthread.c.

                                                                                                                                       {
    sys_chunk* sc;
    LIST_ENTRY* le;
 
    if (Vcb->superblock.n + sizeof(KEY) + size > SYS_CHUNK_ARRAY_SIZE) {
        ERR("error - bootstrap is full\n");
        return STATUS_INTERNAL_ERROR;
    }
 
    sc = ExAllocatePoolWithTag(PagedPool, sizeof(sys_chunk), ALLOC_TAG);
    if (!sc) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    sc->key.obj_id = obj_id;
    sc->key.obj_type = obj_type;
    sc->key.offset = offset;
    sc->size = size;
    sc->data = ExAllocatePoolWithTag(PagedPool, sc->size, ALLOC_TAG);
    if (!sc->data) {
        ERR("out of memory\n");
        ExFreePool(sc);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlCopyMemory(sc->data, data, sc->size);
 
    le = Vcb->sys_chunks.Flink;
    while (le != &Vcb->sys_chunks) {
        sys_chunk* sc2 = CONTAINING_RECORD(le, sys_chunk, list_entry);
 
        if (keycmp(sc2->key, sc->key) == 1)
            break;
 
        le = le->Flink;
    }
    InsertTailList(le, &sc->list_entry);
 
    Vcb->superblock.n += sizeof(KEY) + size;
 
    regen_bootstrap(Vcb);
 
    return STATUS_SUCCESS;
}

Referenced by create_chunk().

add_trim_entry()

static void add_trim_entry ( device *  dev, uint64_t  address, uint64_t  size  )

static

Definition at line 157 of file flushthread.c.

                                                                         {
    space* s = ExAllocatePoolWithTag(PagedPool, sizeof(space), ALLOC_TAG);
    if (!s) {
        ERR("out of memory\n");
        return;
    }
 
    s->address = address;
    s->size = size;
    dev->num_trim_entries++;
 
    InsertTailList(&dev->trim_list, &s->list_entry);
}

Referenced by add_trim_entry_avoid_sb(), and clean_space_cache_chunk().

add_trim_entry_avoid_sb()

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

Definition at line 5507 of file flushthread.c.

                                                                                                  {
    int i;
    ULONG sblen = (ULONG)sector_align(sizeof(superblock), Vcb->superblock.sector_size);
 
    i = 0;
    while (superblock_addrs[i] != 0) {
        if (superblock_addrs[i] + sblen >= address && superblock_addrs[i] < address + size) {
            if (superblock_addrs[i] > address)
                add_trim_entry(dev, address, superblock_addrs[i] - address);
 
            if (size <= superblock_addrs[i] + sblen - address)
                return;
 
            size -= superblock_addrs[i] + sblen - address;
            address = superblock_addrs[i] + sblen;
        } else if (superblock_addrs[i] > address + size)
            break;
 
        i++;
    }
 
    add_trim_entry(dev, address, size);
}

Referenced by drop_chunk(), and trim_unalloc_space().

allocate_tree_extents()

static NTSTATUS allocate_tree_extents ( device_extension *  Vcb, PIRP  Irp, LIST_ENTRY *  rollback  )

static

Definition at line 1465 of file flushthread.c.

                                                                                             {
    LIST_ENTRY* le;
    NTSTATUS Status;
    bool changed = false;
    uint8_t max_level = 0, level;
 
    TRACE("(%p)\n", Vcb);
 
    le = Vcb->trees.Flink;
    while (le != &Vcb->trees) {
        tree* t = CONTAINING_RECORD(le, tree, list_entry);
 
        if (t->write && !t->has_new_address) {
            chunk* c;
 
            if (t->has_address) {
                c = get_chunk_from_address(Vcb, t->header.address);
 
                if (c) {
                    if (!c->cache_loaded) {
                        acquire_chunk_lock(c, Vcb);
 
                        if (!c->cache_loaded) {
                            Status = load_cache_chunk(Vcb, c, NULL);
 
                            if (!NT_SUCCESS(Status)) {
                                ERR("load_cache_chunk returned %08lx\n", Status);
                                release_chunk_lock(c, Vcb);
                                return Status;
                            }
                        }
 
                        release_chunk_lock(c, Vcb);
                    }
                }
            }
 
            Status = get_tree_new_address(Vcb, t, Irp, rollback);
            if (!NT_SUCCESS(Status)) {
                ERR("get_tree_new_address returned %08lx\n", Status);
                return Status;
            }
 
            TRACE("allocated extent %I64x\n", t->new_address);
 
            c = get_chunk_from_address(Vcb, t->new_address);
 
            if (c)
                c->used += Vcb->superblock.node_size;
            else {
                ERR("could not find chunk for address %I64x\n", t->new_address);
                return STATUS_INTERNAL_ERROR;
            }
 
            changed = true;
 
            if (t->header.level > max_level)
                max_level = t->header.level;
        }
 
        le = le->Flink;
    }
 
    if (!changed)
        return STATUS_SUCCESS;
 
    level = max_level;
    do {
        le = Vcb->trees.Flink;
        while (le != &Vcb->trees) {
            tree* t = CONTAINING_RECORD(le, tree, list_entry);
 
            if (t->write && !t->updated_extents && t->has_address && t->header.level == level) {
                Status = update_tree_extents(Vcb, t, Irp, rollback);
                if (!NT_SUCCESS(Status)) {
                    ERR("update_tree_extents returned %08lx\n", Status);
                    return Status;
                }
            }
 
            le = le->Flink;
        }
 
        if (level == 0)
            break;
 
        level--;
    } while (true);
 
    return STATUS_SUCCESS;
}

Referenced by do_write2().

calc_superblock_checksum()

static void calc_superblock_checksum ( superblock *  sb )

static

Definition at line 2211 of file flushthread.c.

                                                     {
    switch (sb->csum_type) {
        case CSUM_TYPE_CRC32C:
            *(uint32_t*)sb = ~calc_crc32c(0xffffffff, (uint8_t*)&sb->uuid, (ULONG)sizeof(superblock) - sizeof(sb->checksum));
        break;
 
        case CSUM_TYPE_XXHASH:
            *(uint64_t*)sb = XXH64(&sb->uuid, sizeof(superblock) - sizeof(sb->checksum), 0);
        break;
 
        case CSUM_TYPE_SHA256:
            calc_sha256((uint8_t*)sb, &sb->uuid, sizeof(superblock) - sizeof(sb->checksum));
        break;
 
        case CSUM_TYPE_BLAKE2:
            blake2b((uint8_t*)sb, BLAKE2_HASH_SIZE, &sb->uuid, sizeof(superblock) - sizeof(sb->checksum));
        break;
    }
}

Referenced by write_superblock().

calc_tree_checksum()

void calc_tree_checksum	(	device_extension *	Vcb,
		tree_header *	th
	)

Definition at line 1806 of file flushthread.c.

                                                                {
    switch (Vcb->superblock.csum_type) {
        case CSUM_TYPE_CRC32C:
            *((uint32_t*)th) = ~calc_crc32c(0xffffffff, (uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
        break;
 
        case CSUM_TYPE_XXHASH:
            *((uint64_t*)th) = XXH64((uint8_t*)&th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum), 0);
        break;
 
        case CSUM_TYPE_SHA256:
            calc_sha256((uint8_t*)th, &th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
        break;
 
        case CSUM_TYPE_BLAKE2:
            blake2b((uint8_t*)th, BLAKE2_HASH_SIZE, &th->fs_uuid, Vcb->superblock.node_size - sizeof(th->csum));
        break;
    }
}

Referenced by snapshot_tree_copy(), write_metadata_items(), and write_trees().

check_for_orphans()

static NTSTATUS check_for_orphans ( device_extension *  Vcb, PIRP  Irp  )

static

Definition at line 7450 of file flushthread.c.

                                                                   {
    NTSTATUS Status;
    LIST_ENTRY* le;
 
    if (IsListEmpty(&Vcb->dirty_filerefs))
        return STATUS_SUCCESS;
 
    le = Vcb->dirty_filerefs.Flink;
    while (le != &Vcb->dirty_filerefs) {
        file_ref* fr = CONTAINING_RECORD(le, file_ref, list_entry_dirty);
 
        if (!fr->fcb->subvol->checked_for_orphans) {
            Status = check_for_orphans_root(Vcb, fr->fcb->subvol, Irp);
            if (!NT_SUCCESS(Status)) {
                ERR("check_for_orphans_root returned %08lx\n", Status);
                return Status;
            }
 
            fr->fcb->subvol->checked_for_orphans = true;
        }
 
        le = le->Flink;
    }
 
    return STATUS_SUCCESS;
}

Referenced by do_write2().

check_for_orphans_root()

static NTSTATUS check_for_orphans_root ( device_extension *  Vcb, root *  r, PIRP  Irp  )

static

Definition at line 7375 of file flushthread.c.

                                                                                 {
    NTSTATUS Status;
    KEY searchkey;
    traverse_ptr tp;
    LIST_ENTRY rollback;
 
    TRACE("(%p, %p)\n", Vcb, r);
 
    InitializeListHead(&rollback);
 
    searchkey.obj_id = BTRFS_ORPHAN_INODE_OBJID;
    searchkey.obj_type = TYPE_ORPHAN_INODE;
    searchkey.offset = 0;
 
    Status = find_item(Vcb, r, &tp, &searchkey, false, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("find_item returned %08lx\n", Status);
        return Status;
    }
 
    do {
        traverse_ptr next_tp;
 
        if (tp.item->key.obj_id > searchkey.obj_id || (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type > searchkey.obj_type))
            break;
 
        if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type) {
            fcb* fcb;
 
            TRACE("removing orphaned inode %I64x\n", tp.item->key.offset);
 
            Status = open_fcb(Vcb, r, tp.item->key.offset, 0, NULL, false, NULL, &fcb, PagedPool, Irp);
            if (!NT_SUCCESS(Status))
                ERR("open_fcb returned %08lx\n", Status);
            else {
                if (fcb->inode_item.st_nlink == 0) {
                    if (fcb->type != BTRFS_TYPE_DIRECTORY && fcb->inode_item.st_size > 0) {
                        Status = excise_extents(Vcb, fcb, 0, sector_align(fcb->inode_item.st_size, Vcb->superblock.sector_size), Irp, &rollback);
                        if (!NT_SUCCESS(Status)) {
                            ERR("excise_extents returned %08lx\n", Status);
                            goto end;
                        }
                    }
 
                    fcb->deleted = true;
 
                    mark_fcb_dirty(fcb);
                }
 
                free_fcb(fcb);
 
                Status = delete_tree_item(Vcb, &tp);
                if (!NT_SUCCESS(Status)) {
                    ERR("delete_tree_item returned %08lx\n", Status);
                    goto end;
                }
            }
        }
 
        if (find_next_item(Vcb, &tp, &next_tp, false, Irp))
            tp = next_tp;
        else
            break;
    } while (true);
 
    Status = STATUS_SUCCESS;
 
    clear_rollback(&rollback);
 
end:
    do_rollback(Vcb, &rollback);
 
    return Status;
}

Referenced by check_for_orphans().

clean_space_cache()

static void clean_space_cache ( device_extension *  Vcb )

static

Definition at line 403 of file flushthread.c.

                                                     {
    LIST_ENTRY* le;
    chunk* c;
#ifndef DEBUG_TRIM_EMULATION
    ULONG num;
#endif
 
    TRACE("(%p)\n", Vcb);
 
    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);
 
    le = Vcb->chunks.Flink;
    while (le != &Vcb->chunks) {
        c = CONTAINING_RECORD(le, chunk, list_entry);
 
        if (c->space_changed) {
            acquire_chunk_lock(c, Vcb);
 
            if (c->space_changed) {
                if (Vcb->trim && !Vcb->options.no_trim)
                    clean_space_cache_chunk(Vcb, c);
 
                space_list_merge(&c->space, &c->space_size, &c->deleting);
 
                while (!IsListEmpty(&c->deleting)) {
                    space* s = CONTAINING_RECORD(RemoveHeadList(&c->deleting), space, list_entry);
 
                    ExFreePool(s);
                }
            }
 
            c->space_changed = false;
 
            release_chunk_lock(c, Vcb);
        }
 
        le = le->Flink;
    }
 
    ExReleaseResourceLite(&Vcb->chunk_lock);
 
    if (Vcb->trim && !Vcb->options.no_trim) {
#ifndef DEBUG_TRIM_EMULATION
        ioctl_context context;
        ULONG total_num;
 
        context.left = 0;
 
        le = Vcb->devices.Flink;
        while (le != &Vcb->devices) {
            device* dev = CONTAINING_RECORD(le, device, list_entry);
 
            if (dev->devobj && !dev->readonly && dev->trim && dev->num_trim_entries > 0)
                context.left++;
 
            le = le->Flink;
        }
 
        if (context.left == 0)
            return;
 
        total_num = context.left;
        num = 0;
 
        KeInitializeEvent(&context.Event, NotificationEvent, false);
 
        context.stripes = ExAllocatePoolWithTag(NonPagedPool, sizeof(ioctl_context_stripe) * context.left, ALLOC_TAG);
        if (!context.stripes) {
            ERR("out of memory\n");
            return;
        }
 
        RtlZeroMemory(context.stripes, sizeof(ioctl_context_stripe) * context.left);
#endif
 
        le = Vcb->devices.Flink;
        while (le != &Vcb->devices) {
            device* dev = CONTAINING_RECORD(le, device, list_entry);
 
            if (dev->devobj && !dev->readonly && dev->trim && dev->num_trim_entries > 0) {
#ifdef DEBUG_TRIM_EMULATION
                trim_emulation(dev);
#else
                LIST_ENTRY* le2;
                ioctl_context_stripe* stripe = &context.stripes[num];
                DEVICE_DATA_SET_RANGE* ranges;
                ULONG datalen = (ULONG)sector_align(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), sizeof(uint64_t)) + (dev->num_trim_entries * sizeof(DEVICE_DATA_SET_RANGE)), i;
                PIO_STACK_LOCATION IrpSp;
 
                stripe->dmdsa = ExAllocatePoolWithTag(PagedPool, datalen, ALLOC_TAG);
                if (!stripe->dmdsa) {
                    ERR("out of memory\n");
                    goto nextdev;
                }
 
                stripe->dmdsa->Size = sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES);
                stripe->dmdsa->Action = DeviceDsmAction_Trim;
                stripe->dmdsa->Flags = DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED;
                stripe->dmdsa->ParameterBlockOffset = 0;
                stripe->dmdsa->ParameterBlockLength = 0;
                stripe->dmdsa->DataSetRangesOffset = (ULONG)sector_align(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES), sizeof(uint64_t));
                stripe->dmdsa->DataSetRangesLength = dev->num_trim_entries * sizeof(DEVICE_DATA_SET_RANGE);
 
                ranges = (DEVICE_DATA_SET_RANGE*)((uint8_t*)stripe->dmdsa + stripe->dmdsa->DataSetRangesOffset);
 
                i = 0;
 
                le2 = dev->trim_list.Flink;
                while (le2 != &dev->trim_list) {
                    space* s = CONTAINING_RECORD(le2, space, list_entry);
 
                    ranges[i].StartingOffset = s->address;
                    ranges[i].LengthInBytes = s->size;
                    i++;
 
                    le2 = le2->Flink;
                }
 
                stripe->Irp = IoAllocateIrp(dev->devobj->StackSize, false);
 
                if (!stripe->Irp) {
                    ERR("IoAllocateIrp failed\n");
                    goto nextdev;
                }
 
                IrpSp = IoGetNextIrpStackLocation(stripe->Irp);
                IrpSp->MajorFunction = IRP_MJ_DEVICE_CONTROL;
                IrpSp->FileObject = dev->fileobj;
 
                IrpSp->Parameters.DeviceIoControl.IoControlCode = IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES;
                IrpSp->Parameters.DeviceIoControl.InputBufferLength = datalen;
                IrpSp->Parameters.DeviceIoControl.OutputBufferLength = 0;
 
                stripe->Irp->AssociatedIrp.SystemBuffer = stripe->dmdsa;
                stripe->Irp->Flags |= IRP_BUFFERED_IO;
                stripe->Irp->UserBuffer = NULL;
                stripe->Irp->UserIosb = &stripe->iosb;
 
                IoSetCompletionRoutine(stripe->Irp, ioctl_completion, &context, true, true, true);
 
                IoCallDriver(dev->devobj, stripe->Irp);
 
nextdev:
#endif
                while (!IsListEmpty(&dev->trim_list)) {
                    space* s = CONTAINING_RECORD(RemoveHeadList(&dev->trim_list), space, list_entry);
                    ExFreePool(s);
                }
 
                dev->num_trim_entries = 0;
 
#ifndef DEBUG_TRIM_EMULATION
                num++;
#endif
            }
 
            le = le->Flink;
        }
 
#ifndef DEBUG_TRIM_EMULATION
        KeWaitForSingleObject(&context.Event, Executive, KernelMode, false, NULL);
 
        for (num = 0; num < total_num; num++) {
            if (context.stripes[num].dmdsa)
                ExFreePool(context.stripes[num].dmdsa);
 
            if (context.stripes[num].Irp)
                IoFreeIrp(context.stripes[num].Irp);
        }
 
        ExFreePool(context.stripes);
#endif
    }
}

Referenced by do_write2().

clean_space_cache_chunk()

static void clean_space_cache_chunk ( device_extension *  Vcb, chunk *  c  )

static

Definition at line 171 of file flushthread.c.

                                                                     {
    LIST_ENTRY* le;
    ULONG type;
 
    if (c->chunk_item->type & BLOCK_FLAG_DUPLICATE)
        type = BLOCK_FLAG_DUPLICATE;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID0)
        type = BLOCK_FLAG_RAID0;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID1)
        type = BLOCK_FLAG_DUPLICATE;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID10)
        type = BLOCK_FLAG_RAID10;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID5)
        type = BLOCK_FLAG_RAID5;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID6)
        type = BLOCK_FLAG_RAID6;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID1C3)
        type = BLOCK_FLAG_DUPLICATE;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID1C4)
        type = BLOCK_FLAG_DUPLICATE;
    else // SINGLE
        type = BLOCK_FLAG_DUPLICATE;
 
    le = c->deleting.Flink;
    while (le != &c->deleting) {
        space* s = CONTAINING_RECORD(le, space, list_entry);
 
        if (!Vcb->options.no_barrier || !(c->chunk_item->type & BLOCK_FLAG_METADATA)) {
            CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
 
            if (type == BLOCK_FLAG_DUPLICATE) {
                uint16_t i;
 
                for (i = 0; i < c->chunk_item->num_stripes; i++) {
                    if (c->devices[i] && c->devices[i]->devobj && !c->devices[i]->readonly && c->devices[i]->trim)
                        add_trim_entry(c->devices[i], s->address - c->offset + cis[i].offset, s->size);
                }
            } else if (type == BLOCK_FLAG_RAID0) {
                uint64_t startoff, endoff;
                uint16_t startoffstripe, endoffstripe, i;
 
                get_raid0_offset(s->address - c->offset, c->chunk_item->stripe_length, c->chunk_item->num_stripes, &startoff, &startoffstripe);
                get_raid0_offset(s->address - c->offset + s->size - 1, c->chunk_item->stripe_length, c->chunk_item->num_stripes, &endoff, &endoffstripe);
 
                for (i = 0; i < c->chunk_item->num_stripes; i++) {
                    if (c->devices[i] && c->devices[i]->devobj && !c->devices[i]->readonly && c->devices[i]->trim) {
                        uint64_t stripestart, stripeend;
 
                        if (startoffstripe > i)
                            stripestart = startoff - (startoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length;
                        else if (startoffstripe == i)
                            stripestart = startoff;
                        else
                            stripestart = startoff - (startoff % c->chunk_item->stripe_length);
 
                        if (endoffstripe > i)
                            stripeend = endoff - (endoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length;
                        else if (endoffstripe == i)
                            stripeend = endoff + 1;
                        else
                            stripeend = endoff - (endoff % c->chunk_item->stripe_length);
 
                        if (stripestart != stripeend)
                            add_trim_entry(c->devices[i], stripestart + cis[i].offset, stripeend - stripestart);
                    }
                }
            } else if (type == BLOCK_FLAG_RAID10) {
                uint64_t startoff, endoff;
                uint16_t sub_stripes, startoffstripe, endoffstripe, i;
 
                sub_stripes = max(1, c->chunk_item->sub_stripes);
 
                get_raid0_offset(s->address - c->offset, c->chunk_item->stripe_length, c->chunk_item->num_stripes / sub_stripes, &startoff, &startoffstripe);
                get_raid0_offset(s->address - c->offset + s->size - 1, c->chunk_item->stripe_length, c->chunk_item->num_stripes / sub_stripes, &endoff, &endoffstripe);
 
                startoffstripe *= sub_stripes;
                endoffstripe *= sub_stripes;
 
                for (i = 0; i < c->chunk_item->num_stripes; i += sub_stripes) {
                    ULONG j;
                    uint64_t stripestart, stripeend;
 
                    if (startoffstripe > i)
                        stripestart = startoff - (startoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length;
                    else if (startoffstripe == i)
                        stripestart = startoff;
                    else
                        stripestart = startoff - (startoff % c->chunk_item->stripe_length);
 
                    if (endoffstripe > i)
                        stripeend = endoff - (endoff % c->chunk_item->stripe_length) + c->chunk_item->stripe_length;
                    else if (endoffstripe == i)
                        stripeend = endoff + 1;
                    else
                        stripeend = endoff - (endoff % c->chunk_item->stripe_length);
 
                    if (stripestart != stripeend) {
                        for (j = 0; j < sub_stripes; j++) {
                            if (c->devices[i+j] && c->devices[i+j]->devobj && !c->devices[i+j]->readonly && c->devices[i+j]->trim)
                                add_trim_entry(c->devices[i+j], stripestart + cis[i+j].offset, stripeend - stripestart);
                        }
                    }
                }
            }
            // FIXME - RAID5(?), RAID6(?)
        }
 
        le = le->Flink;
    }
}

Referenced by clean_space_cache().

create_chunk()

static NTSTATUS create_chunk ( device_extension *  Vcb, chunk *  c, PIRP  Irp  )

static

Definition at line 4206 of file flushthread.c.

                                                                        {
    CHUNK_ITEM* ci;
    CHUNK_ITEM_STRIPE* cis;
    BLOCK_GROUP_ITEM* bgi;
    uint16_t i, factor;
    NTSTATUS Status;
 
    ci = ExAllocatePoolWithTag(PagedPool, c->size, ALLOC_TAG);
    if (!ci) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlCopyMemory(ci, c->chunk_item, c->size);
 
    Status = insert_tree_item(Vcb, Vcb->chunk_root, 0x100, TYPE_CHUNK_ITEM, c->offset, ci, c->size, NULL, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("insert_tree_item failed\n");
        ExFreePool(ci);
        return Status;
    }
 
    if (c->chunk_item->type & BLOCK_FLAG_SYSTEM) {
        Status = add_to_bootstrap(Vcb, 0x100, TYPE_CHUNK_ITEM, c->offset, ci, c->size);
        if (!NT_SUCCESS(Status)) {
            ERR("add_to_bootstrap returned %08lx\n", Status);
            return Status;
        }
    }
 
    // add BLOCK_GROUP_ITEM to tree 2
 
    bgi = ExAllocatePoolWithTag(PagedPool, sizeof(BLOCK_GROUP_ITEM), ALLOC_TAG);
    if (!bgi) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    bgi->used = c->used;
    bgi->chunk_tree = 0x100;
    bgi->flags = c->chunk_item->type;
 
    Status = insert_tree_item(Vcb, Vcb->extent_root, c->offset, TYPE_BLOCK_GROUP_ITEM, c->chunk_item->size, bgi, sizeof(BLOCK_GROUP_ITEM), NULL, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("insert_tree_item failed\n");
        ExFreePool(bgi);
        return Status;
    }
 
    if (c->chunk_item->type & BLOCK_FLAG_RAID0)
        factor = c->chunk_item->num_stripes;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID10)
        factor = c->chunk_item->num_stripes / c->chunk_item->sub_stripes;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID5)
        factor = c->chunk_item->num_stripes - 1;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID6)
        factor = c->chunk_item->num_stripes - 2;
    else // SINGLE, DUPLICATE, RAID1, RAID1C3, RAID1C4
        factor = 1;
 
    // add DEV_EXTENTs to tree 4
 
    cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
 
    for (i = 0; i < c->chunk_item->num_stripes; i++) {
        DEV_EXTENT* de;
 
        de = ExAllocatePoolWithTag(PagedPool, sizeof(DEV_EXTENT), ALLOC_TAG);
        if (!de) {
            ERR("out of memory\n");
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        de->chunktree = Vcb->chunk_root->id;
        de->objid = 0x100;
        de->address = c->offset;
        de->length = c->chunk_item->size / factor;
        de->chunktree_uuid = Vcb->chunk_root->treeholder.tree->header.chunk_tree_uuid;
 
        Status = insert_tree_item(Vcb, Vcb->dev_root, c->devices[i]->devitem.dev_id, TYPE_DEV_EXTENT, cis[i].offset, de, sizeof(DEV_EXTENT), NULL, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("insert_tree_item returned %08lx\n", Status);
            ExFreePool(de);
            return Status;
        }
 
        // FIXME - no point in calling this twice for the same device
        Status = update_dev_item(Vcb, c->devices[i], Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("update_dev_item returned %08lx\n", Status);
            return Status;
        }
    }
 
    c->created = false;
    c->oldused = c->used;
 
    Vcb->superblock.bytes_used += c->used;
 
    return STATUS_SUCCESS;
}

Referenced by update_chunk_usage(), and update_chunks().

delete_root_ref()

static NTSTATUS delete_root_ref ( device_extension *  Vcb, uint64_t  subvolid, uint64_t  parsubvolid, uint64_t  parinode, PANSI_STRING  utf8, PIRP  Irp  )

static

Definition at line 6246 of file flushthread.c.

                                                                                                                                                {
    KEY searchkey;
    traverse_ptr tp;
    NTSTATUS Status;
 
    searchkey.obj_id = parsubvolid;
    searchkey.obj_type = TYPE_ROOT_REF;
    searchkey.offset = subvolid;
 
    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("error - find_item returned %08lx\n", Status);
        return Status;
    }
 
    if (!keycmp(searchkey, tp.item->key)) {
        if (tp.item->size < sizeof(ROOT_REF)) {
            ERR("(%I64x,%x,%I64x) was %u bytes, expected at least %Iu\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, tp.item->size, sizeof(ROOT_REF));
            return STATUS_INTERNAL_ERROR;
        } else {
            ROOT_REF* rr;
            ULONG len;
 
            rr = (ROOT_REF*)tp.item->data;
            len = tp.item->size;
 
            do {
                uint16_t itemlen;
 
                if (len < sizeof(ROOT_REF) || len < offsetof(ROOT_REF, name[0]) + rr->n) {
                    ERR("(%I64x,%x,%I64x) was truncated\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
                    break;
                }
 
                itemlen = (uint16_t)offsetof(ROOT_REF, name[0]) + rr->n;
 
                if (rr->dir == parinode && rr->n == utf8->Length && RtlCompareMemory(rr->name, utf8->Buffer, rr->n) == rr->n) {
                    uint16_t newlen = tp.item->size - itemlen;
 
                    Status = delete_tree_item(Vcb, &tp);
                    if (!NT_SUCCESS(Status)) {
                        ERR("delete_tree_item returned %08lx\n", Status);
                        return Status;
                    }
 
                    if (newlen == 0) {
                        TRACE("deleting (%I64x,%x,%I64x)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
                    } else {
                        uint8_t *newrr = ExAllocatePoolWithTag(PagedPool, newlen, ALLOC_TAG), *rroff;
 
                        if (!newrr) {
                            ERR("out of memory\n");
                            return STATUS_INSUFFICIENT_RESOURCES;
                        }
 
                        TRACE("modifying (%I64x,%x,%I64x)\n", tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset);
 
                        if ((uint8_t*)rr > tp.item->data) {
                            RtlCopyMemory(newrr, tp.item->data, (uint8_t*)rr - tp.item->data);
                            rroff = newrr + ((uint8_t*)rr - tp.item->data);
                        } else {
                            rroff = newrr;
                        }
 
                        if ((uint8_t*)&rr->name[rr->n] < tp.item->data + tp.item->size)
                            RtlCopyMemory(rroff, &rr->name[rr->n], tp.item->size - ((uint8_t*)&rr->name[rr->n] - tp.item->data));
 
                        Status = insert_tree_item(Vcb, Vcb->root_root, tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset, newrr, newlen, NULL, Irp);
                        if (!NT_SUCCESS(Status)) {
                            ERR("insert_tree_item returned %08lx\n", Status);
                            ExFreePool(newrr);
                            return Status;
                        }
                    }
 
                    break;
                }
 
                if (len > itemlen) {
                    len -= itemlen;
                    rr = (ROOT_REF*)&rr->name[rr->n];
                } else
                    break;
            } while (len > 0);
        }
    } else {
        WARN("could not find ROOT_REF entry for subvol %I64x in %I64x\n", searchkey.offset, searchkey.obj_id);
        return STATUS_NOT_FOUND;
    }
 
    return STATUS_SUCCESS;
}

Referenced by flush_fileref().

delete_xattr()

static NTSTATUS delete_xattr ( device_extension *  Vcb, LIST_ENTRY *  batchlist, root *  subvol, uint64_t  inode, char *  name, uint16_t  namelen, uint32_t  crc32  )

static

Definition at line 4367 of file flushthread.c.

                                                               {
    NTSTATUS Status;
    uint16_t xasize;
    DIR_ITEM* xa;
 
    TRACE("(%p, %I64x, %I64x, %.*s, %08x)\n", Vcb, subvol->id, inode, namelen, name, crc32);
 
    xasize = (uint16_t)offsetof(DIR_ITEM, name[0]) + namelen;
 
    xa = ExAllocatePoolWithTag(PagedPool, xasize, ALLOC_TAG);
    if (!xa) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    xa->key.obj_id = 0;
    xa->key.obj_type = 0;
    xa->key.offset = 0;
    xa->transid = Vcb->superblock.generation;
    xa->m = 0;
    xa->n = namelen;
    xa->type = BTRFS_TYPE_EA;
    RtlCopyMemory(xa->name, name, namelen);
 
    Status = insert_tree_item_batch(batchlist, Vcb, subvol, inode, TYPE_XATTR_ITEM, crc32, xa, xasize, Batch_DeleteXattr);
    if (!NT_SUCCESS(Status)) {
        ERR("insert_tree_item_batch returned %08lx\n", Status);
        ExFreePool(xa);
        return Status;
    }
 
    return STATUS_SUCCESS;
}

Referenced by flush_fcb().

do_flush()

static void do_flush ( device_extension *  Vcb )

static

Definition at line 7896 of file flushthread.c.

                                            {
    NTSTATUS Status;
 
    ExAcquireResourceExclusiveLite(&Vcb->tree_lock, true);
 
    if (Vcb->need_write && !Vcb->readonly)
        Status = do_write(Vcb, NULL);
    else
        Status = STATUS_SUCCESS;
 
    free_trees(Vcb);
 
    if (!NT_SUCCESS(Status))
        ERR("do_write returned %08lx\n", Status);
 
    ExReleaseResourceLite(&Vcb->tree_lock);
}

Referenced by _Function_class_().

do_splits()

static NTSTATUS do_splits ( device_extension *  Vcb, PIRP  Irp, LIST_ENTRY *  rollback  )

static

Definition at line 3654 of file flushthread.c.

                                                                                 {
    ULONG level, max_level;
    uint32_t min_size, min_size_fst;
    bool empty, done_deletions = false;
    NTSTATUS Status;
    tree* t;
 
    TRACE("(%p)\n", Vcb);
 
    max_level = 0;
 
    for (level = 0; level <= 255; level++) {
        LIST_ENTRY *le, *nextle;
 
        empty = true;
 
        TRACE("doing level %lu\n", level);
 
        le = Vcb->trees.Flink;
 
        while (le != &Vcb->trees) {
            t = CONTAINING_RECORD(le, tree, list_entry);
 
            nextle = le->Flink;
 
            if (t->write && t->header.level == level) {
                empty = false;
 
                if (t->header.num_items == 0) {
                    if (t->parent) {
                        done_deletions = true;
 
                        TRACE("deleting tree in root %I64x\n", t->root->id);
 
                        t->root->root_item.bytes_used -= Vcb->superblock.node_size;
 
                        if (t->has_new_address) { // delete associated EXTENT_ITEM
                            Status = reduce_tree_extent(Vcb, t->new_address, t, t->parent->header.tree_id, t->header.level, Irp, rollback);
 
                            if (!NT_SUCCESS(Status)) {
                                ERR("reduce_tree_extent returned %08lx\n", Status);
                                return Status;
                            }
 
                            t->has_new_address = false;
                        } else if (t->has_address) {
                            Status = reduce_tree_extent(Vcb,t->header.address, t, t->parent->header.tree_id, t->header.level, Irp, rollback);
 
                            if (!NT_SUCCESS(Status)) {
                                ERR("reduce_tree_extent returned %08lx\n", Status);
                                return Status;
                            }
 
                            t->has_address = false;
                        }
 
                        if (!t->paritem->ignore) {
                            t->paritem->ignore = true;
                            t->parent->header.num_items--;
                            t->parent->size -= sizeof(internal_node);
                        }
 
                        RemoveEntryList(&t->paritem->list_entry);
                        ExFreePool(t->paritem);
                        t->paritem = NULL;
 
                        free_tree(t);
                    } else if (t->header.level != 0) {
                        if (t->has_new_address) {
                            Status = update_extent_level(Vcb, t->new_address, t, 0, Irp);
 
                            if (!NT_SUCCESS(Status)) {
                                ERR("update_extent_level returned %08lx\n", Status);
                                return Status;
                            }
                        }
 
                        t->header.level = 0;
                    }
                } else if (t->size > Vcb->superblock.node_size - sizeof(tree_header)) {
                    TRACE("splitting overlarge tree (%x > %Ix)\n", t->size, Vcb->superblock.node_size - sizeof(tree_header));
 
                    if (!t->updated_extents && t->has_address) {
                        Status = update_tree_extents_recursive(Vcb, t, Irp, rollback);
                        if (!NT_SUCCESS(Status)) {
                            ERR("update_tree_extents_recursive returned %08lx\n", Status);
                            return Status;
                        }
                    }
 
                    Status = split_tree(Vcb, t);
 
                    if (!NT_SUCCESS(Status)) {
                        ERR("split_tree returned %08lx\n", Status);
                        return Status;
                    }
                }
            }
 
            le = nextle;
        }
 
        if (!empty) {
            max_level = level;
        } else {
            TRACE("nothing found for level %lu\n", level);
            break;
        }
    }
 
    min_size = (Vcb->superblock.node_size - sizeof(tree_header)) / 2;
    min_size_fst = (Vcb->superblock.node_size - sizeof(tree_header)) / 4;
 
    for (level = 0; level <= max_level; level++) {
        LIST_ENTRY* le;
 
        le = Vcb->trees.Flink;
 
        while (le != &Vcb->trees) {
            t = CONTAINING_RECORD(le, tree, list_entry);
 
            if (t->write && t->header.level == level && t->header.num_items > 0 && t->parent &&
                ((t->size < min_size && t->root->id != BTRFS_ROOT_FREE_SPACE) || (t->size < min_size_fst && t->root->id == BTRFS_ROOT_FREE_SPACE)) &&
                is_tree_unique(Vcb, t, Irp)) {
                bool done;
 
                do {
                    Status = try_tree_amalgamate(Vcb, t, &done, &done_deletions, Irp, rollback);
                    if (!NT_SUCCESS(Status)) {
                        ERR("try_tree_amalgamate returned %08lx\n", Status);
                        return Status;
                    }
                } while (done && t->size < min_size);
            }
 
            le = le->Flink;
        }
    }
 
    // simplify trees if top tree only has one entry
 
    if (done_deletions) {
        for (level = max_level; level > 0; level--) {
            LIST_ENTRY *le, *nextle;
 
            le = Vcb->trees.Flink;
            while (le != &Vcb->trees) {
                nextle = le->Flink;
                t = CONTAINING_RECORD(le, tree, list_entry);
 
                if (t->write && t->header.level == level) {
                    if (!t->parent && t->header.num_items == 1) {
                        LIST_ENTRY* le2 = t->itemlist.Flink;
                        tree_data* td = NULL;
                        tree* child_tree = NULL;
 
                        while (le2 != &t->itemlist) {
                            td = CONTAINING_RECORD(le2, tree_data, list_entry);
                            if (!td->ignore)
                                break;
                            le2 = le2->Flink;
                        }
 
                        TRACE("deleting top-level tree in root %I64x with one item\n", t->root->id);
 
                        if (t->has_new_address) { // delete associated EXTENT_ITEM
                            Status = reduce_tree_extent(Vcb, t->new_address, t, t->header.tree_id, t->header.level, Irp, rollback);
 
                            if (!NT_SUCCESS(Status)) {
                                ERR("reduce_tree_extent returned %08lx\n", Status);
                                return Status;
                            }
 
                            t->has_new_address = false;
                        } else if (t->has_address) {
                            Status = reduce_tree_extent(Vcb,t->header.address, t, t->header.tree_id, t->header.level, Irp, rollback);
 
                            if (!NT_SUCCESS(Status)) {
                                ERR("reduce_tree_extent returned %08lx\n", Status);
                                return Status;
                            }
 
                            t->has_address = false;
                        }
 
                        if (!td->treeholder.tree) { // load first item if not already loaded
                            KEY searchkey = {0,0,0};
                            traverse_ptr tp;
 
                            Status = find_item(Vcb, t->root, &tp, &searchkey, false, Irp);
                            if (!NT_SUCCESS(Status)) {
                                ERR("error - find_item returned %08lx\n", Status);
                                return Status;
                            }
                        }
 
                        child_tree = td->treeholder.tree;
 
                        if (child_tree) {
                            child_tree->parent = NULL;
                            child_tree->paritem = NULL;
                        }
 
                        t->root->root_item.bytes_used -= Vcb->superblock.node_size;
 
                        free_tree(t);
 
                        if (child_tree)
                            child_tree->root->treeholder.tree = child_tree;
                    }
                }
 
                le = nextle;
            }
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by do_write2().

do_tree_writes()

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

Definition at line 1620 of file flushthread.c.

                                                                                      {
    chunk* c;
    LIST_ENTRY* le;
    tree_write* tw;
    NTSTATUS Status;
    ULONG i, num_bits;
    write_data_context* wtc;
    ULONG bit_num = 0;
    bool raid56 = false;
 
    // merge together runs
    c = NULL;
    le = tree_writes->Flink;
    while (le != tree_writes) {
        tw = CONTAINING_RECORD(le, tree_write, list_entry);
 
        if (!c || tw->address < c->offset || tw->address >= c->offset + c->chunk_item->size)
            c = get_chunk_from_address(Vcb, tw->address);
        else {
            tree_write* tw2 = CONTAINING_RECORD(le->Blink, tree_write, list_entry);
 
            if (tw->address == tw2->address + tw2->length) {
                uint8_t* data = ExAllocatePoolWithTag(NonPagedPool, tw2->length + tw->length, ALLOC_TAG);
 
                if (!data) {
                    ERR("out of memory\n");
                    return STATUS_INSUFFICIENT_RESOURCES;
                }
 
                RtlCopyMemory(data, tw2->data, tw2->length);
                RtlCopyMemory(&data[tw2->length], tw->data, tw->length);
 
                if (!no_free || tw2->allocated)
                    ExFreePool(tw2->data);
 
                tw2->data = data;
                tw2->length += tw->length;
                tw2->allocated = true;
 
                if (!no_free || tw->allocated)
                    ExFreePool(tw->data);
 
                RemoveEntryList(&tw->list_entry);
                ExFreePool(tw);
 
                le = tw2->list_entry.Flink;
                continue;
            }
        }
 
        tw->c = c;
 
        if (c->chunk_item->type & (BLOCK_FLAG_RAID5 | BLOCK_FLAG_RAID6))
            raid56 = true;
 
        le = le->Flink;
    }
 
    num_bits = 0;
 
    le = tree_writes->Flink;
    while (le != tree_writes) {
        tw = CONTAINING_RECORD(le, tree_write, list_entry);
 
        num_bits++;
 
        le = le->Flink;
    }
 
    wtc = ExAllocatePoolWithTag(NonPagedPool, sizeof(write_data_context) * num_bits, ALLOC_TAG);
    if (!wtc) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    le = tree_writes->Flink;
 
    while (le != tree_writes) {
        tw = CONTAINING_RECORD(le, tree_write, list_entry);
 
        TRACE("address: %I64x, size: %x\n", tw->address, tw->length);
 
        KeInitializeEvent(&wtc[bit_num].Event, NotificationEvent, false);
        InitializeListHead(&wtc[bit_num].stripes);
        wtc[bit_num].need_wait = false;
        wtc[bit_num].stripes_left = 0;
        wtc[bit_num].parity1 = wtc[bit_num].parity2 = wtc[bit_num].scratch = NULL;
        wtc[bit_num].mdl = wtc[bit_num].parity1_mdl = wtc[bit_num].parity2_mdl = NULL;
 
        Status = write_data(Vcb, tw->address, tw->data, tw->length, &wtc[bit_num], NULL, NULL, false, 0, HighPagePriority);
        if (!NT_SUCCESS(Status)) {
            ERR("write_data returned %08lx\n", Status);
 
            for (i = 0; i < num_bits; i++) {
                free_write_data_stripes(&wtc[i]);
            }
            ExFreePool(wtc);
 
            return Status;
        }
 
        bit_num++;
 
        le = le->Flink;
    }
 
    for (i = 0; i < num_bits; i++) {
        if (wtc[i].stripes.Flink != &wtc[i].stripes) {
            // launch writes and wait
            le = wtc[i].stripes.Flink;
            while (le != &wtc[i].stripes) {
                write_data_stripe* stripe = CONTAINING_RECORD(le, write_data_stripe, list_entry);
 
                if (stripe->status != WriteDataStatus_Ignore) {
                    wtc[i].need_wait = true;
                    IoCallDriver(stripe->device->devobj, stripe->Irp);
                }
 
                le = le->Flink;
            }
        }
    }
 
    for (i = 0; i < num_bits; i++) {
        if (wtc[i].need_wait)
            KeWaitForSingleObject(&wtc[i].Event, Executive, KernelMode, false, NULL);
    }
 
    for (i = 0; i < num_bits; i++) {
        le = wtc[i].stripes.Flink;
        while (le != &wtc[i].stripes) {
            write_data_stripe* stripe = CONTAINING_RECORD(le, write_data_stripe, list_entry);
 
            if (stripe->status != WriteDataStatus_Ignore && !NT_SUCCESS(stripe->iosb.Status)) {
                Status = stripe->iosb.Status;
                log_device_error(Vcb, stripe->device, BTRFS_DEV_STAT_WRITE_ERRORS);
                break;
            }
 
            le = le->Flink;
        }
 
        free_write_data_stripes(&wtc[i]);
    }
 
    ExFreePool(wtc);
 
    if (raid56) {
        c = NULL;
 
        le = tree_writes->Flink;
        while (le != tree_writes) {
            tw = CONTAINING_RECORD(le, tree_write, list_entry);
 
            if (tw->c != c) {
                c = tw->c;
 
                ExAcquireResourceExclusiveLite(&c->partial_stripes_lock, true);
 
                while (!IsListEmpty(&c->partial_stripes)) {
                    partial_stripe* ps = CONTAINING_RECORD(RemoveHeadList(&c->partial_stripes), partial_stripe, list_entry);
 
                    Status = flush_partial_stripe(Vcb, c, ps);
 
                    if (ps->bmparr)
                        ExFreePool(ps->bmparr);
 
                    ExFreePool(ps);
 
                    if (!NT_SUCCESS(Status)) {
                        ERR("flush_partial_stripe returned %08lx\n", Status);
                        ExReleaseResourceLite(&c->partial_stripes_lock);
                        return Status;
                    }
                }
 
                ExReleaseResourceLite(&c->partial_stripes_lock);
            }
 
            le = le->Flink;
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by write_metadata_items(), and write_trees().

do_write()

NTSTATUS do_write	(	device_extension *	Vcb,
		PIRP	Irp
	)

Definition at line 7877 of file flushthread.c.

                                                   {
    LIST_ENTRY rollback;
    NTSTATUS Status;
 
    InitializeListHead(&rollback);
 
    Status = do_write2(Vcb, Irp, &rollback);
 
    if (!NT_SUCCESS(Status)) {
        ERR("do_write2 returned %08lx, dropping into readonly mode\n", Status);
        Vcb->readonly = true;
        FsRtlNotifyVolumeEvent(Vcb->root_file, FSRTL_VOLUME_FORCED_CLOSED);
        do_rollback(Vcb, &rollback);
    } else
        clear_rollback(&rollback);
 
    return Status;
}

Referenced by _Dispatch_type_(), _Function_class_(), add_balance_item(), add_device(), balance_data_chunk(), balance_metadata_chunk(), dismount_volume(), do_create_snapshot(), do_flush(), finish_removing_device(), invalidate_volumes(), lock_volume(), pnp_query_remove_device(), remove_balance_item(), and try_consolidation().

do_write2()

static NTSTATUS do_write2 ( device_extension *  Vcb, PIRP  Irp, LIST_ENTRY *  rollback  )

static

Definition at line 7477 of file flushthread.c.

                                                                                 {
    NTSTATUS Status;
    LIST_ENTRY *le, batchlist;
    bool cache_changed = false;
    volume_device_extension* vde;
    bool no_cache = false;
#ifdef DEBUG_FLUSH_TIMES
    uint64_t filerefs = 0, fcbs = 0;
    LARGE_INTEGER freq, time1, time2;
#endif
#ifdef DEBUG_WRITE_LOOPS
    UINT loops = 0;
#endif
 
    TRACE("(%p)\n", Vcb);
 
    InitializeListHead(&batchlist);
 
#ifdef DEBUG_FLUSH_TIMES
    time1 = KeQueryPerformanceCounter(&freq);
#endif
 
    Status = check_for_orphans(Vcb, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("check_for_orphans returned %08lx\n", Status);
        return Status;
    }
 
    ExAcquireResourceExclusiveLite(&Vcb->dirty_filerefs_lock, true);
 
    while (!IsListEmpty(&Vcb->dirty_filerefs)) {
        file_ref* fr = CONTAINING_RECORD(RemoveHeadList(&Vcb->dirty_filerefs), file_ref, list_entry_dirty);
 
        flush_fileref(fr, &batchlist, Irp);
        free_fileref(fr);
 
#ifdef DEBUG_FLUSH_TIMES
        filerefs++;
#endif
    }
 
    ExReleaseResourceLite(&Vcb->dirty_filerefs_lock);
 
    Status = commit_batch_list(Vcb, &batchlist, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("commit_batch_list returned %08lx\n", Status);
        return Status;
    }
 
#ifdef DEBUG_FLUSH_TIMES
    time2 = KeQueryPerformanceCounter(NULL);
 
    ERR("flushed %I64u filerefs in %I64u (freq = %I64u)\n", filerefs, time2.QuadPart - time1.QuadPart, freq.QuadPart);
 
    time1 = KeQueryPerformanceCounter(&freq);
#endif
 
    // We process deleted streams first, so we don't run over our xattr
    // limit unless we absolutely have to.
    // We also process deleted normal files, to avoid any problems
    // caused by inode collisions.
 
    ExAcquireResourceExclusiveLite(&Vcb->dirty_fcbs_lock, true);
 
    le = Vcb->dirty_fcbs.Flink;
    while (le != &Vcb->dirty_fcbs) {
        fcb* fcb = CONTAINING_RECORD(le, struct _fcb, list_entry_dirty);
        LIST_ENTRY* le2 = le->Flink;
 
        if (fcb->deleted) {
            ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
            Status = flush_fcb(fcb, false, &batchlist, Irp);
            ExReleaseResourceLite(fcb->Header.Resource);
 
            free_fcb(fcb);
 
            if (!NT_SUCCESS(Status)) {
                ERR("flush_fcb returned %08lx\n", Status);
                clear_batch_list(Vcb, &batchlist);
                ExReleaseResourceLite(&Vcb->dirty_fcbs_lock);
                return Status;
            }
 
#ifdef DEBUG_FLUSH_TIMES
            fcbs++;
#endif
        }
 
        le = le2;
    }
 
    Status = commit_batch_list(Vcb, &batchlist, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("commit_batch_list returned %08lx\n", Status);
        ExReleaseResourceLite(&Vcb->dirty_fcbs_lock);
        return Status;
    }
 
    le = Vcb->dirty_fcbs.Flink;
    while (le != &Vcb->dirty_fcbs) {
        fcb* fcb = CONTAINING_RECORD(le, struct _fcb, list_entry_dirty);
        LIST_ENTRY* le2 = le->Flink;
 
        if (fcb->subvol != Vcb->root_root) {
            ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
            Status = flush_fcb(fcb, false, &batchlist, Irp);
            ExReleaseResourceLite(fcb->Header.Resource);
            free_fcb(fcb);
 
            if (!NT_SUCCESS(Status)) {
                ERR("flush_fcb returned %08lx\n", Status);
                ExReleaseResourceLite(&Vcb->dirty_fcbs_lock);
                return Status;
            }
 
#ifdef DEBUG_FLUSH_TIMES
            fcbs++;
#endif
        }
 
        le = le2;
    }
 
    ExReleaseResourceLite(&Vcb->dirty_fcbs_lock);
 
    Status = commit_batch_list(Vcb, &batchlist, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("commit_batch_list returned %08lx\n", Status);
        return Status;
    }
 
#ifdef DEBUG_FLUSH_TIMES
    time2 = KeQueryPerformanceCounter(NULL);
 
    ERR("flushed %I64u fcbs in %I64u (freq = %I64u)\n", filerefs, time2.QuadPart - time1.QuadPart, freq.QuadPart);
#endif
 
    // no need to get dirty_subvols_lock here, as we have tree_lock exclusively
    while (!IsListEmpty(&Vcb->dirty_subvols)) {
        root* r = CONTAINING_RECORD(RemoveHeadList(&Vcb->dirty_subvols), root, list_entry_dirty);
 
        Status = flush_subvol(Vcb, r, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("flush_subvol returned %08lx\n", Status);
            return Status;
        }
    }
 
    if (!IsListEmpty(&Vcb->drop_roots)) {
        Status = drop_roots(Vcb, Irp, rollback);
 
        if (!NT_SUCCESS(Status)) {
            ERR("drop_roots returned %08lx\n", Status);
            return Status;
        }
    }
 
    Status = update_chunks(Vcb, &batchlist, Irp, rollback);
 
    if (!NT_SUCCESS(Status)) {
        ERR("update_chunks returned %08lx\n", Status);
        return Status;
    }
 
    Status = commit_batch_list(Vcb, &batchlist, Irp);
 
    // If only changing superblock, e.g. changing label, we still need to rewrite
    // the root tree so the generations match, otherwise you won't be able to mount on Linux.
    if (!Vcb->root_root->treeholder.tree || !Vcb->root_root->treeholder.tree->write) {
        KEY searchkey;
 
        traverse_ptr tp;
 
        searchkey.obj_id = 0;
        searchkey.obj_type = 0;
        searchkey.offset = 0;
 
        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("error - find_item returned %08lx\n", Status);
            return Status;
        }
 
        Vcb->root_root->treeholder.tree->write = true;
    }
 
    // make sure we always update the extent tree
    Status = add_root_item_to_cache(Vcb, BTRFS_ROOT_EXTENT, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("add_root_item_to_cache returned %08lx\n", Status);
        return Status;
    }
 
    if (Vcb->stats_changed) {
        le = Vcb->devices.Flink;
        while (le != &Vcb->devices) {
            device* dev = CONTAINING_RECORD(le, device, list_entry);
 
            if (dev->stats_changed) {
                Status = flush_changed_dev_stats(Vcb, dev, Irp);
                if (!NT_SUCCESS(Status)) {
                    ERR("flush_changed_dev_stats returned %08lx\n", Status);
                    return Status;
                }
                dev->stats_changed = false;
            }
 
            le = le->Flink;
        }
 
        Vcb->stats_changed = false;
    }
 
    do {
        Status = add_parents(Vcb, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("add_parents returned %08lx\n", Status);
            goto end;
        }
 
        Status = allocate_tree_extents(Vcb, Irp, rollback);
        if (!NT_SUCCESS(Status)) {
            ERR("allocate_tree_extents returned %08lx\n", Status);
            goto end;
        }
 
        Status = do_splits(Vcb, Irp, rollback);
        if (!NT_SUCCESS(Status)) {
            ERR("do_splits returned %08lx\n", Status);
            goto end;
        }
 
        Status = update_chunk_usage(Vcb, Irp, rollback);
        if (!NT_SUCCESS(Status)) {
            ERR("update_chunk_usage returned %08lx\n", Status);
            goto end;
        }
 
        if (!(Vcb->superblock.compat_ro_flags & BTRFS_COMPAT_RO_FLAGS_FREE_SPACE_CACHE)) {
            if (!no_cache) {
                Status = allocate_cache(Vcb, &cache_changed, Irp, rollback);
                if (!NT_SUCCESS(Status)) {
                    WARN("allocate_cache returned %08lx\n", Status);
                    no_cache = true;
                    cache_changed = false;
                }
            }
        } else {
            Status = update_chunk_caches_tree(Vcb, Irp);
            if (!NT_SUCCESS(Status)) {
                ERR("update_chunk_caches_tree returned %08lx\n", Status);
                goto end;
            }
        }
 
#ifdef DEBUG_WRITE_LOOPS
        loops++;
 
        if (cache_changed)
            ERR("cache has changed, looping again\n");
#endif
    } while (cache_changed || !trees_consistent(Vcb));
 
#ifdef DEBUG_WRITE_LOOPS
    ERR("%u loops\n", loops);
#endif
 
    TRACE("trees consistent\n");
 
    Status = update_root_root(Vcb, no_cache, Irp, rollback);
    if (!NT_SUCCESS(Status)) {
        ERR("update_root_root returned %08lx\n", Status);
        goto end;
    }
 
    Status = write_trees(Vcb, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("write_trees returned %08lx\n", Status);
        goto end;
    }
 
    Status = test_not_full(Vcb);
    if (!NT_SUCCESS(Status)) {
        ERR("test_not_full returned %08lx\n", Status);
        goto end;
    }
 
#ifdef DEBUG_PARANOID
    le = Vcb->trees.Flink;
    while (le != &Vcb->trees) {
        tree* t = CONTAINING_RECORD(le, tree, list_entry);
        KEY searchkey;
        traverse_ptr tp;
 
        searchkey.obj_id = t->header.address;
        searchkey.obj_type = TYPE_METADATA_ITEM;
        searchkey.offset = 0xffffffffffffffff;
 
        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("error - find_item returned %08lx\n", Status);
            goto end;
        }
 
        if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
            searchkey.obj_id = t->header.address;
            searchkey.obj_type = TYPE_EXTENT_ITEM;
            searchkey.offset = 0xffffffffffffffff;
 
            Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
            if (!NT_SUCCESS(Status)) {
                ERR("error - find_item returned %08lx\n", Status);
                goto end;
            }
 
            if (tp.item->key.obj_id != searchkey.obj_id || tp.item->key.obj_type != searchkey.obj_type) {
                ERR("error - could not find entry in extent tree for tree at %I64x\n", t->header.address);
                Status = STATUS_INTERNAL_ERROR;
                goto end;
            }
        }
 
        le = le->Flink;
    }
#endif
 
    Vcb->superblock.cache_generation = Vcb->superblock.generation;
 
    if (!Vcb->options.no_barrier)
        flush_disk_caches(Vcb);
 
    Status = write_superblocks(Vcb, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("write_superblocks returned %08lx\n", Status);
        goto end;
    }
 
    vde = Vcb->vde;
 
    if (vde) {
        pdo_device_extension* pdode = vde->pdode;
 
        ExAcquireResourceSharedLite(&pdode->child_lock, true);
 
        le = pdode->children.Flink;
 
        while (le != &pdode->children) {
            volume_child* vc = CONTAINING_RECORD(le, volume_child, list_entry);
 
            vc->generation = Vcb->superblock.generation;
            le = le->Flink;
        }
 
        ExReleaseResourceLite(&pdode->child_lock);
    }
 
    clean_space_cache(Vcb);
 
    le = Vcb->chunks.Flink;
    while (le != &Vcb->chunks) {
        chunk* c = CONTAINING_RECORD(le, chunk, list_entry);
 
        c->changed = false;
        c->space_changed = false;
 
        le = le->Flink;
    }
 
    Vcb->superblock.generation++;
 
    Status = STATUS_SUCCESS;
 
    le = Vcb->trees.Flink;
    while (le != &Vcb->trees) {
        tree* t = CONTAINING_RECORD(le, tree, list_entry);
 
        t->write = false;
 
        le = le->Flink;
    }
 
    Vcb->need_write = false;
 
    while (!IsListEmpty(&Vcb->drop_roots)) {
        root* r = CONTAINING_RECORD(RemoveHeadList(&Vcb->drop_roots), root, list_entry);
 
        if (IsListEmpty(&r->fcbs)) {
            ExDeleteResourceLite(&r->nonpaged->load_tree_lock);
            ExFreePool(r->nonpaged);
            ExFreePool(r);
        } else
            r->dropped = true;
    }
 
end:
    TRACE("do_write returning %08lx\n", Status);
 
    return Status;
}

Referenced by do_write().

drop_chunk()

static NTSTATUS drop_chunk ( device_extension *  Vcb, chunk *  c, LIST_ENTRY *  batchlist, PIRP  Irp, LIST_ENTRY *  rollback  )

static

Definition at line 5531 of file flushthread.c.

                                                                                                                   {
    NTSTATUS Status;
    KEY searchkey;
    traverse_ptr tp;
    uint64_t i, factor;
    CHUNK_ITEM_STRIPE* cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];;
 
    TRACE("dropping chunk %I64x\n", c->offset);
 
    if (c->chunk_item->type & BLOCK_FLAG_RAID0)
        factor = c->chunk_item->num_stripes;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID10)
        factor = c->chunk_item->num_stripes / c->chunk_item->sub_stripes;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID5)
        factor = c->chunk_item->num_stripes - 1;
    else if (c->chunk_item->type & BLOCK_FLAG_RAID6)
        factor = c->chunk_item->num_stripes - 2;
    else // SINGLE, DUPLICATE, RAID1, RAID1C3, RAID1C4
        factor = 1;
 
    // do TRIM
    if (Vcb->trim && !Vcb->options.no_trim) {
        uint64_t len = c->chunk_item->size / factor;
 
        for (i = 0; i < c->chunk_item->num_stripes; i++) {
            if (c->devices[i] && c->devices[i]->devobj && !c->devices[i]->readonly && c->devices[i]->trim)
                add_trim_entry_avoid_sb(Vcb, c->devices[i], cis[i].offset, len);
        }
    }
 
    if (!c->cache) {
        Status = load_stored_free_space_cache(Vcb, c, true, Irp);
 
        if (!NT_SUCCESS(Status) && Status != STATUS_NOT_FOUND)
            WARN("load_stored_free_space_cache returned %08lx\n", Status);
    }
 
    // remove free space cache
    if (c->cache) {
        c->cache->deleted = true;
 
        Status = excise_extents(Vcb, c->cache, 0, c->cache->inode_item.st_size, Irp, rollback);
        if (!NT_SUCCESS(Status)) {
            ERR("excise_extents returned %08lx\n", Status);
            return Status;
        }
 
        Status = flush_fcb(c->cache, true, batchlist, Irp);
 
        free_fcb(c->cache);
 
        if (c->cache->refcount == 0)
            reap_fcb(c->cache);
 
        if (!NT_SUCCESS(Status)) {
            ERR("flush_fcb returned %08lx\n", Status);
            return Status;
        }
 
        searchkey.obj_id = FREE_SPACE_CACHE_ID;
        searchkey.obj_type = 0;
        searchkey.offset = c->offset;
 
        Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("error - find_item returned %08lx\n", Status);
            return Status;
        }
 
        if (!keycmp(tp.item->key, searchkey)) {
            Status = delete_tree_item(Vcb, &tp);
            if (!NT_SUCCESS(Status)) {
                ERR("delete_tree_item returned %08lx\n", Status);
                return Status;
            }
        }
    }
 
    if (Vcb->space_root) {
        Status = insert_tree_item_batch(batchlist, Vcb, Vcb->space_root, c->offset, TYPE_FREE_SPACE_INFO, c->chunk_item->size,
                                        NULL, 0, Batch_DeleteFreeSpace);
        if (!NT_SUCCESS(Status)) {
            ERR("insert_tree_item_batch returned %08lx\n", Status);
            return Status;
        }
    }
 
    for (i = 0; i < c->chunk_item->num_stripes; i++) {
        if (!c->created) {
            // remove DEV_EXTENTs from tree 4
            searchkey.obj_id = cis[i].dev_id;
            searchkey.obj_type = TYPE_DEV_EXTENT;
            searchkey.offset = cis[i].offset;
 
            Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, false, Irp);
            if (!NT_SUCCESS(Status)) {
                ERR("error - find_item returned %08lx\n", Status);
                return Status;
            }
 
            if (!keycmp(tp.item->key, searchkey)) {
                Status = delete_tree_item(Vcb, &tp);
                if (!NT_SUCCESS(Status)) {
                    ERR("delete_tree_item returned %08lx\n", Status);
                    return Status;
                }
 
                if (tp.item->size >= sizeof(DEV_EXTENT)) {
                    DEV_EXTENT* de = (DEV_EXTENT*)tp.item->data;
 
                    c->devices[i]->devitem.bytes_used -= de->length;
 
                    if (Vcb->balance.thread && Vcb->balance.shrinking && Vcb->balance.opts[0].devid == c->devices[i]->devitem.dev_id) {
                        if (cis[i].offset < Vcb->balance.opts[0].drange_start && cis[i].offset + de->length > Vcb->balance.opts[0].drange_start)
                            space_list_add2(&c->devices[i]->space, NULL, cis[i].offset, Vcb->balance.opts[0].drange_start - cis[i].offset, NULL, rollback);
                    } else
                        space_list_add2(&c->devices[i]->space, NULL, cis[i].offset, de->length, NULL, rollback);
                }
            } else
                WARN("could not find (%I64x,%x,%I64x) in dev tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
        } else {
            uint64_t len = c->chunk_item->size / factor;
 
            c->devices[i]->devitem.bytes_used -= len;
 
            if (Vcb->balance.thread && Vcb->balance.shrinking && Vcb->balance.opts[0].devid == c->devices[i]->devitem.dev_id) {
                if (cis[i].offset < Vcb->balance.opts[0].drange_start && cis[i].offset + len > Vcb->balance.opts[0].drange_start)
                    space_list_add2(&c->devices[i]->space, NULL, cis[i].offset, Vcb->balance.opts[0].drange_start - cis[i].offset, NULL, rollback);
            } else
                space_list_add2(&c->devices[i]->space, NULL, cis[i].offset, len, NULL, rollback);
        }
    }
 
    // modify DEV_ITEMs in chunk tree
    for (i = 0; i < c->chunk_item->num_stripes; i++) {
        if (c->devices[i]) {
            uint64_t j;
            DEV_ITEM* di;
 
            searchkey.obj_id = 1;
            searchkey.obj_type = TYPE_DEV_ITEM;
            searchkey.offset = c->devices[i]->devitem.dev_id;
 
            Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, false, Irp);
            if (!NT_SUCCESS(Status)) {
                ERR("error - find_item returned %08lx\n", Status);
                return Status;
            }
 
            if (!keycmp(tp.item->key, searchkey)) {
                Status = delete_tree_item(Vcb, &tp);
                if (!NT_SUCCESS(Status)) {
                    ERR("delete_tree_item returned %08lx\n", Status);
                    return Status;
                }
 
                di = ExAllocatePoolWithTag(PagedPool, sizeof(DEV_ITEM), ALLOC_TAG);
                if (!di) {
                    ERR("out of memory\n");
                    return STATUS_INSUFFICIENT_RESOURCES;
                }
 
                RtlCopyMemory(di, &c->devices[i]->devitem, sizeof(DEV_ITEM));
 
                Status = insert_tree_item(Vcb, Vcb->chunk_root, 1, TYPE_DEV_ITEM, c->devices[i]->devitem.dev_id, di, sizeof(DEV_ITEM), NULL, Irp);
                if (!NT_SUCCESS(Status)) {
                    ERR("insert_tree_item returned %08lx\n", Status);
                    return Status;
                }
            }
 
            for (j = i + 1; j < c->chunk_item->num_stripes; j++) {
                if (c->devices[j] == c->devices[i])
                    c->devices[j] = NULL;
            }
        }
    }
 
    if (!c->created) {
        // remove CHUNK_ITEM from chunk tree
        searchkey.obj_id = 0x100;
        searchkey.obj_type = TYPE_CHUNK_ITEM;
        searchkey.offset = c->offset;
 
        Status = find_item(Vcb, Vcb->chunk_root, &tp, &searchkey, false, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("error - find_item returned %08lx\n", Status);
            return Status;
        }
 
        if (!keycmp(tp.item->key, searchkey)) {
            Status = delete_tree_item(Vcb, &tp);
 
            if (!NT_SUCCESS(Status)) {
                ERR("delete_tree_item returned %08lx\n", Status);
                return Status;
            }
        } else
            WARN("could not find CHUNK_ITEM for chunk %I64x\n", c->offset);
 
        // remove BLOCK_GROUP_ITEM from extent tree
        searchkey.obj_id = c->offset;
        searchkey.obj_type = TYPE_BLOCK_GROUP_ITEM;
        searchkey.offset = 0xffffffffffffffff;
 
        Status = find_item(Vcb, Vcb->extent_root, &tp, &searchkey, false, Irp);
        if (!NT_SUCCESS(Status)) {
            ERR("error - find_item returned %08lx\n", Status);
            return Status;
        }
 
        if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type) {
            Status = delete_tree_item(Vcb, &tp);
 
            if (!NT_SUCCESS(Status)) {
                ERR("delete_tree_item returned %08lx\n", Status);
                return Status;
            }
        } else
            WARN("could not find BLOCK_GROUP_ITEM for chunk %I64x\n", c->offset);
    }
 
    if (c->chunk_item->type & BLOCK_FLAG_SYSTEM)
        remove_from_bootstrap(Vcb, 0x100, TYPE_CHUNK_ITEM, c->offset);
 
    RemoveEntryList(&c->list_entry);
 
    // clear raid56 incompat flag if dropping last RAID5/6 chunk
 
    if (c->chunk_item->type & BLOCK_FLAG_RAID5 || c->chunk_item->type & BLOCK_FLAG_RAID6) {
        LIST_ENTRY* le;
        bool clear_flag = true;
 
        le = Vcb->chunks.Flink;
        while (le != &Vcb->chunks) {
            chunk* c2 = CONTAINING_RECORD(le, chunk, list_entry);
 
            if (c2->chunk_item->type & BLOCK_FLAG_RAID5 || c2->chunk_item->type & BLOCK_FLAG_RAID6) {
                clear_flag = false;
                break;
            }
 
            le = le->Flink;
        }
 
        if (clear_flag)
            Vcb->superblock.incompat_flags &= ~BTRFS_INCOMPAT_FLAGS_RAID56;
    }
 
    // clear raid1c34 incompat flag if dropping last RAID5/6 chunk
 
    if (c->chunk_item->type & BLOCK_FLAG_RAID1C3 || c->chunk_item->type & BLOCK_FLAG_RAID1C4) {
        LIST_ENTRY* le;
        bool clear_flag = true;
 
        le = Vcb->chunks.Flink;
        while (le != &Vcb->chunks) {
            chunk* c2 = CONTAINING_RECORD(le, chunk, list_entry);
 
            if (c2->chunk_item->type & BLOCK_FLAG_RAID1C3 || c2->chunk_item->type & BLOCK_FLAG_RAID1C4) {
                clear_flag = false;
                break;
            }
 
            le = le->Flink;
        }
 
        if (clear_flag)
            Vcb->superblock.incompat_flags &= ~BTRFS_INCOMPAT_FLAGS_RAID1C34;
    }
 
    Vcb->superblock.bytes_used -= c->oldused;
 
    ExFreePool(c->chunk_item);
    ExFreePool(c->devices);
 
    while (!IsListEmpty(&c->space)) {
        space* s = CONTAINING_RECORD(c->space.Flink, space, list_entry);
 
        RemoveEntryList(&s->list_entry);
        ExFreePool(s);
    }
 
    while (!IsListEmpty(&c->deleting)) {
        space* s = CONTAINING_RECORD(c->deleting.Flink, space, list_entry);
 
        RemoveEntryList(&s->list_entry);
        ExFreePool(s);
    }
 
    release_chunk_lock(c, Vcb);
 
    ExDeleteResourceLite(&c->partial_stripes_lock);
    ExDeleteResourceLite(&c->range_locks_lock);
    ExDeleteResourceLite(&c->lock);
    ExDeleteResourceLite(&c->changed_extents_lock);
 
    ExFreePool(c);
 
    return STATUS_SUCCESS;
}

Referenced by update_chunks().

drop_root()

static NTSTATUS drop_root ( device_extension *  Vcb, root *  r, PIRP  Irp, LIST_ENTRY *  rollback  )

static

Definition at line 3945 of file flushthread.c.

                                                                                          {
    NTSTATUS Status;
    KEY searchkey;
    traverse_ptr tp;
 
    Status = remove_root_extents(Vcb, r, &r->treeholder, r->root_item.root_level, NULL, Irp, rollback);
    if (!NT_SUCCESS(Status)) {
        ERR("remove_root_extents returned %08lx\n", Status);
        return Status;
    }
 
    // remove entries in uuid root (tree 9)
    if (Vcb->uuid_root) {
        RtlCopyMemory(&searchkey.obj_id, &r->root_item.uuid.uuid[0], sizeof(uint64_t));
        searchkey.obj_type = TYPE_SUBVOL_UUID;
        RtlCopyMemory(&searchkey.offset, &r->root_item.uuid.uuid[sizeof(uint64_t)], sizeof(uint64_t));
 
        if (searchkey.obj_id != 0 || searchkey.offset != 0) {
            Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, false, Irp);
            if (!NT_SUCCESS(Status)) {
                WARN("find_item returned %08lx\n", Status);
            } else {
                if (!keycmp(tp.item->key, searchkey)) {
                    Status = delete_tree_item(Vcb, &tp);
                    if (!NT_SUCCESS(Status)) {
                        ERR("delete_tree_item returned %08lx\n", Status);
                        return Status;
                    }
                } else
                    WARN("could not find (%I64x,%x,%I64x) in uuid tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
            }
        }
 
        if (r->root_item.rtransid > 0) {
            RtlCopyMemory(&searchkey.obj_id, &r->root_item.received_uuid.uuid[0], sizeof(uint64_t));
            searchkey.obj_type = TYPE_SUBVOL_REC_UUID;
            RtlCopyMemory(&searchkey.offset, &r->root_item.received_uuid.uuid[sizeof(uint64_t)], sizeof(uint64_t));
 
            Status = find_item(Vcb, Vcb->uuid_root, &tp, &searchkey, false, Irp);
            if (!NT_SUCCESS(Status))
                WARN("find_item returned %08lx\n", Status);
            else {
                if (!keycmp(tp.item->key, searchkey)) {
                    if (tp.item->size == sizeof(uint64_t)) {
                        uint64_t* id = (uint64_t*)tp.item->data;
 
                        if (*id == r->id) {
                            Status = delete_tree_item(Vcb, &tp);
                            if (!NT_SUCCESS(Status)) {
                                ERR("delete_tree_item returned %08lx\n", Status);
                                return Status;
                            }
                        }
                    } else if (tp.item->size > sizeof(uint64_t)) {
                        ULONG i;
                        uint64_t* ids = (uint64_t*)tp.item->data;
 
                        for (i = 0; i < tp.item->size / sizeof(uint64_t); i++) {
                            if (ids[i] == r->id) {
                                uint64_t* ne;
 
                                ne = ExAllocatePoolWithTag(PagedPool, tp.item->size - sizeof(uint64_t), ALLOC_TAG);
                                if (!ne) {
                                    ERR("out of memory\n");
                                    return STATUS_INSUFFICIENT_RESOURCES;
                                }
 
                                if (i > 0)
                                    RtlCopyMemory(ne, ids, sizeof(uint64_t) * i);
 
                                if ((i + 1) * sizeof(uint64_t) < tp.item->size)
                                    RtlCopyMemory(&ne[i], &ids[i + 1], tp.item->size - ((i + 1) * sizeof(uint64_t)));
 
                                Status = delete_tree_item(Vcb, &tp);
                                if (!NT_SUCCESS(Status)) {
                                    ERR("delete_tree_item returned %08lx\n", Status);
                                    ExFreePool(ne);
                                    return Status;
                                }
 
                                Status = insert_tree_item(Vcb, Vcb->uuid_root, tp.item->key.obj_id, tp.item->key.obj_type, tp.item->key.offset,
                                                          ne, tp.item->size - sizeof(uint64_t), NULL, Irp);
                                if (!NT_SUCCESS(Status)) {
                                    ERR("insert_tree_item returned %08lx\n", Status);
                                    ExFreePool(ne);
                                    return Status;
                                }
 
                                break;
                            }
                        }
                    }
                } else
                    WARN("could not find (%I64x,%x,%I64x) in uuid tree\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
            }
        }
    }
 
    // delete ROOT_ITEM
 
    searchkey.obj_id = r->id;
    searchkey.obj_type = TYPE_ROOT_ITEM;
    searchkey.offset = 0xffffffffffffffff;
 
    Status = find_item(Vcb, Vcb->root_root, &tp, &searchkey, false, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("find_item returned %08lx\n", Status);
        return Status;
    }
 
    if (tp.item->key.obj_id == searchkey.obj_id && tp.item->key.obj_type == searchkey.obj_type) {
        Status = delete_tree_item(Vcb, &tp);
 
        if (!NT_SUCCESS(Status)) {
            ERR("delete_tree_item returned %08lx\n", Status);
            return Status;
        }
    } else
        WARN("could not find (%I64x,%x,%I64x) in root_root\n", searchkey.obj_id, searchkey.obj_type, searchkey.offset);
 
    // delete items in tree cache
 
    free_trees_root(Vcb, r);
 
    return STATUS_SUCCESS;
}

Referenced by drop_roots().

drop_roots()

static NTSTATUS drop_roots ( device_extension *  Vcb, PIRP  Irp, LIST_ENTRY *  rollback  )

static

Definition at line 4072 of file flushthread.c.

                                                                                  {
    LIST_ENTRY *le = Vcb->drop_roots.Flink, *le2;
    NTSTATUS Status;
 
    while (le != &Vcb->drop_roots) {
        root* r = CONTAINING_RECORD(le, root, list_entry);
 
        le2 = le->Flink;
 
        Status = drop_root(Vcb, r, Irp, rollback);
        if (!NT_SUCCESS(Status)) {
            ERR("drop_root(%I64x) returned %08lx\n", r->id, Status);
            return Status;
        }
 
        le = le2;
    }
 
    return STATUS_SUCCESS;
}

Referenced by do_write2().

find_metadata_address_in_chunk()

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

Definition at line 744 of file flushthread.c.

                                                                                        {
    LIST_ENTRY* le;
    space* s;
 
    TRACE("(%p, %I64x, %p)\n", Vcb, c->offset, address);
 
    if (Vcb->superblock.node_size > c->chunk_item->size - c->used)
        return false;
 
    if (!c->cache_loaded) {
        NTSTATUS Status = load_cache_chunk(Vcb, c, NULL);
 
        if (!NT_SUCCESS(Status)) {
            ERR("load_cache_chunk returned %08lx\n", Status);
            return false;
        }
    }
 
    if (IsListEmpty(&c->space_size))
        return false;
 
    if (!c->last_alloc_set) {
        s = CONTAINING_RECORD(c->space.Blink, space, list_entry);
 
        c->last_alloc = s->address;
        c->last_alloc_set = true;
 
        if (s->size >= Vcb->superblock.node_size) {
            *address = s->address;
            c->last_alloc += Vcb->superblock.node_size;
            return true;
        }
    }
 
    le = c->space.Flink;
    while (le != &c->space) {
        s = CONTAINING_RECORD(le, space, list_entry);
 
        if (s->address <= c->last_alloc && s->address + s->size >= c->last_alloc + Vcb->superblock.node_size) {
            *address = c->last_alloc;
            c->last_alloc += Vcb->superblock.node_size;
            return true;
        }
 
        le = le->Flink;
    }
 
    le = c->space_size.Flink;
    while (le != &c->space_size) {
        s = CONTAINING_RECORD(le, space, list_entry_size);
 
        if (s->size == Vcb->superblock.node_size) {
            *address = s->address;
            c->last_alloc = s->address + Vcb->superblock.node_size;
            return true;
        } else if (s->size < Vcb->superblock.node_size) {
            if (le == c->space_size.Flink)
                return false;
 
            s = CONTAINING_RECORD(le->Blink, space, list_entry_size);
 
            *address = s->address;
            c->last_alloc = s->address + Vcb->superblock.node_size;
 
            return true;
        }
 
        le = le->Flink;
    }
 
    s = CONTAINING_RECORD(c->space_size.Blink, space, list_entry_size);
 
    if (s->size > Vcb->superblock.node_size) {
        *address = s->address;
        c->last_alloc = s->address + Vcb->superblock.node_size;
        return true;
    }
 
    return false;
}

Referenced by insert_tree_extent(), and write_metadata_items().

flush_changed_dev_stats()

static NTSTATUS flush_changed_dev_stats ( device_extension *  Vcb, device *  dev, PIRP  Irp  )

static

Definition at line 7000 of file flushthread.c.

                                                                                      {
    NTSTATUS Status;
    KEY searchkey;
    traverse_ptr tp;
    uint16_t statslen;
    uint64_t* stats;
 
    searchkey.obj_id = 0;
    searchkey.obj_type = TYPE_DEV_STATS;
    searchkey.offset = dev->devitem.dev_id;
 
    Status = find_item(Vcb, Vcb->dev_root, &tp, &searchkey, false, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("find_item returned %08lx\n", Status);
        return Status;
    }
 
    if (!keycmp(tp.item->key, searchkey)) {
        Status = delete_tree_item(Vcb, &tp);
        if (!NT_SUCCESS(Status)) {
            ERR("delete_tree_item returned %08lx\n", Status);
            return Status;
        }
    }
 
    statslen = sizeof(uint64_t) * 5;
    stats = ExAllocatePoolWithTag(PagedPool, statslen, ALLOC_TAG);
    if (!stats) {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlCopyMemory(stats, dev->stats, statslen);
 
    Status = insert_tree_item(Vcb, Vcb->dev_root, 0, TYPE_DEV_STATS, dev->devitem.dev_id, stats, statslen, NULL, Irp);
    if (!NT_SUCCESS(Status)) {
        ERR("insert_tree_item returned %08lx\n", Status);
        ExFreePool(stats);
        return Status;
    }
 
    return STATUS_SUCCESS;
}

Referenced by do_write2().

flush_changed_extent()

static NTSTATUS flush_changed_extent ( device_extension *  Vcb, chunk *  c, changed_extent *  ce, PIRP  Irp, LIST_ENTRY *  rollback  )

static

Definition at line 2433 of file flushthread.c.

                                                                                                                          {
    LIST_ENTRY *le, *le2;
    NTSTATUS Status;
    uint64_t old_size;
 
    if (ce->count == 0 && ce->old_count == 0) {
        while (!IsListEmpty(&ce->refs)) {
            changed_extent_ref* cer = CONTAINING_RECORD(RemoveHeadList(&ce->refs), changed_extent_ref, list_entry);
            ExFreePool(cer);
        }
 
        while (!IsListEmpty(&ce->old_refs)) {
            changed_extent_ref* cer = CONTAINING_RECORD(RemoveHeadList(&ce->old_refs), changed_extent_ref, list_entry);
            ExFreePool(cer);
        }
 
        goto end;
    }
 
    le = ce->refs.Flink;
    while (le != &ce->refs) {
        changed_extent_ref* cer = CONTAINING_RECORD(le, changed_extent_ref, list_entry);
        uint32_t old_count = 0;
 
        if (cer->type == TYPE_EXTENT_DATA_REF) {
            le2 = ce->old_refs.Flink;
            while (le2 != &ce->old_refs) {
                changed_extent_ref* cer2 = CONTAINING_RECORD(le2, changed_extent_ref, list_entry);
 
                if (cer2->type == TYPE_EXTENT_DATA_REF && cer2->edr.root == cer->edr.root && cer2->edr.objid == cer->edr.objid && cer2->edr.offset == cer->edr.offset) {
                    old_count = cer2->edr.count;
                    break;
                }
 
                le2 = le2->Flink;
            }
 
            old_size = ce->old_count > 0 ? ce->old_size : ce->size;
 
            if (cer->edr.count > old_count) {
                Status = increase_extent_refcount_data(Vcb, ce->address, old_size, cer->edr.root, cer->edr.objid, cer->edr.offset, cer->edr.count - old_count, Irp);
 
                if (!NT_SUCCESS(Status)) {
                    ERR("increase_extent_refcount_data returned %08lx\n", Status);
                    return Status;
                }
            }
        } else if (cer->type == TYPE_SHARED_DATA_REF) {
            le2 = ce->old_refs.Flink;
            while (le2 != &ce->old_refs) {
                changed_extent_ref* cer2 = CONTAINING_RECORD(le2, changed_extent_ref, list_entry);
 
                if (cer2->type == TYPE_SHARED_DATA_REF && cer2->sdr.offset == cer->sdr.offset) {
                    RemoveEntryList(&cer2->list_entry);
                    ExFreePool(cer2);
                    break;