Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable

 */

static void end_compressed_bio_read(struct bio *bio, int err)

{

	struct extent_io_tree *tree;

	struct compressed_bio *cb = bio->bi_private;

	struct inode *inode;

	struct page *page;

	/* ok, we're the last bio for this extent, lets start

	 * the decompression.

	 */

	tree = &BTRFS_I(inode)->io_tree;

	ret = btrfs_zlib_decompress_biovec(cb->compressed_pages,

					cb->start,

					cb->orig_bio->bi_io_vec,

		      struct extent_buffer **cow_ret, u64 new_root_objectid)

{

	struct extent_buffer *cow;

	u32 nritems;

	int ret = 0;

	int level;

	struct btrfs_disk_key disk_key;

	WARN_ON(root->ref_cows && trans->transid != root->last_trans);

	level = btrfs_header_level(buf);

	nritems = btrfs_header_nritems(buf);

	if (level == 0)

		btrfs_item_key(buf, &disk_key, 0);

	else

	int wret;

	int pslot;

	int orig_slot = path->slots[level];

	int err_on_enospc = 0;

	u64 orig_ptr;

	if (level == 0)

	    BTRFS_NODEPTRS_PER_BLOCK(root) / 4)

		return 0;

	if (btrfs_header_nritems(mid) < 2)

		err_on_enospc = 1;

	btrfs_header_nritems(mid);

	left = read_node_slot(root, parent, pslot - 1);

	if (left) {

		wret = push_node_left(trans, root, left, mid, 1);

		if (wret < 0)

			ret = wret;

		if (btrfs_header_nritems(mid) < 2)

			err_on_enospc = 1;

		btrfs_header_nritems(mid);

	}

	/*

	int wret;

	int pslot;

	int orig_slot = path->slots[level];

	u64 orig_ptr;

	if (level == 0)

		return 1;

	mid = path->nodes[level];

	WARN_ON(btrfs_header_generation(mid) != trans->transid);

	orig_ptr = btrfs_node_blockptr(mid, orig_slot);

	if (level < BTRFS_MAX_LEVEL - 1)

		parent = path->nodes[level + 1];

	blocksize = btrfs_level_size(root, level - 1);

	tmp = btrfs_find_tree_block(root, blocknr, blocksize);

	if (tmp && btrfs_buffer_uptodate(tmp, gen)) {

	if (tmp) {

		if (btrfs_buffer_uptodate(tmp, 0)) {

			if (btrfs_buffer_uptodate(tmp, gen)) {

				/*

		 * we found an up to date block without sleeping, return

				 * we found an up to date block without

				 * sleeping, return

				 * right away

				 */

				*eb_ret = tmp;

				return 0;

			}

			/* the pages were up to date, but we failed

			 * the generation number check.  Do a full

			 * read for the generation number that is correct.

			 * We must do this without dropping locks so

			 * we can trust our generation number

			 */

			free_extent_buffer(tmp);

			tmp = read_tree_block(root, blocknr, blocksize, gen);

			if (tmp && btrfs_buffer_uptodate(tmp, gen)) {

				*eb_ret = tmp;

				return 0;

			}

			free_extent_buffer(tmp);

			btrfs_release_path(NULL, p);

			return -EIO;

		}

	}

	/*

	 * reduce lock contention at high levels

	btrfs_unlock_up_safe(p, level + 1);

	btrfs_set_path_blocking(p);

	if (tmp)

	free_extent_buffer(tmp);

	if (p->reada)

		reada_for_search(root, p, level, slot, key->objectid);

{

	struct btrfs_disk_key disk_key;

	struct extent_buffer *right = path->nodes[0];

	int slot;

	int i;

	int push_space = 0;

	int push_items = 0;

	u32 this_item_size;

	u32 old_left_item_size;

	slot = path->slots[1];

	if (empty)

		nr = min(right_nritems, max_slot);

	else

{

	int ret = 0;

	int slot;

	int slot_orig;

	struct extent_buffer *leaf;

	struct btrfs_item *item;

	u32 nritems;

	unsigned int size_diff;

	int i;

	slot_orig = path->slots[0];

	leaf = path->nodes[0];

	slot = path->slots[0];

{

	int ret = 0;

	int slot;

	int slot_orig;

	struct extent_buffer *leaf;

	struct btrfs_item *item;

	u32 nritems;

	unsigned int old_size;

	int i;

	slot_orig = path->slots[0];

	leaf = path->nodes[0];

	nritems = btrfs_header_nritems(leaf);

			    struct btrfs_key *cpu_key, u32 *data_size,

			    int nr)

{

	struct extent_buffer *leaf;

	int ret = 0;

	int slot;

	int i;

	if (ret < 0)

		goto out;

	leaf = path->nodes[0];

	slot = path->slots[0];

	BUG_ON(slot < 0);

 */

