Merge tag 'for-4.21-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux

}

/*

 * We maintain three seperate rbtrees: one for direct refs, one for

 * We maintain three separate rbtrees: one for direct refs, one for

 * indirect refs which have a key, and one for indirect refs which do not

 * have a key. Each tree does merge on insertion.

 *

		}

		/*

		 * Now it's a direct ref, put it in the the direct tree. We must

		 * Now it's a direct ref, put it in the direct tree. We must

		 * do this last because the ref could be merged/freed here.

		 */

		prelim_ref_insert(fs_info, &preftrees->direct, ref, NULL);

			ret = -ENOMEM;

			break;

		}

		extent_buffer_get(eb);

		btrfs_tree_read_lock(eb);

		btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);

		btrfs_release_path(path);

		item = btrfs_item_nr(slot);

			len = sizeof(*iref) + name_len;

			iref = (struct btrfs_inode_ref *)((char *)iref + len);

		}

		btrfs_tree_read_unlock_blocking(eb);

		free_extent_buffer(eb);

	}

			ret = -ENOMEM;

			break;

		}

		extent_buffer_get(eb);

		btrfs_tree_read_lock(eb);

		btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);

		btrfs_release_path(path);

		item_size = btrfs_item_size_nr(eb, slot);

			cur_offset += btrfs_inode_extref_name_len(eb, extref);

			cur_offset += sizeof(*extref);

		}

		btrfs_tree_read_unlock_blocking(eb);

		free_extent_buffer(eb);

		offset++;

 * new data the application may have written before commit.

 */

enum {

	BTRFS_INODE_ORDERED_DATA_CLOSE = 0,

	BTRFS_INODE_ORDERED_DATA_CLOSE,

	BTRFS_INODE_DUMMY,

	BTRFS_INODE_IN_DEFRAG,

	BTRFS_INODE_HAS_ASYNC_EXTENT,

	BTRFS_INODE_IN_DELALLOC_LIST,

	BTRFS_INODE_READDIO_NEED_LOCK,

	BTRFS_INODE_HAS_PROPS,

	BTRFS_INODE_SNAPSHOT_FLUSH,

};

