write.c File Reference

#include "btrfs_drv.h"

Include dependency graph for write.c:

Go to the source code of this file.

Classes
struct	write_stripe
struct	stripe
struct	log_stripe

Functions
	_Function_class_ (IO_COMPLETION_ROUTINE)
chunk *	get_chunk_from_address (device_extension *Vcb, uint64_t address)
static uint64_t	find_new_chunk_address (device_extension *Vcb, uint64_t size)
static bool	find_new_dup_stripes (device_extension *Vcb, stripe *stripes, uint64_t max_stripe_size, bool full_size)
static bool	find_new_stripe (device_extension *Vcb, stripe *stripes, uint16_t i, uint64_t max_stripe_size, bool allow_missing, bool full_size)
NTSTATUS	alloc_chunk (device_extension *Vcb, uint64_t flags, chunk **pc, bool full_size)
static NTSTATUS	prepare_raid0_write (_Pre_satisfies_(_Curr_->chunk_item->num_stripes >0) _In_ chunk *c, _In_ uint64_t address, _In_reads_bytes_(length) void *data, _In_ uint32_t length, _In_ write_stripe *stripes, _In_ PIRP Irp, _In_ uint64_t irp_offset, _In_ write_data_context *wtc)
static NTSTATUS	prepare_raid10_write (_Pre_satisfies_(_Curr_->chunk_item->sub_stripes >0 &&_Curr_->chunk_item->num_stripes >=_Curr_->chunk_item->sub_stripes) _In_ chunk *c, _In_ uint64_t address, _In_reads_bytes_(length) void *data, _In_ uint32_t length, _In_ write_stripe *stripes, _In_ PIRP Irp, _In_ uint64_t irp_offset, _In_ write_data_context *wtc)
static NTSTATUS	add_partial_stripe (device_extension *Vcb, chunk *c, uint64_t address, uint32_t length, void *data)
static NTSTATUS	prepare_raid5_write (device_extension *Vcb, chunk *c, uint64_t address, void *data, uint32_t length, write_stripe *stripes, PIRP Irp, uint64_t irp_offset, ULONG priority, write_data_context *wtc)
static NTSTATUS	prepare_raid6_write (device_extension *Vcb, chunk *c, uint64_t address, void *data, uint32_t length, write_stripe *stripes, PIRP Irp, uint64_t irp_offset, ULONG priority, write_data_context *wtc)
NTSTATUS	write_data (_In_ device_extension *Vcb, _In_ uint64_t address, _In_reads_bytes_(length) void *data, _In_ uint32_t length, _In_ write_data_context *wtc, _In_opt_ PIRP Irp, _In_opt_ chunk *c, _In_ bool file_write, _In_ uint64_t irp_offset, _In_ ULONG priority)
void	get_raid56_lock_range (chunk *c, uint64_t address, uint64_t length, uint64_t *lockaddr, uint64_t *locklen)
NTSTATUS	write_data_complete (device_extension *Vcb, uint64_t address, void *data, uint32_t length, PIRP Irp, chunk *c, bool file_write, uint64_t irp_offset, ULONG priority)
void	free_write_data_stripes (write_data_context *wtc)
void	add_extent (_In_ fcb *fcb, _In_ LIST_ENTRY *prevextle, _In_ __drv_aliasesMem extent *newext)
NTSTATUS	excise_extents (device_extension *Vcb, fcb *fcb, uint64_t start_data, uint64_t end_data, PIRP Irp, LIST_ENTRY *rollback)
void	add_insert_extent_rollback (LIST_ENTRY *rollback, fcb *fcb, extent *ext)
NTSTATUS	add_extent_to_fcb (_In_ fcb *fcb, _In_ uint64_t offset, _In_reads_bytes_(edsize) EXTENT_DATA *ed, _In_ uint16_t edsize, _In_ bool unique, _In_opt_ _When_(return >=0, __drv_aliasesMem) uint32_t *csum, _In_ LIST_ENTRY *rollback)
static void	remove_fcb_extent (fcb *fcb, extent *ext, LIST_ENTRY *rollback)
NTSTATUS	calc_csum (_In_ device_extension *Vcb, _In_reads_bytes_(sectors *Vcb->superblock.sector_size) uint8_t *data, _In_ uint32_t sectors, _Out_writes_bytes_(sectors *sizeof(uint32_t)) uint32_t *csum)
	_Requires_lock_held_ (c->lock) _When_(return !=0
	_Releases_lock_ (c->lock)) bool insert_extent_chunk(_In_ device_extension *Vcb
	TRACE ("(%p, (%I64x, %I64x), %I64x, %I64x, %I64x, %u, %p, %p)\n", Vcb, fcb->subvol->id, fcb->inode, c->offset, start_data, length, prealloc, data, rollback)
	if (!find_data_address_in_chunk(Vcb, c, length, &address)) return false
	if (!ed)
	if (!prealloc &&data &&!(fcb->inode_item.flags &BTRFS_INODE_NODATASUM))
	if (!NT_SUCCESS(Status))
	ExFreePool (ed)
	space_list_subtract (c, false, address, length, rollback)
	mark_fcb_dirty (fcb)
	add_changed_extent_ref (c, address, length, fcb->subvol->id, fcb->inode, start_data, 1, fcb->inode_item.flags &BTRFS_INODE_NODATASUM)
	release_chunk_lock (c, Vcb)
	if (data)
static bool	try_extend_data (device_extension *Vcb, fcb *fcb, uint64_t start_data, uint64_t length, void *data, PIRP Irp, uint64_t *written, bool file_write, uint64_t irp_offset, LIST_ENTRY *rollback)
static NTSTATUS	insert_chunk_fragmented (fcb *fcb, uint64_t start, uint64_t length, uint8_t *data, bool prealloc, LIST_ENTRY *rollback)
static NTSTATUS	insert_prealloc_extent (fcb *fcb, uint64_t start, uint64_t length, LIST_ENTRY *rollback)
static NTSTATUS	insert_extent (device_extension *Vcb, fcb *fcb, uint64_t start_data, uint64_t length, void *data, PIRP Irp, bool file_write, uint64_t irp_offset, LIST_ENTRY *rollback)
NTSTATUS	truncate_file (fcb *fcb, uint64_t end, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	extend_file (fcb *fcb, file_ref *fileref, uint64_t end, bool prealloc, PIRP Irp, LIST_ENTRY *rollback)
static NTSTATUS	do_write_file_prealloc (fcb *fcb, extent *ext, uint64_t start_data, uint64_t end_data, void *data, uint64_t *written, PIRP Irp, bool file_write, uint64_t irp_offset, ULONG priority, LIST_ENTRY *rollback)
NTSTATUS	do_write_file (fcb *fcb, uint64_t start, uint64_t end_data, void *data, PIRP Irp, bool file_write, uint32_t irp_offset, LIST_ENTRY *rollback)
NTSTATUS	write_compressed (fcb *fcb, uint64_t start_data, uint64_t end_data, void *data, PIRP Irp, LIST_ENTRY *rollback)
NTSTATUS	write_file2 (device_extension *Vcb, PIRP Irp, LARGE_INTEGER offset, void *buf, ULONG *length, bool paging_io, bool no_cache, bool wait, bool deferred_write, bool write_irp, LIST_ENTRY *rollback)
NTSTATUS	write_file (device_extension *Vcb, PIRP Irp, bool wait, bool deferred_write)
	_Dispatch_type_ (IRP_MJ_WRITE)

Variables
_In_ fcb *	fcb
_In_ fcb _In_ chunk *	c
_In_ fcb _In_ chunk _In_ uint64_t	start_data
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t	length
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool	prealloc
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void *	data
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP	Irp
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY *	rollback
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t	compression = compression
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t	decoded_size = decoded_size
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t _In_ bool	file_write
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t _In_ uint64_t _In_ bool _In_ uint64_t	irp_offset
NTSTATUS	Status = add_extent_to_fcb(fcb, start_data, ed, edsize, true, csum, rollback)
EXTENT_DATA *	ed = ExAllocatePoolWithTag(PagedPool, edsize, ALLOC_TAG)
EXTENT_DATA2 *	ed2 = (EXTENT_DATA2*)ed->data
uint16_t	edsize = (uint16_t)(offsetof(EXTENT_DATA, data[0]) + sizeof(EXTENT_DATA2))
uint32_t *	csum = NULL
ed	generation = Vcb->superblock.generation
ed	encryption = BTRFS_ENCRYPTION_NONE
ed	encoding = BTRFS_ENCODING_NONE
ed	type = prealloc ? EXTENT_TYPE_PREALLOC : EXTENT_TYPE_REGULAR
ed2	address = address
ed2	size = length
ed2	offset = 0
ed2	num_bytes = decoded_size
c	used = length
fcb inode_item	st_blocks = decoded_size
fcb	extents_changed = true
fcb	inode_item_changed = true
return	true

Function Documentation

_Dispatch_type_()

_Dispatch_type_

(

IRP_MJ_WRITE

)

Definition at line 4705 of file write.c.

                                                                          {
    NTSTATUS Status;
    bool top_level;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    device_extension* Vcb = DeviceObject->DeviceExtension;
    PFILE_OBJECT FileObject = IrpSp->FileObject;
    fcb* fcb = FileObject ? FileObject->FsContext : NULL;
    ccb* ccb = FileObject ? FileObject->FsContext2 : NULL;
    bool wait = FileObject ? IoIsOperationSynchronous(Irp) : true;

    FsRtlEnterFileSystem();

    top_level = is_top_level(Irp);

    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = vol_write(DeviceObject, Irp);
        goto exit;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }

    if (!fcb) {
        ERR("fcb was NULL\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }

    if (!ccb) {
        ERR("ccb was NULL\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }

    if (Irp->RequestorMode == UserMode && !(ccb->access & (FILE_WRITE_DATA | FILE_APPEND_DATA))) {
        WARN("insufficient permissions\n");
        Status = STATUS_ACCESS_DENIED;
        goto end;
    }

    if (fcb == Vcb->volume_fcb) {
        if (!Vcb->locked || Vcb->locked_fileobj != FileObject) {
            ERR("trying to write to volume when not locked, or locked with another FileObject\n");
            Status = STATUS_ACCESS_DENIED;
            goto end;
        }

        TRACE("writing directly to volume\n");

        IoSkipCurrentIrpStackLocation(Irp);

        Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
        goto exit;
    }

    if (is_subvol_readonly(fcb->subvol, Irp)) {
        Status = STATUS_ACCESS_DENIED;
        goto end;
    }

    if (Vcb->readonly) {
        Status = STATUS_MEDIA_WRITE_PROTECTED;
        goto end;
    }

    _SEH2_TRY {
        if (IrpSp->MinorFunction & IRP_MN_COMPLETE) {
            CcMdlWriteComplete(IrpSp->FileObject, &IrpSp->Parameters.Write.ByteOffset, Irp->MdlAddress);

            Irp->MdlAddress = NULL;
            Status = STATUS_SUCCESS;
        } else {
            if (!(Irp->Flags & IRP_PAGING_IO))
                FsRtlCheckOplock(fcb_oplock(fcb), Irp, NULL, NULL, NULL);

            // Don't offload jobs when doing paging IO - otherwise this can lead to
            // deadlocks in CcCopyWrite.
            if (Irp->Flags & IRP_PAGING_IO)
                wait = true;

            Status = write_file(Vcb, Irp, wait, false);
        }
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
        Status = _SEH2_GetExceptionCode();
    } _SEH2_END;

end:
    Irp->IoStatus.Status = Status;

    TRACE("wrote %u bytes\n", Irp->IoStatus.Information);

    if (Status != STATUS_PENDING)
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    else {
        IoMarkIrpPending(Irp);

        if (!add_thread_job(Vcb, Irp))
            Status = do_write_job(Vcb, Irp);
    }

exit:
    if (top_level)
        IoSetTopLevelIrp(NULL);

    TRACE("returning %08x\n", Status);

    FsRtlExitFileSystem();

    return Status;
}

_Function_class_()

_Function_class_

(

IO_COMPLETION_ROUTINE

)

Definition at line 28 of file write.c.

                                                                                                     {
    LIST_ENTRY* le;
    space* s;

    TRACE("(%p, %I64x, %I64x, %p)\n", Vcb, c->offset, length, address);

    if (length > 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 %08x\n", Status);
            return false;
        }
    }

    if (IsListEmpty(&c->space_size))
        return false;

    le = c->space_size.Flink;
    while (le != &c->space_size) {
        s = CONTAINING_RECORD(le, space, list_entry_size);

        if (s->size == length) {
            *address = s->address;
            return true;
        } else if (s->size < length) {
            if (le == c->space_size.Flink)
                return false;

            s = CONTAINING_RECORD(le->Blink, space, list_entry_size);

            *address = s->address;
            return true;
        }

        le = le->Flink;
    }

    s = CONTAINING_RECORD(c->space_size.Blink, space, list_entry_size);

    if (s->size > length) {
        *address = s->address;
        return true;
    }

    return false;
}

_Releases_lock_()

_Releases_lock_

(

c->

lock

)

_Requires_lock_held_()

_Requires_lock_held_ ( c->  lock )

pure virtual

add_changed_extent_ref()

add_changed_extent_ref	(	c	,
		address	,
		length	,
		fcb->subvol->	id,
		fcb->	inode,
		start_data	,
		1	,
		fcb->inode_item.flags &	BTRFS_INODE_NODATASUM
	)

add_extent()

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

Definition at line 2351 of file write.c.

                                                                                                 {
    LIST_ENTRY* le = prevextle->Flink;

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

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

        le = le->Flink;
    }

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

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

add_extent_to_fcb()

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

Definition at line 2720 of file write.c.

                                                                                                                                       {
    extent* ext;
    LIST_ENTRY* le;

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

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

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

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

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

        le = le->Flink;
    }

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

end:
    add_insert_extent_rollback(rollback, fcb, ext);

    return STATUS_SUCCESS;
}

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

add_insert_extent_rollback()

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

Definition at line 2701 of file write.c.

                                                                             {
    rollback_extent* re;

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

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

    add_rollback(rollback, ROLLBACK_INSERT_EXTENT, re);
}

Referenced by add_extent_to_fcb(), and do_write_file_prealloc().

add_partial_stripe()

static NTSTATUS add_partial_stripe ( device_extension *  Vcb, chunk *  c, uint64_t  address, uint32_t  length, void *  data  )

static

Definition at line 960 of file write.c.

                                                                                                                   {
    NTSTATUS Status;
    LIST_ENTRY* le;
    partial_stripe* ps;
    uint64_t stripe_addr;
    uint16_t num_data_stripes;

    num_data_stripes = c->chunk_item->num_stripes - (c->chunk_item->type & BLOCK_FLAG_RAID5 ? 1 : 2);
    stripe_addr = address - ((address - c->offset) % (num_data_stripes * c->chunk_item->stripe_length));

    ExAcquireResourceExclusiveLite(&c->partial_stripes_lock, true);

    le = c->partial_stripes.Flink;
    while (le != &c->partial_stripes) {
        ps = CONTAINING_RECORD(le, partial_stripe, list_entry);

        if (ps->address == stripe_addr) {
            // update existing entry

            RtlCopyMemory(ps->data + address - stripe_addr, data, length);
            RtlClearBits(&ps->bmp, (ULONG)((address - stripe_addr) / Vcb->superblock.sector_size), length / Vcb->superblock.sector_size);

            // if now filled, flush
            if (RtlAreBitsClear(&ps->bmp, 0, (ULONG)((num_data_stripes * c->chunk_item->stripe_length) / Vcb->superblock.sector_size))) {
                Status = flush_partial_stripe(Vcb, c, ps);
                if (!NT_SUCCESS(Status)) {
                    ERR("flush_partial_stripe returned %08x\n", Status);
                    goto end;
                }

                RemoveEntryList(&ps->list_entry);

                if (ps->bmparr)
                    ExFreePool(ps->bmparr);

                ExFreePool(ps);
            }

            Status = STATUS_SUCCESS;
            goto end;
        } else if (ps->address > stripe_addr)
            break;

        le = le->Flink;
    }

    // add new entry

    ps = ExAllocatePoolWithTag(NonPagedPool, offsetof(partial_stripe, data[0]) + (ULONG)(num_data_stripes * c->chunk_item->stripe_length), ALLOC_TAG);
    if (!ps) {
        ERR("out of memory\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto end;
    }

    ps->bmplen = (ULONG)(num_data_stripes * c->chunk_item->stripe_length) / Vcb->superblock.sector_size;

    ps->address = stripe_addr;
    ps->bmparr = ExAllocatePoolWithTag(NonPagedPool, (size_t)sector_align(((ps->bmplen / 8) + 1), sizeof(ULONG)), ALLOC_TAG);
    if (!ps->bmparr) {
        ERR("out of memory\n");
        ExFreePool(ps);
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto end;
    }

    RtlInitializeBitMap(&ps->bmp, ps->bmparr, ps->bmplen);
    RtlSetAllBits(&ps->bmp);

    RtlCopyMemory(ps->data + address - stripe_addr, data, length);
    RtlClearBits(&ps->bmp, (ULONG)((address - stripe_addr) / Vcb->superblock.sector_size), length / Vcb->superblock.sector_size);

    InsertHeadList(le->Blink, &ps->list_entry);

    Status = STATUS_SUCCESS;

end:
    ExReleaseResourceLite(&c->partial_stripes_lock);

    return Status;
}

Referenced by prepare_raid5_write(), and prepare_raid6_write().

alloc_chunk()

NTSTATUS alloc_chunk	(	device_extension *	Vcb,
		uint64_t	flags,
		chunk **	pc,
		bool	full_size
	)

Definition at line 361 of file write.c.

                                                                                        {
    NTSTATUS Status;
    uint64_t max_stripe_size, max_chunk_size, stripe_size, stripe_length, factor;
    uint64_t total_size = 0, logaddr;
    uint16_t i, type, num_stripes, sub_stripes, max_stripes, min_stripes, allowed_missing;
    stripe* stripes = NULL;
    uint16_t cisize;
    CHUNK_ITEM_STRIPE* cis;
    chunk* c = NULL;
    space* s = NULL;
    LIST_ENTRY* le;

    le = Vcb->devices.Flink;
    while (le != &Vcb->devices) {
        device* dev = CONTAINING_RECORD(le, device, list_entry);
        total_size += dev->devitem.num_bytes;

        le = le->Flink;
    }

    TRACE("total_size = %I64x\n", total_size);

    // We purposely check for DATA first - mixed blocks have the same size
    // as DATA ones.
    if (flags & BLOCK_FLAG_DATA) {
        max_stripe_size = 0x40000000; // 1 GB
        max_chunk_size = 10 * max_stripe_size;
    } else if (flags & BLOCK_FLAG_METADATA) {
        if (total_size > 0xC80000000) // 50 GB
            max_stripe_size = 0x40000000; // 1 GB
        else
            max_stripe_size = 0x10000000; // 256 MB

        max_chunk_size = max_stripe_size;
    } else if (flags & BLOCK_FLAG_SYSTEM) {
        max_stripe_size = 0x2000000; // 32 MB
        max_chunk_size = 2 * max_stripe_size;
    } else {
        ERR("unknown chunk type\n");
        return STATUS_INTERNAL_ERROR;
    }

    if (flags & BLOCK_FLAG_DUPLICATE) {
        min_stripes = 2;
        max_stripes = 2;
        sub_stripes = 0;
        type = BLOCK_FLAG_DUPLICATE;
        allowed_missing = 0;
    } else if (flags & BLOCK_FLAG_RAID0) {
        min_stripes = 2;
        max_stripes = (uint16_t)min(0xffff, Vcb->superblock.num_devices);
        sub_stripes = 0;
        type = BLOCK_FLAG_RAID0;
        allowed_missing = 0;
    } else if (flags & BLOCK_FLAG_RAID1) {
        min_stripes = 2;
        max_stripes = 2;
        sub_stripes = 1;
        type = BLOCK_FLAG_RAID1;
        allowed_missing = 1;
    } else if (flags & BLOCK_FLAG_RAID10) {
        min_stripes = 4;
        max_stripes = (uint16_t)min(0xffff, Vcb->superblock.num_devices);
        sub_stripes = 2;
        type = BLOCK_FLAG_RAID10;
        allowed_missing = 1;
    } else if (flags & BLOCK_FLAG_RAID5) {
        min_stripes = 3;
        max_stripes = (uint16_t)min(0xffff, Vcb->superblock.num_devices);
        sub_stripes = 1;
        type = BLOCK_FLAG_RAID5;
        allowed_missing = 1;
    } else if (flags & BLOCK_FLAG_RAID6) {
        min_stripes = 4;
        max_stripes = 257;
        sub_stripes = 1;
        type = BLOCK_FLAG_RAID6;
        allowed_missing = 2;
    } else { // SINGLE
        min_stripes = 1;
        max_stripes = 1;
        sub_stripes = 1;
        type = 0;
        allowed_missing = 0;
    }

    if (max_chunk_size > total_size / 10) {  // cap at 10%
        max_chunk_size = total_size / 10;
        max_stripe_size = max_chunk_size / min_stripes;
    }

    TRACE("would allocate a new chunk of %I64x bytes and stripe %I64x\n", max_chunk_size, max_stripe_size);

    stripes = ExAllocatePoolWithTag(PagedPool, sizeof(stripe) * max_stripes, ALLOC_TAG);
    if (!stripes) {
        ERR("out of memory\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto end;
    }

    num_stripes = 0;

    if (type == BLOCK_FLAG_DUPLICATE) {
        if (!find_new_dup_stripes(Vcb, stripes, max_stripe_size, full_size)) {
            Status = STATUS_DISK_FULL;
            goto end;
        }
        else
            num_stripes = max_stripes;
    } else {
        for (i = 0; i < max_stripes; i++) {
            if (!find_new_stripe(Vcb, stripes, i, max_stripe_size, false, full_size))
                break;
            else
                num_stripes++;
        }
    }

    if (num_stripes < min_stripes && Vcb->options.allow_degraded && allowed_missing > 0) {
        uint16_t added_missing = 0;

        for (i = num_stripes; i < max_stripes; i++) {
            if (!find_new_stripe(Vcb, stripes, i, max_stripe_size, true, full_size))
                break;
            else {
                added_missing++;
                if (added_missing >= allowed_missing)
                    break;
            }
        }

        num_stripes += added_missing;
    }

    // for RAID10, round down to an even number of stripes
    if (type == BLOCK_FLAG_RAID10 && (num_stripes % sub_stripes) != 0) {
        num_stripes -= num_stripes % sub_stripes;
    }

    if (num_stripes < min_stripes) {
        WARN("found %u stripes, needed at least %u\n", num_stripes, min_stripes);
        Status = STATUS_DISK_FULL;
        goto end;
    }

    c = ExAllocatePoolWithTag(NonPagedPool, sizeof(chunk), ALLOC_TAG);
    if (!c) {
        ERR("out of memory\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto end;
    }

    c->devices = NULL;

    cisize = sizeof(CHUNK_ITEM) + (num_stripes * sizeof(CHUNK_ITEM_STRIPE));
    c->chunk_item = ExAllocatePoolWithTag(NonPagedPool, cisize, ALLOC_TAG);
    if (!c->chunk_item) {
        ERR("out of memory\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto end;
    }

    stripe_length = 0x10000; // FIXME? BTRFS_STRIPE_LEN in kernel

    if (type == BLOCK_FLAG_DUPLICATE && stripes[1].dh == stripes[0].dh)
        stripe_size = min(stripes[0].dh->size / 2, max_stripe_size);
    else {
        stripe_size = max_stripe_size;
        for (i = 0; i < num_stripes; i++) {
            if (stripes[i].dh->size < stripe_size)
                stripe_size = stripes[i].dh->size;
        }
    }

    if (type == 0 || type == BLOCK_FLAG_DUPLICATE || type == BLOCK_FLAG_RAID1)
        factor = 1;
    else if (type == BLOCK_FLAG_RAID0)
        factor = num_stripes;
    else if (type == BLOCK_FLAG_RAID10)
        factor = num_stripes / sub_stripes;
    else if (type == BLOCK_FLAG_RAID5)
        factor = num_stripes - 1;
    else if (type == BLOCK_FLAG_RAID6)
        factor = num_stripes - 2;

    if (stripe_size * factor > max_chunk_size)
        stripe_size = max_chunk_size / factor;

    if (stripe_size % stripe_length > 0)
        stripe_size -= stripe_size % stripe_length;

    if (stripe_size == 0) {
        ERR("not enough free space found (stripe_size == 0)\n");
        Status = STATUS_DISK_FULL;
        goto end;
    }

    c->chunk_item->size = stripe_size * factor;
    c->chunk_item->root_id = Vcb->extent_root->id;
    c->chunk_item->stripe_length = stripe_length;
    c->chunk_item->type = flags;
    c->chunk_item->opt_io_alignment = (uint32_t)c->chunk_item->stripe_length;
    c->chunk_item->opt_io_width = (uint32_t)c->chunk_item->stripe_length;
    c->chunk_item->sector_size = stripes[0].device->devitem.minimal_io_size;
    c->chunk_item->num_stripes = num_stripes;
    c->chunk_item->sub_stripes = sub_stripes;

    c->devices = ExAllocatePoolWithTag(NonPagedPool, sizeof(device*) * num_stripes, ALLOC_TAG);
    if (!c->devices) {
        ERR("out of memory\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto end;
    }

    cis = (CHUNK_ITEM_STRIPE*)&c->chunk_item[1];
    for (i = 0; i < num_stripes; i++) {
        cis[i].dev_id = stripes[i].device->devitem.dev_id;

        if (type == BLOCK_FLAG_DUPLICATE && i == 1 && stripes[i].dh == stripes[0].dh)
            cis[i].offset = stripes[0].dh->address + stripe_size;
        else
            cis[i].offset = stripes[i].dh->address;

        cis[i].dev_uuid = stripes[i].device->devitem.device_uuid;

        c->devices[i] = stripes[i].device;
    }

    logaddr = find_new_chunk_address(Vcb, c->chunk_item->size);

    Vcb->superblock.chunk_root_generation = Vcb->superblock.generation;

    c->size = cisize;
    c->offset = logaddr;
    c->used = c->oldused = 0;
    c->cache = c->old_cache = NULL;
    c->readonly = false;
    c->reloc = false;
    c->last_alloc_set = false;
    c->last_stripe = 0;
    c->cache_loaded = true;
    c->changed = false;
    c->space_changed = false;
    c->balance_num = 0;

    InitializeListHead(&c->space);
    InitializeListHead(&c->space_size);
    InitializeListHead(&c->deleting);
    InitializeListHead(&c->changed_extents);

    InitializeListHead(&c->range_locks);
    ExInitializeResourceLite(&c->range_locks_lock);
    KeInitializeEvent(&c->range_locks_event, NotificationEvent, false);

    InitializeListHead(&c->partial_stripes);
    ExInitializeResourceLite(&c->partial_stripes_lock);

    ExInitializeResourceLite(&c->lock);
    ExInitializeResourceLite(&c->changed_extents_lock);

    s = ExAllocatePoolWithTag(NonPagedPool, sizeof(space), ALLOC_TAG);
    if (!s) {
        ERR("out of memory\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto end;
    }

    s->address = c->offset;
    s->size = c->chunk_item->size;
    InsertTailList(&c->space, &s->list_entry);
    InsertTailList(&c->space_size, &s->list_entry_size);

    protect_superblocks(c);

    for (i = 0; i < num_stripes; i++) {
        stripes[i].device->devitem.bytes_used += stripe_size;

        space_list_subtract2(&stripes[i].device->space, NULL, cis[i].offset, stripe_size, NULL, NULL);
    }

    Status = STATUS_SUCCESS;

    if (flags & BLOCK_FLAG_RAID5 || flags & BLOCK_FLAG_RAID6)
        Vcb->superblock.incompat_flags |= BTRFS_INCOMPAT_FLAGS_RAID56;

end:
    if (stripes)
        ExFreePool(stripes);

    if (!NT_SUCCESS(Status)) {
        if (c) {
            if (c->devices)
                ExFreePool(c->devices);

            if (c->chunk_item)
                ExFreePool(c->chunk_item);

            ExFreePool(c);
        }

        if (s) ExFreePool(s);
    } else {
        bool done = false;

        le = Vcb->chunks.Flink;
        while (le != &Vcb->chunks) {
            chunk* c2 = CONTAINING_RECORD(le, chunk, list_entry);

            if (c2->offset > c->offset) {
                InsertHeadList(le->Blink, &c->list_entry);
                done = true;
                break;
            }

            le = le->Flink;
        }

        if (!done)
            InsertTailList(&Vcb->chunks, &c->list_entry);

        c->created = true;
        c->changed = true;
        c->space_changed = true;
        c->list_entry_balance.Flink = NULL;

        *pc = c;
    }

    return Status;
}

Referenced by _Function_class_(), balance_data_chunk(), get_tree_new_address(), insert_cache_extent(), insert_chunk_fragmented(), insert_extent(), insert_prealloc_extent(), lzo_write_compressed_bit(), try_consolidation(), write_metadata_items(), zlib_write_compressed_bit(), and zstd_write_compressed_bit().

calc_csum()

NTSTATUS calc_csum	(	_In_ device_extension *	Vcb,
		_In_reads_bytes_(sectors *Vcb->superblock.sector_size) uint8_t *	data,
		_In_ uint32_t	sectors,
		_Out_writes_bytes_(sectors *sizeof(uint32_t)) uint32_t *	csum
	)

Definition at line 2782 of file write.c.

                                                                                                       {
    NTSTATUS Status;
    calc_job* cj;

    // From experimenting, it seems that 40 sectors is roughly the crossover
    // point where offloading the crc32 calculation becomes worth it.

    if (sectors < 40 || get_num_of_processors() < 2) {
        ULONG j;

        for (j = 0; j < sectors; j++) {
            csum[j] = ~calc_crc32c(0xffffffff, data + (j * Vcb->superblock.sector_size), Vcb->superblock.sector_size);
        }

        return STATUS_SUCCESS;
    }

    Status = add_calc_job(Vcb, data, sectors, csum, &cj);
    if (!NT_SUCCESS(Status)) {
        ERR("add_calc_job returned %08x\n", Status);
        return Status;
    }

    KeWaitForSingleObject(&cj->event, Executive, KernelMode, false, NULL);
    free_calc_job(cj);

    return STATUS_SUCCESS;
}

Referenced by do_write_file(), do_write_file_prealloc(), if(), scrub_extent_dup(), and scrub_extent_raid10().

do_write_file()

NTSTATUS do_write_file	(	fcb *	fcb,
		uint64_t	start,
		uint64_t	end_data,
		void *	data,
		PIRP	Irp,
		bool	file_write,
		uint32_t	irp_offset,
		LIST_ENTRY *	rollback
	)

Definition at line 3939 of file write.c.

                                                                                                                                                      {
    NTSTATUS Status;
    LIST_ENTRY *le, *le2;
    uint64_t written = 0, length = end_data - start;
    uint64_t last_cow_start;
    ULONG priority = fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE ? HighPagePriority : NormalPagePriority;
#ifdef DEBUG_PARANOID
    uint64_t last_off;
#endif
    bool extents_changed = false;

    last_cow_start = 0;

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

        le2 = le->Flink;

        if (!ext->ignore) {
            EXTENT_DATA* ed = &ext->extent_data;
            EXTENT_DATA2* ed2 = ed->type == EXTENT_TYPE_INLINE ? NULL : (EXTENT_DATA2*)ed->data;
            uint64_t len;

            len = ed->type == EXTENT_TYPE_INLINE ? ed->decoded_size : ed2->num_bytes;

            if (ext->offset + len <= start)
                goto nextitem;

            if (ext->offset > start + written + length)
                break;

            if ((fcb->inode_item.flags & BTRFS_INODE_NODATACOW || ed->type == EXTENT_TYPE_PREALLOC) && ext->unique && ed->compression == BTRFS_COMPRESSION_NONE) {
                if (max(last_cow_start, start + written) < ext->offset) {
                    uint64_t start_write = max(last_cow_start, start + written);

                    extents_changed = true;

                    Status = excise_extents(fcb->Vcb, fcb, start_write, ext->offset, Irp, rollback);
                    if (!NT_SUCCESS(Status)) {
                        ERR("excise_extents returned %08x\n", Status);
                        return Status;
                    }

                    Status = insert_extent(fcb->Vcb, fcb, start_write, ext->offset - start_write, (uint8_t*)data + written, Irp, file_write, irp_offset + written, rollback);
                    if (!NT_SUCCESS(Status)) {
                        ERR("insert_extent returned %08x\n", Status);
                        return Status;
                    }

                    written += ext->offset - start_write;
                    length -= ext->offset - start_write;

                    if (length == 0)
                        break;
                }

                if (ed->type == EXTENT_TYPE_REGULAR) {
                    uint64_t writeaddr = ed2->address + ed2->offset + start + written - ext->offset;
                    uint64_t write_len = min(len, length);
                    chunk* c;

                    TRACE("doing non-COW write to %I64x\n", writeaddr);

                    Status = write_data_complete(fcb->Vcb, writeaddr, (uint8_t*)data + written, (uint32_t)write_len, Irp, NULL, file_write, irp_offset + written, priority);
                    if (!NT_SUCCESS(Status)) {
                        ERR("write_data_complete returned %08x\n", Status);
                        return Status;
                    }

                    c = get_chunk_from_address(fcb->Vcb, writeaddr);
                    if (c)
                        c->changed = true;

                    // This shouldn't ever get called - nocow files should always also be nosum.
                    if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
                        calc_csum(fcb->Vcb, (uint8_t*)data + written, (uint32_t)(write_len / fcb->Vcb->superblock.sector_size),
                                  &ext->csum[(start + written - ext->offset) / fcb->Vcb->superblock.sector_size]);

                        ext->inserted = true;
                        extents_changed = true;
                    }

                    written += write_len;
                    length -= write_len;

                    if (length == 0)
                        break;
                } else if (ed->type == EXTENT_TYPE_PREALLOC) {
                    uint64_t write_len;

                    Status = do_write_file_prealloc(fcb, ext, start + written, end_data, (uint8_t*)data + written, &write_len,
                                                    Irp, file_write, irp_offset + written, priority, rollback);
                    if (!NT_SUCCESS(Status)) {
                        ERR("do_write_file_prealloc returned %08x\n", Status);
                        return Status;
                    }

                    extents_changed = true;

                    written += write_len;
                    length -= write_len;

                    if (length == 0)
                        break;
                }

                last_cow_start = ext->offset + len;
            }
        }

nextitem:
        le = le2;
    }

    if (length > 0) {
        uint64_t start_write = max(last_cow_start, start + written);

        extents_changed = true;

        Status = excise_extents(fcb->Vcb, fcb, start_write, end_data, Irp, rollback);
        if (!NT_SUCCESS(Status)) {
            ERR("excise_extents returned %08x\n", Status);
            return Status;
        }

        Status = insert_extent(fcb->Vcb, fcb, start_write, end_data - start_write, (uint8_t*)data + written, Irp, file_write, irp_offset + written, rollback);
        if (!NT_SUCCESS(Status)) {
            ERR("insert_extent returned %08x\n", Status);
            return Status;
        }
    }

#ifdef DEBUG_PARANOID
    last_off = 0xffffffffffffffff;

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

        if (!ext->ignore) {
            if (ext->offset == last_off) {
                ERR("offset %I64x duplicated\n", ext->offset);
                int3;
            } else if (ext->offset < last_off && last_off != 0xffffffffffffffff) {
                ERR("offsets out of order\n");
                int3;
            }

            last_off = ext->offset;
        }

        le = le->Flink;
    }
#endif

    if (extents_changed) {
        fcb->extents_changed = true;
        mark_fcb_dirty(fcb);
    }

    return STATUS_SUCCESS;
}

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

do_write_file_prealloc()

static NTSTATUS do_write_file_prealloc ( fcb *  fcb, extent *  ext, uint64_t  start_data, uint64_t  end_data, void *  data, uint64_t *  written, PIRP  Irp, bool  file_write, uint64_t  irp_offset, ULONG  priority, LIST_ENTRY *  rollback  )

static

Definition at line 3552 of file write.c.

                                                                                                                             {
    EXTENT_DATA* ed = &ext->extent_data;
    EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ed->data;
    NTSTATUS Status;
    chunk* c = NULL;

    if (start_data <= ext->offset && end_data >= ext->offset + ed2->num_bytes) { // replace all
        extent* newext;

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

        RtlCopyMemory(&newext->extent_data, &ext->extent_data, ext->datalen);

        newext->extent_data.type = EXTENT_TYPE_REGULAR;

        Status = write_data_complete(fcb->Vcb, ed2->address + ed2->offset, (uint8_t*)data + ext->offset - start_data, (uint32_t)ed2->num_bytes, Irp,
                                     NULL, file_write, irp_offset + ext->offset - start_data, priority);
        if (!NT_SUCCESS(Status)) {
            ERR("write_data_complete returned %08x\n", Status);
            return Status;
        }

        if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
            ULONG sl = (ULONG)(ed2->num_bytes / fcb->Vcb->superblock.sector_size);
            uint32_t* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(uint32_t), ALLOC_TAG);

            if (!csum) {
                ERR("out of memory\n");
                ExFreePool(newext);
                return STATUS_INSUFFICIENT_RESOURCES;
            }

            Status = calc_csum(fcb->Vcb, (uint8_t*)data + ext->offset - start_data, sl, csum);
            if (!NT_SUCCESS(Status)) {
                ERR("calc_csum returned %08x\n", Status);
                ExFreePool(csum);
                ExFreePool(newext);
                return Status;
            }

            newext->csum = csum;
        } else
            newext->csum = NULL;

        *written = ed2->num_bytes;

        newext->offset = ext->offset;
        newext->datalen = ext->datalen;
        newext->unique = ext->unique;
        newext->ignore = false;
        newext->inserted = true;
        InsertHeadList(&ext->list_entry, &newext->list_entry);

        add_insert_extent_rollback(rollback, fcb, newext);

        remove_fcb_extent(fcb, ext, rollback);

        c = get_chunk_from_address(fcb->Vcb, ed2->address);
    } else if (start_data <= ext->offset && end_data < ext->offset + ed2->num_bytes) { // replace beginning
        EXTENT_DATA2* ned2;
        extent *newext1, *newext2;

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

        newext2 = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + ext->datalen, ALLOC_TAG);
        if (!newext2) {
            ERR("out of memory\n");
            ExFreePool(newext1);
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        RtlCopyMemory(&newext1->extent_data, &ext->extent_data, ext->datalen);
        newext1->extent_data.type = EXTENT_TYPE_REGULAR;
        ned2 = (EXTENT_DATA2*)newext1->extent_data.data;
        ned2->num_bytes = end_data - ext->offset;

        RtlCopyMemory(&newext2->extent_data, &ext->extent_data, ext->datalen);
        ned2 = (EXTENT_DATA2*)newext2->extent_data.data;
        ned2->offset += end_data - ext->offset;
        ned2->num_bytes -= end_data - ext->offset;

        Status = write_data_complete(fcb->Vcb, ed2->address + ed2->offset, (uint8_t*)data + ext->offset - start_data, (uint32_t)(end_data - ext->offset),
                                     Irp, NULL, file_write, irp_offset + ext->offset - start_data, priority);
        if (!NT_SUCCESS(Status)) {
            ERR("write_data_complete returned %08x\n", Status);
            ExFreePool(newext1);
            ExFreePool(newext2);
            return Status;
        }

        if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
            ULONG sl = (ULONG)((end_data - ext->offset) / fcb->Vcb->superblock.sector_size);
            uint32_t* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(uint32_t), ALLOC_TAG);

            if (!csum) {
                ERR("out of memory\n");
                ExFreePool(newext1);
                ExFreePool(newext2);
                return STATUS_INSUFFICIENT_RESOURCES;
            }

            Status = calc_csum(fcb->Vcb, (uint8_t*)data + ext->offset - start_data, sl, csum);
            if (!NT_SUCCESS(Status)) {
                ERR("calc_csum returned %08x\n", Status);
                ExFreePool(newext1);
                ExFreePool(newext2);
                ExFreePool(csum);
                return Status;
            }

            newext1->csum = csum;
        } else
            newext1->csum = NULL;

        *written = end_data - ext->offset;

        newext1->offset = ext->offset;
        newext1->datalen = ext->datalen;
        newext1->unique = ext->unique;
        newext1->ignore = false;
        newext1->inserted = true;
        InsertHeadList(&ext->list_entry, &newext1->list_entry);

        add_insert_extent_rollback(rollback, fcb, newext1);

        newext2->offset = end_data;
        newext2->datalen = ext->datalen;
        newext2->unique = ext->unique;
        newext2->ignore = false;
        newext2->inserted = true;
        newext2->csum = NULL;
        add_extent(fcb, &newext1->list_entry, newext2);

        add_insert_extent_rollback(rollback, fcb, newext2);

        c = get_chunk_from_address(fcb->Vcb, ed2->address);

        if (!c)
            ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
        else {
            Status = update_changed_extent_ref(fcb->Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, 1,
                                                fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);

            if (!NT_SUCCESS(Status)) {
                ERR("update_changed_extent_ref returned %08x\n", Status);
                return Status;
            }
        }

        remove_fcb_extent(fcb, ext, rollback);
    } else if (start_data > ext->offset && end_data >= ext->offset + ed2->num_bytes) { // replace end
        EXTENT_DATA2* ned2;
        extent *newext1, *newext2;

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

        newext2 = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + ext->datalen, ALLOC_TAG);
        if (!newext2) {
            ERR("out of memory\n");
            ExFreePool(newext1);
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        RtlCopyMemory(&newext1->extent_data, &ext->extent_data, ext->datalen);

        ned2 = (EXTENT_DATA2*)newext1->extent_data.data;
        ned2->num_bytes = start_data - ext->offset;

        RtlCopyMemory(&newext2->extent_data, &ext->extent_data, ext->datalen);

        newext2->extent_data.type = EXTENT_TYPE_REGULAR;
        ned2 = (EXTENT_DATA2*)newext2->extent_data.data;
        ned2->offset += start_data - ext->offset;
        ned2->num_bytes = ext->offset + ed2->num_bytes - start_data;

        Status = write_data_complete(fcb->Vcb, ed2->address + ned2->offset, data, (uint32_t)ned2->num_bytes, Irp, NULL, file_write, irp_offset, priority);
        if (!NT_SUCCESS(Status)) {
            ERR("write_data_complete returned %08x\n", Status);
            ExFreePool(newext1);
            ExFreePool(newext2);
            return Status;
        }

        if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
            ULONG sl = (ULONG)(ned2->num_bytes / fcb->Vcb->superblock.sector_size);
            uint32_t* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(uint32_t), ALLOC_TAG);

            if (!csum) {
                ERR("out of memory\n");
                ExFreePool(newext1);
                ExFreePool(newext2);
                return STATUS_INSUFFICIENT_RESOURCES;
            }

            Status = calc_csum(fcb->Vcb, data, sl, csum);
            if (!NT_SUCCESS(Status)) {
                ERR("calc_csum returned %08x\n", Status);
                ExFreePool(newext1);
                ExFreePool(newext2);
                ExFreePool(csum);
                return Status;
            }

            newext2->csum = csum;
        } else
            newext2->csum = NULL;

        *written = ned2->num_bytes;

        newext1->offset = ext->offset;
        newext1->datalen = ext->datalen;
        newext1->unique = ext->unique;
        newext1->ignore = false;
        newext1->inserted = true;
        newext1->csum = NULL;
        InsertHeadList(&ext->list_entry, &newext1->list_entry);

        add_insert_extent_rollback(rollback, fcb, newext1);

        newext2->offset = start_data;
        newext2->datalen = ext->datalen;
        newext2->unique = ext->unique;
        newext2->ignore = false;
        newext2->inserted = true;
        add_extent(fcb, &newext1->list_entry, newext2);

        add_insert_extent_rollback(rollback, fcb, newext2);

        c = get_chunk_from_address(fcb->Vcb, ed2->address);

        if (!c)
            ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
        else {
            Status = update_changed_extent_ref(fcb->Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, 1,
                                               fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);

            if (!NT_SUCCESS(Status)) {
                ERR("update_changed_extent_ref returned %08x\n", Status);
                return Status;
            }
        }

        remove_fcb_extent(fcb, ext, rollback);
    } else if (start_data > ext->offset && end_data < ext->offset + ed2->num_bytes) { // replace middle
        EXTENT_DATA2* ned2;
        extent *newext1, *newext2, *newext3;

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

        newext2 = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + ext->datalen, ALLOC_TAG);
        if (!newext2) {
            ERR("out of memory\n");
            ExFreePool(newext1);
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        newext3 = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + ext->datalen, ALLOC_TAG);
        if (!newext3) {
            ERR("out of memory\n");
            ExFreePool(newext1);
            ExFreePool(newext2);
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        RtlCopyMemory(&newext1->extent_data, &ext->extent_data, ext->datalen);
        RtlCopyMemory(&newext2->extent_data, &ext->extent_data, ext->datalen);
        RtlCopyMemory(&newext3->extent_data, &ext->extent_data, ext->datalen);

        ned2 = (EXTENT_DATA2*)newext1->extent_data.data;
        ned2->num_bytes = start_data - ext->offset;

        newext2->extent_data.type = EXTENT_TYPE_REGULAR;
        ned2 = (EXTENT_DATA2*)newext2->extent_data.data;
        ned2->offset += start_data - ext->offset;
        ned2->num_bytes = end_data - start_data;

        ned2 = (EXTENT_DATA2*)newext3->extent_data.data;
        ned2->offset += end_data - ext->offset;
        ned2->num_bytes -= end_data - ext->offset;

        ned2 = (EXTENT_DATA2*)newext2->extent_data.data;
        Status = write_data_complete(fcb->Vcb, ed2->address + ned2->offset, data, (uint32_t)(end_data - start_data), Irp, NULL, file_write, irp_offset, priority);
        if (!NT_SUCCESS(Status)) {
            ERR("write_data_complete returned %08x\n", Status);
            ExFreePool(newext1);
            ExFreePool(newext2);
            ExFreePool(newext3);
            return Status;
        }

        if (!(fcb->inode_item.flags & BTRFS_INODE_NODATASUM)) {
            ULONG sl = (ULONG)((end_data - start_data) / fcb->Vcb->superblock.sector_size);
            uint32_t* csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(uint32_t), ALLOC_TAG);

            if (!csum) {
                ERR("out of memory\n");
                ExFreePool(newext1);
                ExFreePool(newext2);
                ExFreePool(newext3);
                return STATUS_INSUFFICIENT_RESOURCES;
            }

            Status = calc_csum(fcb->Vcb, data, sl, csum);
            if (!NT_SUCCESS(Status)) {
                ERR("calc_csum returned %08x\n", Status);
                ExFreePool(newext1);
                ExFreePool(newext2);
                ExFreePool(newext3);
                ExFreePool(csum);
                return Status;
            }

            newext2->csum = csum;
        } else
            newext2->csum = NULL;

        *written = end_data - start_data;

        newext1->offset = ext->offset;
        newext1->datalen = ext->datalen;
        newext1->unique = ext->unique;
        newext1->ignore = false;
        newext1->inserted = true;
        newext1->csum = NULL;
        InsertHeadList(&ext->list_entry, &newext1->list_entry);

        add_insert_extent_rollback(rollback, fcb, newext1);

        newext2->offset = start_data;
        newext2->datalen = ext->datalen;
        newext2->unique = ext->unique;
        newext2->ignore = false;
        newext2->inserted = true;
        add_extent(fcb, &newext1->list_entry, newext2);

        add_insert_extent_rollback(rollback, fcb, newext2);

        newext3->offset = end_data;
        newext3->datalen = ext->datalen;
        newext3->unique = ext->unique;
        newext3->ignore = false;
        newext3->inserted = true;
        newext3->csum = NULL;
        add_extent(fcb, &newext2->list_entry, newext3);

        add_insert_extent_rollback(rollback, fcb, newext3);

        c = get_chunk_from_address(fcb->Vcb, ed2->address);

        if (!c)
            ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
        else {
            Status = update_changed_extent_ref(fcb->Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, 2,
                                               fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);

            if (!NT_SUCCESS(Status)) {
                ERR("update_changed_extent_ref returned %08x\n", Status);
                return Status;
            }
        }

        remove_fcb_extent(fcb, ext, rollback);
    }

    if (c)
        c->changed = true;

    return STATUS_SUCCESS;
}