#define BTRFS_EXTENT_CSUM_OBJECTID -10ULL

/* For storing free space cache */

#define BTRFS_FREE_SPACE_OBJECTID -11ULL

/* dummy objectid represents multiple objectids */

#define BTRFS_MULTIPLE_OBJECTIDS -255ULL

	/* additional stripes go here */

} __attribute__ ((__packed__));

#define BTRFS_FREE_SPACE_EXTENT	1

#define BTRFS_FREE_SPACE_BITMAP	2

struct btrfs_free_space_entry {

	__le64 offset;

	__le64 bytes;

	u8 type;

} __attribute__ ((__packed__));

struct btrfs_free_space_header {

	struct btrfs_disk_key location;

	__le64 generation;

	__le64 num_entries;

	__le64 num_bitmaps;

} __attribute__ ((__packed__));

static inline unsigned long btrfs_chunk_item_size(int num_stripes)

{

	BUG_ON(num_stripes == 0);

	char label[BTRFS_LABEL_SIZE];

	__le64 cache_generation;

	/* future expansion */

	__le64 reserved[32];

	__le64 reserved[31];

	u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];

} __attribute__ ((__packed__));

 * ones specified below then we will fail to mount

 */

#define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF	(1ULL << 0)

#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL	(2ULL << 0)

#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL	(1ULL << 1)

#define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS	(1ULL << 2)

#define BTRFS_FEATURE_COMPAT_SUPP		0ULL

#define BTRFS_FEATURE_COMPAT_RO_SUPP		0ULL

#define BTRFS_FEATURE_INCOMPAT_SUPP			\

	(BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |		\

	 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL)

	 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |	\

	 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)

/*

 * A leaf is full of items. offset and size tell us where to find

struct btrfs_space_info {

	u64 flags;

	u64 total_bytes;	/* total bytes in the space */

	u64 total_bytes;	/* total bytes in the space,

				   this doesn't take mirrors into account */

	u64 bytes_used;		/* total bytes used,

				   this does't take mirrors into account */

	u64 bytes_pinned;	/* total bytes pinned, will be freed when the

	u64 bytes_may_use;	/* number of bytes that may be used for

				   delalloc/allocations */

	u64 disk_used;		/* total bytes used on disk */

	u64 disk_total;		/* total bytes on disk, takes mirrors into

				   account */

	int full;		/* indicates that we cannot allocate any more

				   chunks for this space */

	BTRFS_CACHE_FINISHED	= 2,

};

enum btrfs_disk_cache_state {

	BTRFS_DC_WRITTEN	= 0,

	BTRFS_DC_ERROR		= 1,

	BTRFS_DC_CLEAR		= 2,

	BTRFS_DC_SETUP		= 3,

	BTRFS_DC_NEED_WRITE	= 4,

};

struct btrfs_caching_control {

	struct list_head list;

	struct mutex mutex;

	struct btrfs_key key;

	struct btrfs_block_group_item item;

	struct btrfs_fs_info *fs_info;

	struct inode *inode;

	spinlock_t lock;

	u64 pinned;

	u64 reserved;

	int extents_thresh;

	int free_extents;

	int total_bitmaps;

	int ro;

	int dirty;

	int ro:1;

	int dirty:1;

	int iref:1;

	int disk_cache_state;

	/* cache tracking stuff */

	int cached;

	struct btrfs_transaction *running_transaction;

	wait_queue_head_t transaction_throttle;

	wait_queue_head_t transaction_wait;

	wait_queue_head_t transaction_blocked_wait;

	wait_queue_head_t async_submit_wait;

	struct btrfs_super_block super_copy;

	struct btrfs_workers endio_meta_workers;

	struct btrfs_workers endio_meta_write_workers;

	struct btrfs_workers endio_write_workers;

	struct btrfs_workers endio_freespace_worker;

	struct btrfs_workers submit_workers;