/* in memory btrfs inode */

	 */

	u64 last_unlink_trans;

	/*

	 * Track the transaction id of the last transaction used to create a

	 * hard link for the inode. This is used by the log tree (fsync).

	 */

	u64 last_link_trans;

	/*

	 * Number of bytes outstanding that are going to need csums.  This is

	 * used in ENOSPC accounting.

	return false;

}

static inline bool is_data_inode(struct inode *inode)

{

	return btrfs_ino(BTRFS_I(inode)) != BTRFS_BTREE_INODE_OBJECTID;

}

static inline void btrfs_mod_outstanding_extents(struct btrfs_inode *inode,

						 int mod)

{

	void *dstv, u32 offset, size_t len)

{

	size_t cur;

	size_t offset_in_page;

	size_t pgoff;

	char *kaddr;

	char *dst = (char *)dstv;

	size_t start_offset = block_ctx->start & ((u64)PAGE_SIZE - 1);

	size_t start_offset = offset_in_page(block_ctx->start);

	unsigned long i = (start_offset + offset) >> PAGE_SHIFT;

	WARN_ON(offset + len > block_ctx->len);

	offset_in_page = (start_offset + offset) & (PAGE_SIZE - 1);

	pgoff = offset_in_page(start_offset + offset);

	while (len > 0) {

		cur = min(len, ((size_t)PAGE_SIZE - offset_in_page));

		cur = min(len, ((size_t)PAGE_SIZE - pgoff));

		BUG_ON(i >= DIV_ROUND_UP(block_ctx->len, PAGE_SIZE));

		kaddr = block_ctx->datav[i];

		memcpy(dst, kaddr + offset_in_page, cur);

		memcpy(dst, kaddr + pgoff, cur);

		dst += cur;

		len -= cur;

		offset_in_page = 0;

		pgoff = 0;

		i++;

	}

}

	BUG_ON(block_ctx->datav);

	BUG_ON(block_ctx->pagev);

	BUG_ON(block_ctx->mem_to_free);

	if (block_ctx->dev_bytenr & ((u64)PAGE_SIZE - 1)) {

	if (!PAGE_ALIGNED(block_ctx->dev_bytenr)) {

		pr_info("btrfsic: read_block() with unaligned bytenr %llu\n",

		       block_ctx->dev_bytenr);

		return -1;

	num_pages = state->metablock_size >> PAGE_SHIFT;

	h = (struct btrfs_header *)datav[0];

	if (memcmp(h->fsid, fs_info->fsid, BTRFS_FSID_SIZE))

	if (memcmp(h->fsid, fs_info->fs_devices->fsid, BTRFS_FSID_SIZE))

		return 1;

	for (i = 0; i < num_pages; i++) {

				return;

			}

			is_metadata = 1;

			BUG_ON(BTRFS_SUPER_INFO_SIZE & (PAGE_SIZE - 1));

			BUG_ON(!PAGE_ALIGNED(BTRFS_SUPER_INFO_SIZE));

			processed_len = BTRFS_SUPER_INFO_SIZE;

			if (state->print_mask &

			    BTRFSIC_PRINT_MASK_TREE_BEFORE_SB_WRITE) {

		 * write operations. Therefore it keeps the linkage

		 * information for a block until a block is

		 * rewritten. This can temporarily cause incorrect

		 * and even circular linkage informations. This

		 * and even circular linkage information. This

		 * causes no harm unless such blocks are referenced

		 * by the most recent super block.

		 */

	struct list_head *dev_head = &fs_devices->devices;

	struct btrfs_device *device;

	if (fs_info->nodesize & ((u64)PAGE_SIZE - 1)) {

	if (!PAGE_ALIGNED(fs_info->nodesize)) {

		pr_info("btrfsic: cannot handle nodesize %d not being a multiple of PAGE_SIZE %ld!\n",

		       fs_info->nodesize, PAGE_SIZE);

		return -1;

	}

	if (fs_info->sectorsize & ((u64)PAGE_SIZE - 1)) {

	if (!PAGE_ALIGNED(fs_info->sectorsize)) {

		pr_info("btrfsic: cannot handle sectorsize %d not being a multiple of PAGE_SIZE %ld!\n",

		       fs_info->sectorsize, PAGE_SIZE);

		return -1;

 */

static void end_compressed_bio_write(struct bio *bio)

{

	struct extent_io_tree *tree;

	struct compressed_bio *cb = bio->bi_private;

	struct inode *inode;

	struct page *page;

	 * call back into the FS and do all the end_io operations

	 */

	inode = cb->inode;

	tree = &BTRFS_I(inode)->io_tree;

	cb->compressed_pages[0]->mapping = cb->inode->i_mapping;

	tree->ops->writepage_end_io_hook(cb->compressed_pages[0],

					 cb->start,

					 cb->start + cb->len - 1,

					 NULL,

					 bio->bi_status ?

					 BLK_STS_OK : BLK_STS_NOTSUPP);

	btrfs_writepage_endio_finish_ordered(cb->compressed_pages[0],

			cb->start, cb->start + cb->len - 1,

			bio->bi_status ? BLK_STS_OK : BLK_STS_NOTSUPP);

	cb->compressed_pages[0]->mapping = NULL;

	end_compressed_writeback(inode, cb);

	blk_status_t ret;

	int skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;

	WARN_ON(start & ((u64)PAGE_SIZE - 1));

	WARN_ON(!PAGE_ALIGNED(start));

	cb = kmalloc(compressed_bio_size(fs_info, compressed_len), GFP_NOFS);

	if (!cb)

		return BLK_STS_RESOURCE;

		page = compressed_pages[pg_index];

		page->mapping = inode->i_mapping;

		if (bio->bi_iter.bi_size)

			submit = btrfs_merge_bio_hook(page, 0, PAGE_SIZE, bio, 0);

			submit = btrfs_bio_fits_in_stripe(page, PAGE_SIZE, bio,

							  0);

		page->mapping = NULL;

		if (submit || bio_add_page(bio, page, PAGE_SIZE, 0) <

		if (page->index == end_index) {

			char *userpage;

			size_t zero_offset = isize & (PAGE_SIZE - 1);

			size_t zero_offset = offset_in_page(isize);

			if (zero_offset) {

				int zeros;

		page->index = em_start >> PAGE_SHIFT;

		if (comp_bio->bi_iter.bi_size)

			submit = btrfs_merge_bio_hook(page, 0, PAGE_SIZE,

			submit = btrfs_bio_fits_in_stripe(page, PAGE_SIZE,

							  comp_bio, 0);

		page->mapping = NULL;

/*

 * Shannon Entropy calculation

 *

 * Pure byte distribution analysis fails to determine compressiability of data.

 * Pure byte distribution analysis fails to determine compressibility of data.

 * Try calculating entropy to estimate the average minimum number of bits

 * needed to encode the sampled data.

 *

/*

 * Use 4 bits as radix base

 * Use 16 u32 counters for calculating new possition in buf array

 * Use 16 u32 counters for calculating new position in buf array

 *

 * @array     - array that will be sorted

 * @array_buf - buffer array to store sorting results

#include "transaction.h"

#include "print-tree.h"

#include "locking.h"

#include "volumes.h"

static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root

		      *root, struct btrfs_path *path, int level);

	else

		btrfs_set_header_owner(cow, new_root_objectid);

	write_extent_buffer_fsid(cow, fs_info->fsid);

	write_extent_buffer_fsid(cow, fs_info->fs_devices->metadata_uuid);

	WARN_ON(btrfs_header_generation(buf) > trans->transid);

	if (new_root_objectid == BTRFS_TREE_RELOC_OBJECTID)

	else

		btrfs_set_header_owner(cow, root->root_key.objectid);

	write_extent_buffer_fsid(cow, fs_info->fsid);

	write_extent_buffer_fsid(cow, fs_info->fs_devices->metadata_uuid);

	ret = update_ref_for_cow(trans, root, buf, cow, &last_ref);

	if (ret) {

	btrfs_tree_read_unlock_blocking(eb);

	free_extent_buffer(eb);

	extent_buffer_get(eb_rewin);

	btrfs_tree_read_lock(eb_rewin);

	__tree_mod_log_rewind(fs_info, eb_rewin, time_seq, tm);

	WARN_ON(btrfs_header_nritems(eb_rewin) >

	if (!eb)

		return NULL;

	extent_buffer_get(eb);

	btrfs_tree_read_lock(eb);

	if (old_root) {

		btrfs_set_header_bytenr(eb, eb->start);

	 *

	 * What is forced COW:

	 *    when we create snapshot during committing the transaction,

	 *    after we've finished coping src root, we must COW the shared

	 *    after we've finished copying src root, we must COW the shared

	 *    block to ensure the metadata consistency.

	 */

	if (btrfs_header_generation(buf) == trans->transid &&

	u64 search_start;

	int ret;

	if (test_bit(BTRFS_ROOT_DELETING, &root->state))

		btrfs_err(fs_info,

			"COW'ing blocks on a fs root that's being dropped");

	if (trans->transaction != fs_info->running_transaction)

		WARN(1, KERN_CRIT "trans %llu running %llu\n",

		       trans->transid,

	root_lock = BTRFS_READ_LOCK;

	if (p->search_commit_root) {

		/* The commit roots are read only so we always do read locks */

		if (p->need_commit_sem)

		/*

		 * The commit roots are read only so we always do read locks,

		 * and we always must hold the commit_root_sem when doing

		 * searches on them, the only exception is send where we don't

		 * want to block transaction commits for a long time, so

		 * we need to clone the commit root in order to avoid races

		 * with transaction commits that create a snapshot of one of

		 * the roots used by a send operation.

		 */

		if (p->need_commit_sem) {

			down_read(&fs_info->commit_root_sem);

			b = btrfs_clone_extent_buffer(root->commit_root);

			up_read(&fs_info->commit_root_sem);

			if (!b)

				return ERR_PTR(-ENOMEM);

		} else {

			b = root->commit_root;

			extent_buffer_get(b);

		}

		level = btrfs_header_level(b);

		if (p->need_commit_sem)

			up_read(&fs_info->commit_root_sem);

		/*

		 * Ensure that all callers have set skip_locking when

		 * p->search_commit_root = 1.

again:

	prev_cmp = -1;

	b = btrfs_search_slot_get_root(root, p, write_lock_level);

	if (IS_ERR(b)) {

		ret = PTR_ERR(b);

		goto done;

	}

	while (b) {

		level = btrfs_header_level(b);

		/* Key greater than all keys in the leaf, right neighbor has

		 * enough room for it and we're not emptying our leaf to delete

		 * it, therefore use right neighbor to insert the new item and

		 * no need to touch/dirty our left leaft. */

		 * no need to touch/dirty our left leaf. */

		btrfs_tree_unlock(left);

		free_extent_buffer(left);

		path->nodes[0] = right;

		ret = -ENOMEM;

		goto out;

	}

	extent_buffer_get(left_path->nodes[left_level]);

	right_level = btrfs_header_level(right_root->commit_root);

	right_root_level = right_level;

		ret = -ENOMEM;

		goto out;

	}

	extent_buffer_get(right_path->nodes[right_level]);

	up_read(&fs_info->commit_root_sem);

	if (left_level == 0)