Referenced by do_write_file().

excise_extents()

NTSTATUS excise_extents	(	device_extension *	Vcb,
		fcb *	fcb,
		uint64_t	start_data,
		uint64_t	end_data,
		PIRP	Irp,
		LIST_ENTRY *	rollback
	)

Definition at line 2368 of file write.c.

                                                                                                                                 {
    NTSTATUS Status;
    LIST_ENTRY* le;

    le = fcb->extents.Flink;

    while (le != &fcb->extents) {
        LIST_ENTRY* le2 = le->Flink;
        extent* ext = CONTAINING_RECORD(le, extent, list_entry);
        EXTENT_DATA* ed = &ext->extent_data;
        EXTENT_DATA2* ed2 = NULL;
        uint64_t len;

        if (!ext->ignore) {
            if (ed->type != EXTENT_TYPE_INLINE)
                ed2 = (EXTENT_DATA2*)ed->data;

            len = ed->type == EXTENT_TYPE_INLINE ? ed->decoded_size : ed2->num_bytes;

            if (ext->offset < end_data && ext->offset + len > start_data) {
                if (ed->type == EXTENT_TYPE_INLINE) {
                    if (start_data <= ext->offset && end_data >= ext->offset + len) { // remove all
                        remove_fcb_extent(fcb, ext, rollback);

                        fcb->inode_item.st_blocks -= len;
                        fcb->inode_item_changed = true;
                    } else {
                        ERR("trying to split inline extent\n");
#ifdef DEBUG_PARANOID
                        int3;
#endif
                        return STATUS_INTERNAL_ERROR;
                    }
                } else if (ed->type != EXTENT_TYPE_INLINE) {
                    if (start_data <= ext->offset && end_data >= ext->offset + len) { // remove all
                        if (ed2->size != 0) {
                            chunk* c;

                            fcb->inode_item.st_blocks -= len;
                            fcb->inode_item_changed = true;

                            c = get_chunk_from_address(Vcb, ed2->address);

                            if (!c) {
                                ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
                            } else {
                                Status = update_changed_extent_ref(Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, -1,
                                                                   fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
                                if (!NT_SUCCESS(Status)) {
                                    ERR("update_changed_extent_ref returned %08x\n", Status);
                                    goto end;
                                }
                            }
                        }

                        remove_fcb_extent(fcb, ext, rollback);
                    } else if (start_data <= ext->offset && end_data < ext->offset + len) { // remove beginning
                        EXTENT_DATA2* ned2;
                        extent* newext;

                        if (ed2->size != 0) {
                            fcb->inode_item.st_blocks -= end_data - ext->offset;
                            fcb->inode_item_changed = true;
                        }

                        newext = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2), ALLOC_TAG);
                        if (!newext) {
                            ERR("out of memory\n");
                            Status = STATUS_INSUFFICIENT_RESOURCES;
                            goto end;
                        }

                        ned2 = (EXTENT_DATA2*)newext->extent_data.data;

                        newext->extent_data.generation = Vcb->superblock.generation;
                        newext->extent_data.decoded_size = ed->decoded_size;
                        newext->extent_data.compression = ed->compression;
                        newext->extent_data.encryption = ed->encryption;
                        newext->extent_data.encoding = ed->encoding;
                        newext->extent_data.type = ed->type;
                        ned2->address = ed2->address;
                        ned2->size = ed2->size;
                        ned2->offset = ed2->offset + (end_data - ext->offset);
                        ned2->num_bytes = ed2->num_bytes - (end_data - ext->offset);

                        newext->offset = end_data;
                        newext->datalen = sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
                        newext->unique = ext->unique;
                        newext->ignore = false;
                        newext->inserted = true;

                        if (ext->csum) {
                            if (ed->compression == BTRFS_COMPRESSION_NONE) {
                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ned2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                if (!newext->csum) {
                                    ERR("out of memory\n");
                                    Status = STATUS_INSUFFICIENT_RESOURCES;
                                    ExFreePool(newext);
                                    goto end;
                                }

                                RtlCopyMemory(newext->csum, &ext->csum[(end_data - ext->offset) / Vcb->superblock.sector_size],
                                              (ULONG)(ned2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size));
                            } else {
                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                if (!newext->csum) {
                                    ERR("out of memory\n");
                                    Status = STATUS_INSUFFICIENT_RESOURCES;
                                    ExFreePool(newext);
                                    goto end;
                                }

                                RtlCopyMemory(newext->csum, ext->csum, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size));
                            }
                        } else
                            newext->csum = NULL;

                        add_extent(fcb, &ext->list_entry, newext);

                        remove_fcb_extent(fcb, ext, rollback);
                    } else if (start_data > ext->offset && end_data >= ext->offset + len) { // remove end
                        EXTENT_DATA2* ned2;
                        extent* newext;

                        if (ed2->size != 0) {
                            fcb->inode_item.st_blocks -= ext->offset + len - start_data;
                            fcb->inode_item_changed = true;
                        }

                        newext = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2), ALLOC_TAG);
                        if (!newext) {
                            ERR("out of memory\n");
                            Status = STATUS_INSUFFICIENT_RESOURCES;
                            goto end;
                        }

                        ned2 = (EXTENT_DATA2*)newext->extent_data.data;

                        newext->extent_data.generation = Vcb->superblock.generation;
                        newext->extent_data.decoded_size = ed->decoded_size;
                        newext->extent_data.compression = ed->compression;
                        newext->extent_data.encryption = ed->encryption;
                        newext->extent_data.encoding = ed->encoding;
                        newext->extent_data.type = ed->type;
                        ned2->address = ed2->address;
                        ned2->size = ed2->size;
                        ned2->offset = ed2->offset;
                        ned2->num_bytes = start_data - ext->offset;

                        newext->offset = ext->offset;
                        newext->datalen = sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
                        newext->unique = ext->unique;
                        newext->ignore = false;
                        newext->inserted = true;

                        if (ext->csum) {
                            if (ed->compression == BTRFS_COMPRESSION_NONE) {
                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ned2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                if (!newext->csum) {
                                    ERR("out of memory\n");
                                    Status = STATUS_INSUFFICIENT_RESOURCES;
                                    ExFreePool(newext);
                                    goto end;
                                }

                                RtlCopyMemory(newext->csum, ext->csum, (ULONG)(ned2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size));
                            } else {
                                newext->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                if (!newext->csum) {
                                    ERR("out of memory\n");
                                    Status = STATUS_INSUFFICIENT_RESOURCES;
                                    ExFreePool(newext);
                                    goto end;
                                }

                                RtlCopyMemory(newext->csum, ext->csum, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size));
                            }
                        } else
                            newext->csum = NULL;

                        InsertHeadList(&ext->list_entry, &newext->list_entry);

                        remove_fcb_extent(fcb, ext, rollback);
                    } else if (start_data > ext->offset && end_data < ext->offset + len) { // remove middle
                        EXTENT_DATA2 *neda2, *nedb2;
                        extent *newext1, *newext2;

                        if (ed2->size != 0) {
                            chunk* c;

                            fcb->inode_item.st_blocks -= end_data - start_data;
                            fcb->inode_item_changed = true;

                            c = get_chunk_from_address(Vcb, ed2->address);

                            if (!c) {
                                ERR("get_chunk_from_address(%I64x) failed\n", ed2->address);
                            } else {
                                Status = update_changed_extent_ref(Vcb, c, ed2->address, ed2->size, fcb->subvol->id, fcb->inode, ext->offset - ed2->offset, 1,
                                                                   fcb->inode_item.flags & BTRFS_INODE_NODATASUM, false, Irp);
                                if (!NT_SUCCESS(Status)) {
                                    ERR("update_changed_extent_ref returned %08x\n", Status);
                                    goto end;
                                }
                            }
                        }

                        newext1 = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2), ALLOC_TAG);
                        if (!newext1) {
                            ERR("out of memory\n");
                            Status = STATUS_INSUFFICIENT_RESOURCES;
                            goto end;
                        }

                        newext2 = ExAllocatePoolWithTag(PagedPool, offsetof(extent, extent_data) + sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2), ALLOC_TAG);
                        if (!newext2) {
                            ERR("out of memory\n");
                            Status = STATUS_INSUFFICIENT_RESOURCES;
                            ExFreePool(newext1);
                            goto end;
                        }

                        neda2 = (EXTENT_DATA2*)newext1->extent_data.data;

                        newext1->extent_data.generation = Vcb->superblock.generation;
                        newext1->extent_data.decoded_size = ed->decoded_size;
                        newext1->extent_data.compression = ed->compression;
                        newext1->extent_data.encryption = ed->encryption;
                        newext1->extent_data.encoding = ed->encoding;
                        newext1->extent_data.type = ed->type;
                        neda2->address = ed2->address;
                        neda2->size = ed2->size;
                        neda2->offset = ed2->offset;
                        neda2->num_bytes = start_data - ext->offset;

                        nedb2 = (EXTENT_DATA2*)newext2->extent_data.data;

                        newext2->extent_data.generation = Vcb->superblock.generation;
                        newext2->extent_data.decoded_size = ed->decoded_size;
                        newext2->extent_data.compression = ed->compression;
                        newext2->extent_data.encryption = ed->encryption;
                        newext2->extent_data.encoding = ed->encoding;
                        newext2->extent_data.type = ed->type;
                        nedb2->address = ed2->address;
                        nedb2->size = ed2->size;
                        nedb2->offset = ed2->offset + (end_data - ext->offset);
                        nedb2->num_bytes = ext->offset + len - end_data;

                        newext1->offset = ext->offset;
                        newext1->datalen = sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
                        newext1->unique = ext->unique;
                        newext1->ignore = false;
                        newext1->inserted = true;

                        newext2->offset = end_data;
                        newext2->datalen = sizeof(EXTENT_DATA) - 1 + sizeof(EXTENT_DATA2);
                        newext2->unique = ext->unique;
                        newext2->ignore = false;
                        newext2->inserted = true;

                        if (ext->csum) {
                            if (ed->compression == BTRFS_COMPRESSION_NONE) {
                                newext1->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(neda2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                if (!newext1->csum) {
                                    ERR("out of memory\n");
                                    Status = STATUS_INSUFFICIENT_RESOURCES;
                                    ExFreePool(newext1);
                                    ExFreePool(newext2);
                                    goto end;
                                }

                                newext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(nedb2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                if (!newext2->csum) {
                                    ERR("out of memory\n");
                                    Status = STATUS_INSUFFICIENT_RESOURCES;
                                    ExFreePool(newext1->csum);
                                    ExFreePool(newext1);
                                    ExFreePool(newext2);
                                    goto end;
                                }

                                RtlCopyMemory(newext1->csum, ext->csum, (ULONG)(neda2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size));
                                RtlCopyMemory(newext2->csum, &ext->csum[(end_data - ext->offset) / Vcb->superblock.sector_size],
                                              (ULONG)(nedb2->num_bytes * sizeof(uint32_t) / Vcb->superblock.sector_size));
                            } else {
                                newext1->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                if (!newext1->csum) {
                                    ERR("out of memory\n");
                                    Status = STATUS_INSUFFICIENT_RESOURCES;
                                    ExFreePool(newext1);
                                    ExFreePool(newext2);
                                    goto end;
                                }

                                newext2->csum = ExAllocatePoolWithTag(PagedPool, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size), ALLOC_TAG);
                                if (!newext2->csum) {
                                    ERR("out of memory\n");
                                    Status = STATUS_INSUFFICIENT_RESOURCES;
                                    ExFreePool(newext1->csum);
                                    ExFreePool(newext1);
                                    ExFreePool(newext2);
                                    goto end;
                                }

                                RtlCopyMemory(newext1->csum, ext->csum, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size));
                                RtlCopyMemory(newext2->csum, ext->csum, (ULONG)(ed2->size * sizeof(uint32_t) / Vcb->superblock.sector_size));
                            }
                        } else {
                            newext1->csum = NULL;
                            newext2->csum = NULL;
                        }

                        InsertHeadList(&ext->list_entry, &newext1->list_entry);
                        add_extent(fcb, &newext1->list_entry, newext2);

                        remove_fcb_extent(fcb, ext, rollback);
                    }
                }
            }
        }

        le = le2;
    }

    Status = STATUS_SUCCESS;