	/*

	 * fixup workers take dirty pages that didn't properly go through

#define BTRFS_MOUNT_NOSSD		(1 << 9)

#define BTRFS_MOUNT_DISCARD		(1 << 10)

#define BTRFS_MOUNT_FORCE_COMPRESS      (1 << 11)

#define BTRFS_MOUNT_SPACE_CACHE		(1 << 12)

#define BTRFS_MOUNT_CLEAR_CACHE		(1 << 13)

#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)

#define btrfs_clear_opt(o, opt)		((o) &= ~BTRFS_MOUNT_##opt)

#define btrfs_set_opt(o, opt)		((o) |= BTRFS_MOUNT_##opt)

	write_eb_member(eb, item, struct btrfs_dir_item, location, key);

}

BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,

		   num_entries, 64);

BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,

		   num_bitmaps, 64);

BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,

		   generation, 64);

static inline void btrfs_free_space_key(struct extent_buffer *eb,

					struct btrfs_free_space_header *h,

					struct btrfs_disk_key *key)

{

	read_eb_member(eb, h, struct btrfs_free_space_header, location, key);

}

static inline void btrfs_set_free_space_key(struct extent_buffer *eb,

					    struct btrfs_free_space_header *h,

					    struct btrfs_disk_key *key)

{

	write_eb_member(eb, h, struct btrfs_free_space_header, location, key);

}

/* struct btrfs_disk_key */

BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,

			 objectid, 64);

			 incompat_flags, 64);

BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,

			 csum_type, 16);

BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,

			 cache_generation, 64);

static inline int btrfs_super_csum_size(struct btrfs_super_block *s)

{

	return file->f_path.dentry;

}

static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)

{

	return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&

		(space_info->flags & BTRFS_BLOCK_GROUP_DATA));

}

/* extent-tree.c */

void btrfs_put_block_group(struct btrfs_block_group_cache *cache);

int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,

void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes);

int btrfs_trans_reserve_metadata(struct btrfs_trans_handle *trans,

				struct btrfs_root *root,

				int num_items, int *retries);

				int num_items);

void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,

				struct btrfs_root *root);

int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,

int btrfs_block_rsv_add(struct btrfs_trans_handle *trans,

			struct btrfs_root *root,

			struct btrfs_block_rsv *block_rsv,

			u64 num_bytes, int *retries);

			u64 num_bytes);

int btrfs_block_rsv_check(struct btrfs_trans_handle *trans,

			  struct btrfs_root *root,

			  struct btrfs_block_rsv *block_rsv,

			     struct btrfs_block_group_cache *cache);

int btrfs_set_block_group_rw(struct btrfs_root *root,

			     struct btrfs_block_group_cache *cache);

void btrfs_put_block_group_cache(struct btrfs_fs_info *info);

/* ctree.c */

int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,

		     int level, int *slot);

			       u32 min_type);

int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);

int btrfs_start_one_delalloc_inode(struct btrfs_root *root, int delay_iput);

int btrfs_start_one_delalloc_inode(struct btrfs_root *root, int delay_iput,

				   int sync);

int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,

			      struct extent_state **cached_state);

int btrfs_writepages(struct address_space *mapping,

int btrfs_prealloc_file_range(struct inode *inode, int mode,

			      u64 start, u64 num_bytes, u64 min_size,

			      loff_t actual_len, u64 *alloc_hint);

int btrfs_prealloc_file_range_trans(struct inode *inode,

				    struct btrfs_trans_handle *trans, int mode,

				    u64 start, u64 num_bytes, u64 min_size,

				    loff_t actual_len, u64 *alloc_hint);

extern const struct dentry_operations btrfs_dentry_operations;

/* ioctl.c */

		ret = btrfs_truncate_item(trans, root, path,

					  item_len - sub_item_len, 1);

	}

	return 0;

	return ret;

}

	struct extent_io_tree *tree;

	u64 start = (u64)page->index << PAGE_CACHE_SHIFT;

	u64 found_start;

	int found_level;

	unsigned long len;

	struct extent_buffer *eb;

	int ret;

		WARN_ON(1);

		goto err;

	}

	found_level = btrfs_header_level(eb);

	csum_tree_block(root, eb, 0);

