ext4: add ext4_split_extent_at() and ext4_split_extent()

	return ret;

}

/*

 * used by extent splitting.

 */

#define EXT4_EXT_MAY_ZEROOUT	0x1  /* safe to zeroout if split fails \

					due to ENOSPC */

#define EXT4_EXT_MARK_UNINIT1	0x2  /* mark first half uninitialized */

#define EXT4_EXT_MARK_UNINIT2	0x4  /* mark second half uninitialized */

/*

 * ext4_split_extent_at() splits an extent at given block.

 *

 * @handle: the journal handle

 * @inode: the file inode

 * @path: the path to the extent

 * @split: the logical block where the extent is splitted.

 * @split_flags: indicates if the extent could be zeroout if split fails, and

 *		 the states(init or uninit) of new extents.

 * @flags: flags used to insert new extent to extent tree.

 *

 *

 * Splits extent [a, b] into two extents [a, @split) and [@split, b], states

 * of which are deterimined by split_flag.

 *

 * There are two cases:

 *  a> the extent are splitted into two extent.

 *  b> split is not needed, and just mark the extent.

 *

 * return 0 on success.

 */

static int ext4_split_extent_at(handle_t *handle,

			     struct inode *inode,

			     struct ext4_ext_path *path,

			     ext4_lblk_t split,

			     int split_flag,

			     int flags)

{

	ext4_fsblk_t newblock;

	ext4_lblk_t ee_block;

	struct ext4_extent *ex, newex, orig_ex;

	struct ext4_extent *ex2 = NULL;

	unsigned int ee_len, depth;

	int err = 0;

	ext_debug("ext4_split_extents_at: inode %lu, logical"

		"block %llu\n", inode->i_ino, (unsigned long long)split);

	ext4_ext_show_leaf(inode, path);

	depth = ext_depth(inode);

	ex = path[depth].p_ext;

	ee_block = le32_to_cpu(ex->ee_block);

	ee_len = ext4_ext_get_actual_len(ex);

	newblock = split - ee_block + ext4_ext_pblock(ex);

	BUG_ON(split < ee_block || split >= (ee_block + ee_len));

	err = ext4_ext_get_access(handle, inode, path + depth);

	if (err)

		goto out;

	if (split == ee_block) {

		/*

		 * case b: block @split is the block that the extent begins with

		 * then we just change the state of the extent, and splitting

		 * is not needed.

		 */

		if (split_flag & EXT4_EXT_MARK_UNINIT2)

			ext4_ext_mark_uninitialized(ex);

		else

			ext4_ext_mark_initialized(ex);

		if (!(flags & EXT4_GET_BLOCKS_PRE_IO))

			ext4_ext_try_to_merge(inode, path, ex);

		err = ext4_ext_dirty(handle, inode, path + depth);

		goto out;

	}

	/* case a */

	memcpy(&orig_ex, ex, sizeof(orig_ex));

	ex->ee_len = cpu_to_le16(split - ee_block);

	if (split_flag & EXT4_EXT_MARK_UNINIT1)

		ext4_ext_mark_uninitialized(ex);

	/*

	 * path may lead to new leaf, not to original leaf any more

	 * after ext4_ext_insert_extent() returns,

	 */

	err = ext4_ext_dirty(handle, inode, path + depth);

	if (err)

		goto fix_extent_len;

	ex2 = &newex;

	ex2->ee_block = cpu_to_le32(split);

	ex2->ee_len   = cpu_to_le16(ee_len - (split - ee_block));

	ext4_ext_store_pblock(ex2, newblock);

	if (split_flag & EXT4_EXT_MARK_UNINIT2)

		ext4_ext_mark_uninitialized(ex2);

	err = ext4_ext_insert_extent(handle, inode, path, &newex, flags);

	if (err == -ENOSPC && (EXT4_EXT_MAY_ZEROOUT & split_flag)) {

		err = ext4_ext_zeroout(inode, &orig_ex);

		if (err)

			goto fix_extent_len;

		/* update the extent length and mark as initialized */

		ex->ee_len = cpu_to_le32(ee_len);

		ext4_ext_try_to_merge(inode, path, ex);

		err = ext4_ext_dirty(handle, inode, path + depth);

		goto out;

	} else if (err)

		goto fix_extent_len;

out:

	ext4_ext_show_leaf(inode, path);

	return err;

fix_extent_len:

	ex->ee_len = orig_ex.ee_len;

	ext4_ext_dirty(handle, inode, path + depth);

	return err;

}

/*

 * ext4_split_extents() splits an extent and mark extent which is covered

 * by @map as split_flags indicates

 *

 * It may result in splitting the extent into multiple extents (upto three)

 * There are three possibilities:

 *   a> There is no split required

 *   b> Splits in two extents: Split is happening at either end of the extent

 *   c> Splits in three extents: Somone is splitting in middle of the extent

 *

 */

static int ext4_split_extent(handle_t *handle,

			      struct inode *inode,

			      struct ext4_ext_path *path,

			      struct ext4_map_blocks *map,

			      int split_flag,

			      int flags)

{

	ext4_lblk_t ee_block;

	struct ext4_extent *ex;

	unsigned int ee_len, depth;

	int err = 0;

	int uninitialized;

	int split_flag1, flags1;

	depth = ext_depth(inode);

	ex = path[depth].p_ext;

	ee_block = le32_to_cpu(ex->ee_block);

	ee_len = ext4_ext_get_actual_len(ex);

	uninitialized = ext4_ext_is_uninitialized(ex);

	if (map->m_lblk + map->m_len < ee_block + ee_len) {

		split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT ?

			      EXT4_EXT_MAY_ZEROOUT : 0;

		flags1 = flags | EXT4_GET_BLOCKS_PRE_IO;

		if (uninitialized)

			split_flag1 |= EXT4_EXT_MARK_UNINIT1 |

				       EXT4_EXT_MARK_UNINIT2;

		err = ext4_split_extent_at(handle, inode, path,

				map->m_lblk + map->m_len, split_flag1, flags1);

	}

	ext4_ext_drop_refs(path);

	path = ext4_ext_find_extent(inode, map->m_lblk, path);

	if (IS_ERR(path))

		return PTR_ERR(path);

	if (map->m_lblk >= ee_block) {

		split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT ?

			      EXT4_EXT_MAY_ZEROOUT : 0;

		if (uninitialized)

			split_flag1 |= EXT4_EXT_MARK_UNINIT1;

		if (split_flag & EXT4_EXT_MARK_UNINIT2)

			split_flag1 |= EXT4_EXT_MARK_UNINIT2;

		err = ext4_split_extent_at(handle, inode, path,

				map->m_lblk, split_flag1, flags);

		if (err)

			goto out;

	}

	ext4_ext_show_leaf(inode, path);

out:

	return err ? err : map->m_len;

}

#define EXT4_EXT_ZERO_LEN 7

/*

 * This function is called by ext4_ext_map_blocks() if someone tries to write