end:
    fcb->extents_changed = true;
    mark_fcb_dirty(fcb);

    return Status;
}

Referenced by allocate_cache_chunk(), check_for_orphans_root(), delete_fileref_fcb(), do_write_file(), drop_chunk(), duplicate_extents(), extend_file(), load_stored_free_space_cache(), lzo_write_compressed_bit(), remove_free_space_inode(), rename_file_to_stream(), set_zero_data(), truncate_file(), write_file2(), zero_data(), zlib_write_compressed_bit(), and zstd_write_compressed_bit().

ExFreePool()

ExFreePool

(

ed

)

Referenced by _Requires_lock_held_(), add_partial_stripe(), alloc_chunk(), do_write_file_prealloc(), excise_extents(), extend_file(), FatDeferredFlush(), FFSFloppyFlush(), FFSv1WriteInode(), FFSWriteVolume(), free_write_data_stripes(), if(), prepare_raid0_write(), prepare_raid10_write(), prepare_raid5_write(), prepare_raid6_write(), RfsdFloppyFlush(), RfsdWriteInode(), RfsdWriteVolume(), truncate_file(), write_data(), and write_file2().

extend_file()

NTSTATUS extend_file	(	fcb *	fcb,
		file_ref *	fileref,
		uint64_t	end,
		bool	prealloc,
		PIRP	Irp,
		LIST_ENTRY *	rollback
	)