err:

	free_extent_buffer(eb);

	end_io_wq->work.flags = 0;

	if (bio->bi_rw & REQ_WRITE) {

		if (end_io_wq->metadata)

		if (end_io_wq->metadata == 1)

			btrfs_queue_worker(&fs_info->endio_meta_write_workers,

					   &end_io_wq->work);

		else if (end_io_wq->metadata == 2)

			btrfs_queue_worker(&fs_info->endio_freespace_worker,

					   &end_io_wq->work);

		else

			btrfs_queue_worker(&fs_info->endio_write_workers,

					   &end_io_wq->work);

	}

}

/*

 * For the metadata arg you want

 *

 * 0 - if data

 * 1 - if normal metadta

 * 2 - if writing to the free space cache area

 */

int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,

			int metadata)

{

static void run_one_async_start(struct btrfs_work *work)

{

	struct btrfs_fs_info *fs_info;

	struct async_submit_bio *async;

	async = container_of(work, struct  async_submit_bio, work);

	fs_info = BTRFS_I(async->inode)->root->fs_info;

	async->submit_bio_start(async->inode, async->rw, async->bio,

			       async->mirror_num, async->bio_flags,

			       async->bio_offset);

				      u32 blocksize, u64 parent_transid)

{

	struct extent_buffer *buf = NULL;

	struct inode *btree_inode = root->fs_info->btree_inode;

	struct extent_io_tree *io_tree;

	int ret;

	io_tree = &BTRFS_I(btree_inode)->io_tree;

	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);

	if (!buf)

		return NULL;

	u64 start = 0;

	struct page *page;

	struct extent_io_tree *io_tree = NULL;

	struct btrfs_fs_info *info = NULL;

	struct bio_vec *bvec;

	int i;

	int ret;

		buf_len = page->private >> 2;

		start = page_offset(page) + bvec->bv_offset;

		io_tree = &BTRFS_I(page->mapping->host)->io_tree;

		info = BTRFS_I(page->mapping->host)->root->fs_info;

	}

	/* are we fully contained in this bio? */

	if (buf_len <= length)

	init_waitqueue_head(&fs_info->transaction_throttle);

	init_waitqueue_head(&fs_info->transaction_wait);

	init_waitqueue_head(&fs_info->transaction_blocked_wait);

	init_waitqueue_head(&fs_info->async_submit_wait);

	__setup_root(4096, 4096, 4096, 4096, tree_root,

		     fs_info, BTRFS_ROOT_TREE_OBJECTID);

	bh = btrfs_read_dev_super(fs_devices->latest_bdev);

	if (!bh)

		goto fail_iput;

	btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",

			   fs_info->thread_pool_size,

			   &fs_info->generic_worker);

	btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",

			   1, &fs_info->generic_worker);

	/*

	 * endios are largely parallel and should have a very

	btrfs_start_workers(&fs_info->endio_meta_workers, 1);

	btrfs_start_workers(&fs_info->endio_meta_write_workers, 1);

	btrfs_start_workers(&fs_info->endio_write_workers, 1);

	btrfs_start_workers(&fs_info->endio_freespace_worker, 1);

	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);

	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,

	if (!(sb->s_flags & MS_RDONLY)) {

		down_read(&fs_info->cleanup_work_sem);

		btrfs_orphan_cleanup(fs_info->fs_root);

		btrfs_orphan_cleanup(fs_info->tree_root);

		up_read(&fs_info->cleanup_work_sem);

	}

	btrfs_stop_workers(&fs_info->endio_meta_workers);

	btrfs_stop_workers(&fs_info->endio_meta_write_workers);

	btrfs_stop_workers(&fs_info->endio_write_workers);

	btrfs_stop_workers(&fs_info->endio_freespace_worker);

	btrfs_stop_workers(&fs_info->submit_workers);

fail_iput:

	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);

	fs_info->closing = 1;

	smp_mb();

	btrfs_put_block_group_cache(fs_info);

	if (!(fs_info->sb->s_flags & MS_RDONLY)) {

		ret =  btrfs_commit_super(root);

		if (ret)

	btrfs_stop_workers(&fs_info->endio_meta_workers);

	btrfs_stop_workers(&fs_info->endio_meta_write_workers);

	btrfs_stop_workers(&fs_info->endio_write_workers);

	btrfs_stop_workers(&fs_info->endio_freespace_worker);

	btrfs_stop_workers(&fs_info->submit_workers);

	btrfs_close_devices(fs_info->fs_devices);