Definition at line 3319 of file write.c.

                                                                                                               {
    uint64_t oldalloc, newalloc;
    bool cur_inline;
    NTSTATUS Status;

    TRACE("(%p, %p, %x, %u)\n", fcb, fileref, end, prealloc);

    if (fcb->ads) {
        if (end > 0xffff)
            return STATUS_DISK_FULL;

        return stream_set_end_of_file_information(fcb->Vcb, (uint16_t)end, fcb, fileref, false);
    } else {
        extent* ext = NULL;
        LIST_ENTRY* le;

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

            if (!ext2->ignore) {
                ext = ext2;
                break;
            }

            le = le->Blink;
        }

        oldalloc = 0;
        if (ext) {
            EXTENT_DATA* ed = &ext->extent_data;
            EXTENT_DATA2* ed2 = (EXTENT_DATA2*)ed->data;

            oldalloc = ext->offset + (ed->type == EXTENT_TYPE_INLINE ? ed->decoded_size : ed2->num_bytes);
            cur_inline = ed->type == EXTENT_TYPE_INLINE;

            if (cur_inline && end > fcb->Vcb->options.max_inline) {
                uint64_t origlength, length;
                uint8_t* data;

                TRACE("giving inline file proper extents\n");

                origlength = ed->decoded_size;

                cur_inline = false;

                length = sector_align(origlength, fcb->Vcb->superblock.sector_size);

                data = ExAllocatePoolWithTag(PagedPool, (ULONG)length, ALLOC_TAG);
                if (!data) {
                    ERR("could not allocate %I64x bytes for data\n", length);
                    return STATUS_INSUFFICIENT_RESOURCES;
                }

                Status = read_file(fcb, data, 0, origlength, NULL, Irp);
                if (!NT_SUCCESS(Status)) {
                    ERR("read_file returned %08x\n", Status);
                    ExFreePool(data);
                    return Status;
                }

                RtlZeroMemory(data + origlength, (ULONG)(length - origlength));

                Status = excise_extents(fcb->Vcb, fcb, 0, fcb->inode_item.st_size, Irp, rollback);
                if (!NT_SUCCESS(Status)) {
                    ERR("excise_extents returned %08x\n", Status);
                    ExFreePool(data);
                    return Status;
                }

                Status = do_write_file(fcb, 0, length, data, Irp, false, 0, rollback);
                if (!NT_SUCCESS(Status)) {
                    ERR("do_write_file returned %08x\n", Status);
                    ExFreePool(data);
                    return Status;
                }

                oldalloc = ext->offset + length;

                ExFreePool(data);
            }

            if (cur_inline) {
                uint16_t edsize;

                if (end > oldalloc) {
                    edsize = (uint16_t)(offsetof(EXTENT_DATA, data[0]) + end - ext->offset);
                    ed = ExAllocatePoolWithTag(PagedPool, edsize, ALLOC_TAG);

                    if (!ed) {
                        ERR("out of memory\n");
                        return STATUS_INSUFFICIENT_RESOURCES;
                    }

                    ed->generation = fcb->Vcb->superblock.generation;
                    ed->decoded_size = end - ext->offset;
                    ed->compression = BTRFS_COMPRESSION_NONE;
                    ed->encryption = BTRFS_ENCRYPTION_NONE;
                    ed->encoding = BTRFS_ENCODING_NONE;
                    ed->type = EXTENT_TYPE_INLINE;

                    Status = read_file(fcb, ed->data, ext->offset, oldalloc, NULL, Irp);
                    if (!NT_SUCCESS(Status)) {
                        ERR("read_file returned %08x\n", Status);
                        ExFreePool(ed);
                        return Status;
                    }

                    RtlZeroMemory(ed->data + oldalloc - ext->offset, (ULONG)(end - oldalloc));

                    remove_fcb_extent(fcb, ext, rollback);

                    Status = add_extent_to_fcb(fcb, ext->offset, ed, edsize, ext->unique, NULL, rollback);
                    if (!NT_SUCCESS(Status)) {
                        ERR("add_extent_to_fcb returned %08x\n", Status);
                        ExFreePool(ed);
                        return Status;
                    }

                    ExFreePool(ed);

                    fcb->extents_changed = true;
                    mark_fcb_dirty(fcb);
                }

                TRACE("extending inline file (oldalloc = %I64x, end = %I64x)\n", oldalloc, end);

                fcb->inode_item.st_size = end;
                TRACE("setting st_size to %I64x\n", end);

                fcb->inode_item.st_blocks = end;

                fcb->Header.AllocationSize.QuadPart = fcb->Header.FileSize.QuadPart = fcb->Header.ValidDataLength.QuadPart = end;
            } else {
                newalloc = sector_align(end, fcb->Vcb->superblock.sector_size);

                if (newalloc > oldalloc) {
                    if (prealloc) {
                        // FIXME - try and extend previous extent first

                        Status = insert_prealloc_extent(fcb, oldalloc, newalloc - oldalloc, rollback);

                        if (!NT_SUCCESS(Status)) {
                            ERR("insert_prealloc_extent returned %08x\n", Status);
                            return Status;
                        }
                    }

                    fcb->extents_changed = true;
                }

                fcb->inode_item.st_size = end;
                fcb->inode_item_changed = true;
                mark_fcb_dirty(fcb);

                TRACE("setting st_size to %I64x\n", end);

                TRACE("newalloc = %I64x\n", newalloc);

                fcb->Header.AllocationSize.QuadPart = newalloc;
                fcb->Header.FileSize.QuadPart = fcb->Header.ValidDataLength.QuadPart = end;
            }
        } else {
            if (end > fcb->Vcb->options.max_inline) {
                newalloc = sector_align(end, fcb->Vcb->superblock.sector_size);

                if (prealloc) {
                    Status = insert_prealloc_extent(fcb, 0, newalloc, rollback);

                    if (!NT_SUCCESS(Status)) {
                        ERR("insert_prealloc_extent returned %08x\n", Status);
                        return Status;
                    }
                }

                fcb->extents_changed = true;
                fcb->inode_item_changed = true;
                mark_fcb_dirty(fcb);

                fcb->inode_item.st_size = end;
                TRACE("setting st_size to %I64x\n", end);

                TRACE("newalloc = %I64x\n", newalloc);

                fcb->Header.AllocationSize.QuadPart = newalloc;
                fcb->Header.FileSize.QuadPart = fcb->Header.ValidDataLength.QuadPart = end;
            } else {
                EXTENT_DATA* ed;
                uint16_t edsize;

                edsize = (uint16_t)(offsetof(EXTENT_DATA, data[0]) + end);
                ed = ExAllocatePoolWithTag(PagedPool, edsize, ALLOC_TAG);

                if (!ed) {
                    ERR("out of memory\n");
                    return STATUS_INSUFFICIENT_RESOURCES;
                }

                ed->generation = fcb->Vcb->superblock.generation;
                ed->decoded_size = end;
                ed->compression = BTRFS_COMPRESSION_NONE;
                ed->encryption = BTRFS_ENCRYPTION_NONE;
                ed->encoding = BTRFS_ENCODING_NONE;
                ed->type = EXTENT_TYPE_INLINE;

                RtlZeroMemory(ed->data, (ULONG)end);

                Status = add_extent_to_fcb(fcb, 0, ed, edsize, false, NULL, rollback);
                if (!NT_SUCCESS(Status)) {
                    ERR("add_extent_to_fcb returned %08x\n", Status);
                    ExFreePool(ed);
                    return Status;
                }

                ExFreePool(ed);

                fcb->extents_changed = true;
                fcb->inode_item_changed = true;
                mark_fcb_dirty(fcb);

                fcb->inode_item.st_size = end;
                TRACE("setting st_size to %I64x\n", end);

                fcb->inode_item.st_blocks = end;

                fcb->Header.AllocationSize.QuadPart = fcb->Header.FileSize.QuadPart = fcb->Header.ValidDataLength.QuadPart = end;
            }
        }
    }

    return STATUS_SUCCESS;
}

Referenced by file_create2(), open_file2(), set_end_of_file_information(), and write_file2().

find_new_chunk_address()

static uint64_t find_new_chunk_address ( device_extension *  Vcb, uint64_t  size  )

static

Definition at line 116 of file write.c.

                                                                             {
    uint64_t lastaddr;
    LIST_ENTRY* le;

    lastaddr = 0xc00000;

    le = Vcb->chunks.Flink;
    while (le != &Vcb->chunks) {
        chunk* c = CONTAINING_RECORD(le, chunk, list_entry);

        if (c->offset >= lastaddr + size)
            return lastaddr;

        lastaddr = c->offset + c->chunk_item->size;

        le = le->Flink;
    }

    return lastaddr;
}

Referenced by alloc_chunk().

find_new_dup_stripes()

static bool find_new_dup_stripes ( device_extension *  Vcb, stripe *  stripes, uint64_t  max_stripe_size, bool  full_size  )

static

Definition at line 137 of file write.c.

                                                                                                                   {
    uint64_t devusage = 0xffffffffffffffff;
    space *devdh1 = NULL, *devdh2 = NULL;
    LIST_ENTRY* le;
    device* dev2 = NULL;

    le = Vcb->devices.Flink;

    while (le != &Vcb->devices) {
        device* dev = CONTAINING_RECORD(le, device, list_entry);

        if (!dev->readonly && !dev->reloc && dev->devobj) {
            uint64_t usage = (dev->devitem.bytes_used * 4096) / dev->devitem.num_bytes;

            // favour devices which have been used the least
            if (usage < devusage) {
                if (!IsListEmpty(&dev->space)) {
                    LIST_ENTRY* le2;
                    space *dh1 = NULL, *dh2 = NULL;

                    le2 = dev->space.Flink;
                    while (le2 != &dev->space) {
                        space* dh = CONTAINING_RECORD(le2, space, list_entry);

                        if (dh->size >= max_stripe_size && (!dh1 || !dh2 || dh->size < dh1->size)) {
                            dh2 = dh1;
                            dh1 = dh;
                        }

                        le2 = le2->Flink;
                    }

                    if (dh1 && (dh2 || dh1->size >= 2 * max_stripe_size)) {
                        dev2 = dev;
                        devusage = usage;
                        devdh1 = dh1;
                        devdh2 = dh2 ? dh2 : dh1;
                    }
                }
            }
        }

        le = le->Flink;
    }

    if (!devdh1) {
        uint64_t size = 0;

        // Can't find hole of at least max_stripe_size; look for the largest one we can find

        if (full_size)
            return false;

        le = Vcb->devices.Flink;
        while (le != &Vcb->devices) {
            device* dev = CONTAINING_RECORD(le, device, list_entry);

            if (!dev->readonly && !dev->reloc) {
                if (!IsListEmpty(&dev->space)) {
                    LIST_ENTRY* le2;
                    space *dh1 = NULL, *dh2 = NULL;

                    le2 = dev->space.Flink;
                    while (le2 != &dev->space) {
                        space* dh = CONTAINING_RECORD(le2, space, list_entry);

                        if (!dh1 || !dh2 || dh->size < dh1->size) {
                            dh2 = dh1;
                            dh1 = dh;
                        }

                        le2 = le2->Flink;
                    }

                    if (dh1) {
                        uint64_t devsize;

                        if (dh2)
                            devsize = max(dh1->size / 2, min(dh1->size, dh2->size));
                        else
                            devsize = dh1->size / 2;

                        if (devsize > size) {
                            dev2 = dev;
                            devdh1 = dh1;

                            if (dh2 && min(dh1->size, dh2->size) > dh1->size / 2)
                                devdh2 = dh2;
                            else
                                devdh2 = dh1;

                            size = devsize;
                        }
                    }
                }
            }

            le = le->Flink;
        }

        if (!devdh1)
            return false;
    }

    stripes[0].device = stripes[1].device = dev2;
    stripes[0].dh = devdh1;
    stripes[1].dh = devdh2;

    return true;
}

Referenced by alloc_chunk().

find_new_stripe()

static bool find_new_stripe ( device_extension *  Vcb, stripe *  stripes, uint16_t  i, uint64_t  max_stripe_size, bool  allow_missing, bool  full_size  )

static

Definition at line 248 of file write.c.

                                                                                                                                              {
    uint64_t k, devusage = 0xffffffffffffffff;
    space* devdh = NULL;
    LIST_ENTRY* le;
    device* dev2 = NULL;

    le = Vcb->devices.Flink;
    while (le != &Vcb->devices) {
        device* dev = CONTAINING_RECORD(le, device, list_entry);
        uint64_t usage;
        bool skip = false;

        if (dev->readonly || dev->reloc || (!dev->devobj && !allow_missing)) {
            le = le->Flink;
            continue;
        }

        // skip this device if it already has a stripe
        if (i > 0) {
            for (k = 0; k < i; k++) {
                if (stripes[k].device == dev) {
                    skip = true;
                    break;
                }
            }
        }

        if (!skip) {
            usage = (dev->devitem.bytes_used * 4096) / dev->devitem.num_bytes;

            // favour devices which have been used the least
            if (usage < devusage) {
                if (!IsListEmpty(&dev->space)) {
                    LIST_ENTRY* le2;

                    le2 = dev->space.Flink;
                    while (le2 != &dev->space) {
                        space* dh = CONTAINING_RECORD(le2, space, list_entry);

                        if ((dev2 != dev && dh->size >= max_stripe_size) ||
                            (dev2 == dev && dh->size >= max_stripe_size && dh->size < devdh->size)
                        ) {
                            devdh = dh;
                            dev2 = dev;
                            devusage = usage;
                        }

                        le2 = le2->Flink;
                    }
                }
            }
        }

        le = le->Flink;
    }

    if (!devdh) {
        // Can't find hole of at least max_stripe_size; look for the largest one we can find

        if (full_size)
            return false;

        le = Vcb->devices.Flink;
        while (le != &Vcb->devices) {
            device* dev = CONTAINING_RECORD(le, device, list_entry);
            bool skip = false;

            if (dev->readonly || dev->reloc || (!dev->devobj && !allow_missing)) {
                le = le->Flink;
                continue;
            }

            // skip this device if it already has a stripe
            if (i > 0) {
                for (k = 0; k < i; k++) {
                    if (stripes[k].device == dev) {
                        skip = true;
                        break;
                    }
                }
            }

            if (!skip) {
                if (!IsListEmpty(&dev->space)) {
                    LIST_ENTRY* le2;

                    le2 = dev->space.Flink;
                    while (le2 != &dev->space) {
                        space* dh = CONTAINING_RECORD(le2, space, list_entry);

                        if (!devdh || devdh->size < dh->size) {
                            devdh = dh;
                            dev2 = dev;
                        }

                        le2 = le2->Flink;
                    }
                }
            }

            le = le->Flink;
        }

        if (!devdh)
            return false;
    }

    stripes[i].dh = devdh;
    stripes[i].device = dev2;

    return true;
}

Referenced by alloc_chunk().

free_write_data_stripes()

void free_write_data_stripes

(

write_data_context *

wtc

)

Definition at line 2291 of file write.c.

                                                      {
    LIST_ENTRY* le;
    PMDL last_mdl = NULL;

    if (wtc->parity1_mdl) {
        if (wtc->parity1_mdl->MdlFlags & MDL_PAGES_LOCKED)
            MmUnlockPages(wtc->parity1_mdl);

        IoFreeMdl(wtc->parity1_mdl);
    }

    if (wtc->parity2_mdl) {
        if (wtc->parity2_mdl->MdlFlags & MDL_PAGES_LOCKED)
            MmUnlockPages(wtc->parity2_mdl);

        IoFreeMdl(wtc->parity2_mdl);
    }

    if (wtc->mdl) {
        if (wtc->mdl->MdlFlags & MDL_PAGES_LOCKED)
            MmUnlockPages(wtc->mdl);

        IoFreeMdl(wtc->mdl);
    }

    if (wtc->parity1)
        ExFreePool(wtc->parity1);

    if (wtc->parity2)
        ExFreePool(wtc->parity2);

    if (wtc->scratch)
        ExFreePool(wtc->scratch);

    le = wtc->stripes.Flink;
    while (le != &wtc->stripes) {
        write_data_stripe* stripe = CONTAINING_RECORD(le, write_data_stripe, list_entry);

        if (stripe->mdl && stripe->mdl != last_mdl) {
            if (stripe->mdl->MdlFlags & MDL_PAGES_LOCKED)
                MmUnlockPages(stripe->mdl);

            IoFreeMdl(stripe->mdl);
        }

        last_mdl = stripe->mdl;

        if (stripe->Irp)
            IoFreeIrp(stripe->Irp);

        le = le->Flink;
    }

    while (!IsListEmpty(&wtc->stripes)) {
        write_data_stripe* stripe = CONTAINING_RECORD(RemoveHeadList(&wtc->stripes), write_data_stripe, list_entry);

        ExFreePool(stripe);
    }
}

Referenced by do_tree_writes(), snapshot_tree_copy(), write_data(), and write_data_complete().

get_chunk_from_address()

chunk* get_chunk_from_address	(	device_extension *	Vcb,
		uint64_t	address
	)

Definition at line 89 of file write.c.

                                                                       {
    LIST_ENTRY* le2;

    ExAcquireResourceSharedLite(&Vcb->chunk_lock, true);

    le2 = Vcb->chunks.Flink;
    while (le2 != &Vcb->chunks) {
        chunk* c = CONTAINING_RECORD(le2, chunk, list_entry);

        if (address >= c->offset && address < c->offset + c->chunk_item->size) {
            ExReleaseResourceLite(&Vcb->chunk_lock);
            return c;
        }

        le2 = le2->Flink;
    }

    ExReleaseResourceLite(&Vcb->chunk_lock);

    return NULL;
}

Referenced by add_data_reloc(), add_metadata_reloc(), add_metadata_reloc_extent_item(), allocate_cache_chunk(), allocate_tree_extents(), do_rollback(), do_tree_writes(), do_write_file(), do_write_file_prealloc(), duplicate_extents(), excise_extents(), flush_fcb(), get_tree_new_address(), move_across_subvols(), rationalize_extents(), read_data(), read_file(), reduce_tree_extent(), snapshot_tree_copy(), try_extend_data(), update_tree_extents(), write_data(), and write_data_complete().

get_raid56_lock_range()

void get_raid56_lock_range	(	chunk *	c,
		uint64_t	address,
		uint64_t	length,
		uint64_t *	lockaddr,
		uint64_t *	locklen
	)

Definition at line 2150 of file write.c.

                                                                                                               {
    uint64_t startoff, endoff;
    uint16_t startoffstripe, endoffstripe, datastripes;

    datastripes = c->chunk_item->num_stripes - (c->chunk_item->type & BLOCK_FLAG_RAID5 ? 1 : 2);

    get_raid0_offset(address - c->offset, c->chunk_item->stripe_length, datastripes, &startoff, &startoffstripe);
    get_raid0_offset(address + length - c->offset - 1, c->chunk_item->stripe_length, datastripes, &endoff, &endoffstripe);

    startoff -= startoff % c->chunk_item->stripe_length;
    endoff = sector_align(endoff, c->chunk_item->stripe_length);

    *lockaddr = c->offset + (startoff * datastripes);
    *locklen = (endoff - startoff) * datastripes;
}

Referenced by read_data(), and write_data_complete().

if() [1/5]

if

(

!

find_data_address_in_chunkVcb, c, length, &address

)

Referenced by _Requires_lock_held_(), do_write_file(), do_write_file_prealloc(), excise_extents(), Ext2Write(), Ext2ZeroData(), FFSWrite(), find_new_dup_stripes(), find_new_stripe(), prepare_raid0_write(), prepare_raid10_write(), prepare_raid5_write(), prepare_raid6_write(), RfsdWrite(), RfsdWriteInode(), try_extend_data(), and write_data().

if() [2/5]

if

(

!

ed

)

Definition at line 2830 of file write.c.

             {
        ERR("out of memory\n");
        return false;
    }

if() [3/5]

if

(

!prealloc &&data &&!

fcb->inode_item.flags &BTRFS_INODE_NODATASUM

)

Definition at line 2848 of file write.c.

                                                                               {
        ULONG sl = (ULONG)(length / Vcb->superblock.sector_size);

        csum = ExAllocatePoolWithTag(PagedPool, sl * sizeof(uint32_t), ALLOC_TAG);
        if (!csum) {
            ERR("out of memory\n");
            ExFreePool(ed);
            return false;
        }

        Status = calc_csum(Vcb, data, sl, csum);
        if (!NT_SUCCESS(Status)) {
            ERR("calc_csum returned %08x\n", Status);
            ExFreePool(csum);
            ExFreePool(ed);
            return false;
        }
    }

if() [4/5]

if

(

!

NT_SUCCESSStatus

)

Definition at line 2868 of file write.c.

                             {
        ERR("add_extent_to_fcb returned %08x\n", Status);
        if (csum) ExFreePool(csum);
        ExFreePool(ed);
        return false;
    }

if() [5/5]

if

(

data

)

Definition at line 2894 of file write.c.

              {
        Status = write_data_complete(Vcb, address, data, (uint32_t)length, Irp, NULL, file_write, irp_offset,
                                     fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE ? HighPagePriority : NormalPagePriority);
        if (!NT_SUCCESS(Status))
            ERR("write_data_complete returned %08x\n", Status);
    }

insert_chunk_fragmented()

static NTSTATUS insert_chunk_fragmented ( fcb *  fcb, uint64_t  start, uint64_t  length, uint8_t *  data, bool  prealloc, LIST_ENTRY *  rollback  )

static

Definition at line 2996 of file write.c.

                                                                                                                                       {
    LIST_ENTRY* le;
    uint64_t flags = fcb->Vcb->data_flags;
    bool page_file = fcb->Header.Flags2 & FSRTL_FLAG2_IS_PAGING_FILE;
    NTSTATUS Status;
    chunk* c;

    ExAcquireResourceSharedLite(&fcb->Vcb->chunk_lock, true);

    // first create as many chunks as we can
    do {
        Status = alloc_chunk(fcb->Vcb, flags, &c, false);
    } while (NT_SUCCESS(Status));

    if (Status != STATUS_DISK_FULL) {
        ERR("alloc_chunk returned %08x\n", Status);
        ExReleaseResourceLite(&fcb->Vcb->chunk_lock);
        return Status;
    }

    le = fcb->Vcb->chunks.Flink;
    while (le != &fcb->Vcb->chunks) {
        c = CONTAINING_RECORD(le, chunk, list_entry);

        if (!