[PATCH] ext4: clean up comments in ext4-extents patch (d0d856e8) · Commits · jan.koester / Linux

fs/ext4/extents.c

+128 −98

Original line number	Original line	Diff line number	Diff line
	@@ -44,7 +44,10 @@
	#include <asm/uaccess.h>		#include <asm/uaccess.h>


	/* this macro combines low and hi parts of phys. blocknr into ext4_fsblk_t */		/*
			* ext_pblock:
			* combine low and high parts of physical block number into ext4_fsblk_t
			*/
	static inline ext4_fsblk_t ext_pblock(struct ext4_extent *ex)		static inline ext4_fsblk_t ext_pblock(struct ext4_extent *ex)
	{		{
	ext4_fsblk_t block;		ext4_fsblk_t block;
	@@ -55,7 +58,10 @@ static inline ext4_fsblk_t ext_pblock(struct ext4_extent *ex)
	return block;		return block;
	}		}

	/* this macro combines low and hi parts of phys. blocknr into ext4_fsblk_t */		/*
			* idx_pblock:
			* combine low and high parts of a leaf physical block number into ext4_fsblk_t
			*/
	static inline ext4_fsblk_t idx_pblock(struct ext4_extent_idx *ix)		static inline ext4_fsblk_t idx_pblock(struct ext4_extent_idx *ix)
	{		{
	ext4_fsblk_t block;		ext4_fsblk_t block;
	@@ -66,7 +72,11 @@ static inline ext4_fsblk_t idx_pblock(struct ext4_extent_idx *ix)
	return block;		return block;
	}		}

	/* the routine stores large phys. blocknr into extent breaking it into parts */		/*
			* ext4_ext_store_pblock:
			* stores a large physical block number into an extent struct,
			* breaking it into parts
			*/
	static inline void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb)		static inline void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb)
	{		{
	ex->ee_start = cpu_to_le32((unsigned long) (pb & 0xffffffff));		ex->ee_start = cpu_to_le32((unsigned long) (pb & 0xffffffff));
	@@ -74,7 +84,11 @@ static inline void ext4_ext_store_pblock(struct ext4_extent *ex, ext4_fsblk_t pb
	ex->ee_start_hi = cpu_to_le16((unsigned long) ((pb >> 31) >> 1) & 0xffff);		ex->ee_start_hi = cpu_to_le16((unsigned long) ((pb >> 31) >> 1) & 0xffff);
	}		}

	/* the routine stores large phys. blocknr into index breaking it into parts */		/*
			* ext4_idx_store_pblock:
			* stores a large physical block number into an index struct,
			* breaking it into parts
			*/
	static inline void ext4_idx_store_pblock(struct ext4_extent_idx *ix, ext4_fsblk_t pb)		static inline void ext4_idx_store_pblock(struct ext4_extent_idx *ix, ext4_fsblk_t pb)
	{		{
	ix->ei_leaf = cpu_to_le32((unsigned long) (pb & 0xffffffff));		ix->ei_leaf = cpu_to_le32((unsigned long) (pb & 0xffffffff));
	@@ -179,8 +193,8 @@ static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode,
	if ((ex = path[depth].p_ext))		if ((ex = path[depth].p_ext))
	return ext_pblock(ex)+(block-le32_to_cpu(ex->ee_block));		return ext_pblock(ex)+(block-le32_to_cpu(ex->ee_block));

	/* it looks index is empty		/* it looks like index is empty;
	* try to find starting from index itself */		* try to find starting block from index itself */
	if (path[depth].p_bh)		if (path[depth].p_bh)
	return path[depth].p_bh->b_blocknr;		return path[depth].p_bh->b_blocknr;
	}		}
	@@ -317,7 +331,8 @@ static void ext4_ext_drop_refs(struct ext4_ext_path *path)
	}		}

	/*		/*
	* binary search for closest index by given block		* ext4_ext_binsearch_idx:
			* binary search for the closest index of the given block
	*/		*/
	static void		static void
	ext4_ext_binsearch_idx(struct inode inode, struct ext4_ext_path path, int block)		ext4_ext_binsearch_idx(struct inode inode, struct ext4_ext_path path, int block)
	@@ -375,7 +390,8 @@ ext4_ext_binsearch_idx(struct inode inode, struct ext4_ext_path path, int bloc
	}		}

	/*		/*
	* binary search for closest extent by given block		* ext4_ext_binsearch:
			* binary search for closest extent of the given block
	*/		*/
	static void		static void
	ext4_ext_binsearch(struct inode inode, struct ext4_ext_path path, int block)		ext4_ext_binsearch(struct inode inode, struct ext4_ext_path path, int block)
	@@ -388,7 +404,7 @@ ext4_ext_binsearch(struct inode inode, struct ext4_ext_path path, int block)

	if (eh->eh_entries == 0) {		if (eh->eh_entries == 0) {
	/*		/*
	* this leaf is empty yet:		* this leaf is empty:
	* we get such a leaf in split/add case		* we get such a leaf in split/add case
	*/		*/
	return;		return;
	@@ -520,8 +536,9 @@ ext4_ext_find_extent(struct inode inode, int block, struct ext4_ext_path path)
	}		}

	/*		/*
	* insert new index [logical;ptr] into the block at cupr		* ext4_ext_insert_index:
	* it check where to insert: before curp or after curp		* insert new index [@logical;@ptr] into the block at @curp;
			* check where to insert: before @curp or after @curp
	*/		*/
	static int ext4_ext_insert_index(handle_t handle, struct inode inode,		static int ext4_ext_insert_index(handle_t handle, struct inode inode,
	struct ext4_ext_path *curp,		struct ext4_ext_path *curp,
	@@ -574,13 +591,14 @@ static int ext4_ext_insert_index(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* routine inserts new subtree into the path, using free index entry		* ext4_ext_split:
	* at depth 'at:		* inserts new subtree into the path, using free index entry
			* at depth @at:
	* - allocates all needed blocks (new leaf and all intermediate index blocks)		* - allocates all needed blocks (new leaf and all intermediate index blocks)
	* - makes decision where to split		* - makes decision where to split
	* - moves remaining extens and index entries (right to the split point)		* - moves remaining extents and index entries (right to the split point)
	* into the newly allocated blocks		* into the newly allocated blocks
	* - initialize subtree		* - initializes subtree
	*/		*/
	static int ext4_ext_split(handle_t handle, struct inode inode,		static int ext4_ext_split(handle_t handle, struct inode inode,
	struct ext4_ext_path *path,		struct ext4_ext_path *path,
	@@ -598,14 +616,14 @@ static int ext4_ext_split(handle_t handle, struct inode inode,
	int err = 0;		int err = 0;

	/* make decision: where to split? */		/* make decision: where to split? */
	/* FIXME: now desicion is simplest: at current extent */		/* FIXME: now decision is simplest: at current extent */

	/* if current leaf will be splitted, then we should use		/* if current leaf will be split, then we should use
	* border from split point */		* border from split point */
	BUG_ON(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr));		BUG_ON(path[depth].p_ext > EXT_MAX_EXTENT(path[depth].p_hdr));
	if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) {		if (path[depth].p_ext != EXT_MAX_EXTENT(path[depth].p_hdr)) {
	border = path[depth].p_ext[1].ee_block;		border = path[depth].p_ext[1].ee_block;
	ext_debug("leaf will be splitted."		ext_debug("leaf will be split."
	" next leaf starts at %d\n",		" next leaf starts at %d\n",
	le32_to_cpu(border));		le32_to_cpu(border));
	} else {		} else {
	@@ -616,16 +634,16 @@ static int ext4_ext_split(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* if error occurs, then we break processing		* If error occurs, then we break processing
	* and turn filesystem read-only. so, index won't		* and mark filesystem read-only. index won't
	* be inserted and tree will be in consistent		* be inserted and tree will be in consistent
	* state. next mount will repair buffers too		* state. Next mount will repair buffers too.
	*/		*/

	/*		/*
	* get array to track all allocated blocks		* Get array to track all allocated blocks.
	* we need this to handle errors and free blocks		* We need this to handle errors and free blocks
	* upon them		* upon them.
	*/		*/
	ablocks = kmalloc(sizeof(ext4_fsblk_t) * depth, GFP_NOFS);		ablocks = kmalloc(sizeof(ext4_fsblk_t) * depth, GFP_NOFS);
	if (!ablocks)		if (!ablocks)
	@@ -661,7 +679,7 @@ static int ext4_ext_split(handle_t handle, struct inode inode,
	neh->eh_depth = 0;		neh->eh_depth = 0;
	ex = EXT_FIRST_EXTENT(neh);		ex = EXT_FIRST_EXTENT(neh);

	/* move remain of path[depth] to the new leaf */		/* move remainder of path[depth] to the new leaf */
	BUG_ON(path[depth].p_hdr->eh_entries != path[depth].p_hdr->eh_max);		BUG_ON(path[depth].p_hdr->eh_entries != path[depth].p_hdr->eh_max);
	/* start copy from next extent */		/* start copy from next extent */
	/* TODO: we could do it by single memmove */		/* TODO: we could do it by single memmove */
	@@ -813,10 +831,11 @@ static int ext4_ext_split(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* routine implements tree growing procedure:		* ext4_ext_grow_indepth:
			* implements tree growing procedure:
	* - allocates new block		* - allocates new block
	* - moves top-level data (index block or leaf) into the new block		* - moves top-level data (index block or leaf) into the new block
	* - initialize new top-level, creating index that points to the		* - initializes new top-level, creating index that points to the
	* just created block		* just created block
	*/		*/
	static int ext4_ext_grow_indepth(handle_t handle, struct inode inode,		static int ext4_ext_grow_indepth(handle_t handle, struct inode inode,
	@@ -892,8 +911,9 @@ static int ext4_ext_grow_indepth(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* routine finds empty index and adds new leaf. if no free index found		* ext4_ext_create_new_leaf:
	* then it requests in-depth growing		* finds empty index and adds new leaf.
			* if no free index is found, then it requests in-depth growing.
	*/		*/
	static int ext4_ext_create_new_leaf(handle_t handle, struct inode inode,		static int ext4_ext_create_new_leaf(handle_t handle, struct inode inode,
	struct ext4_ext_path *path,		struct ext4_ext_path *path,
	@@ -912,8 +932,8 @@ static int ext4_ext_create_new_leaf(handle_t handle, struct inode inode,
	curp--;		curp--;
	}		}

	/* we use already allocated block for index block		/* we use already allocated block for index block,
	* so, subsequent data blocks should be contigoues */		* so subsequent data blocks should be contiguous */
	if (EXT_HAS_FREE_INDEX(curp)) {		if (EXT_HAS_FREE_INDEX(curp)) {
	/* if we found index with free entry, then use that		/* if we found index with free entry, then use that
	* entry: create all needed subtree and add new leaf */		* entry: create all needed subtree and add new leaf */
	@@ -943,12 +963,12 @@ static int ext4_ext_create_new_leaf(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* only first (depth 0 -> 1) produces free space		* only first (depth 0 -> 1) produces free space;
	* in all other cases we have to split growed tree		* in all other cases we have to split the grown tree
	*/		*/
	depth = ext_depth(inode);		depth = ext_depth(inode);
	if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) {		if (path[depth].p_hdr->eh_entries == path[depth].p_hdr->eh_max) {
	/* now we need split */		/* now we need to split */
	goto repeat;		goto repeat;
	}		}
	}		}
	@@ -958,10 +978,11 @@ static int ext4_ext_create_new_leaf(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* returns allocated block in subsequent extent or EXT_MAX_BLOCK		* ext4_ext_next_allocated_block:
	* NOTE: it consider block number from index entry as		* returns allocated block in subsequent extent or EXT_MAX_BLOCK.
	* allocated block. thus, index entries have to be consistent		* NOTE: it considers block number from index entry as
	* with leafs		* allocated block. Thus, index entries have to be consistent
			* with leaves.
	*/		*/
	static unsigned long		static unsigned long
	ext4_ext_next_allocated_block(struct ext4_ext_path *path)		ext4_ext_next_allocated_block(struct ext4_ext_path *path)
	@@ -993,6 +1014,7 @@ ext4_ext_next_allocated_block(struct ext4_ext_path *path)
	}		}

	/*		/*
			* ext4_ext_next_leaf_block:
	* returns first allocated block from next leaf or EXT_MAX_BLOCK		* returns first allocated block from next leaf or EXT_MAX_BLOCK
	*/		*/
	static unsigned ext4_ext_next_leaf_block(struct inode *inode,		static unsigned ext4_ext_next_leaf_block(struct inode *inode,
	@@ -1021,8 +1043,9 @@ static unsigned ext4_ext_next_leaf_block(struct inode *inode,
	}		}

	/*		/*
	* if leaf gets modified and modified extent is first in the leaf		* ext4_ext_correct_indexes:
	* then we have to correct all indexes above		* if leaf gets modified and modified extent is first in the leaf,
			* then we have to correct all indexes above.
	* TODO: do we need to correct tree in all cases?		* TODO: do we need to correct tree in all cases?
	*/		*/
	int ext4_ext_correct_indexes(handle_t handle, struct inode inode,		int ext4_ext_correct_indexes(handle_t handle, struct inode inode,
	@@ -1050,7 +1073,7 @@ int ext4_ext_correct_indexes(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* TODO: we need correction if border is smaller then current one		* TODO: we need correction if border is smaller than current one
	*/		*/
	k = depth - 1;		k = depth - 1;
	border = path[depth].p_ext->ee_block;		border = path[depth].p_ext->ee_block;
	@@ -1085,7 +1108,7 @@ ext4_can_extents_be_merged(struct inode inode, struct ext4_extent ex1,
	/*		/*
	* To allow future support for preallocated extents to be added		* To allow future support for preallocated extents to be added
	* as an RO_COMPAT feature, refuse to merge to extents if		* as an RO_COMPAT feature, refuse to merge to extents if
	* can result in the top bit of ee_len being set		* this can result in the top bit of ee_len being set.
	*/		*/
	if (le16_to_cpu(ex1->ee_len) + le16_to_cpu(ex2->ee_len) > EXT_MAX_LEN)		if (le16_to_cpu(ex1->ee_len) + le16_to_cpu(ex2->ee_len) > EXT_MAX_LEN)
	return 0;		return 0;
	@@ -1100,9 +1123,10 @@ ext4_can_extents_be_merged(struct inode inode, struct ext4_extent ex1,
	}		}

	/*		/*
	* this routine tries to merge requsted extent into the existing		* ext4_ext_insert_extent:
	* extent or inserts requested extent as new one into the tree,		* tries to merge requsted extent into the existing extent or
	* creating new leaf in no-space case		* inserts requested extent as new one into the tree,
			* creating new leaf in the no-space case.
	*/		*/
	int ext4_ext_insert_extent(handle_t handle, struct inode inode,		int ext4_ext_insert_extent(handle_t handle, struct inode inode,
	struct ext4_ext_path *path,		struct ext4_ext_path *path,
	@@ -1163,8 +1187,8 @@ int ext4_ext_insert_extent(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* there is no free space in found leaf		* There is no free space in the found leaf.
	* we're gonna add new leaf in the tree		* We're gonna add a new leaf in the tree.
	*/		*/
	err = ext4_ext_create_new_leaf(handle, inode, path, newext);		err = ext4_ext_create_new_leaf(handle, inode, path, newext);
	if (err)		if (err)
	@@ -1377,7 +1401,8 @@ ext4_ext_put_in_cache(struct inode *inode, __u32 block,
	}		}

	/*		/*
	* this routine calculate boundaries of the gap requested block fits into		* ext4_ext_put_gap_in_cache:
			* calculate boundaries of the gap that the requested block fits into
	* and cache this gap		* and cache this gap
	*/		*/
	static inline void		static inline void
	@@ -1452,9 +1477,10 @@ ext4_ext_in_cache(struct inode *inode, unsigned long block,
	}		}

	/*		/*
	* routine removes index from the index block		* ext4_ext_rm_idx:
	* it's used in truncate case only. thus all requests are for		* removes index from the index block.
	* last index in the block only		* It's used in truncate case only, thus all requests are for
			* last index in the block only.
	*/		*/
	int ext4_ext_rm_idx(handle_t handle, struct inode inode,		int ext4_ext_rm_idx(handle_t handle, struct inode inode,
	struct ext4_ext_path *path)		struct ext4_ext_path *path)
	@@ -1480,11 +1506,12 @@ int ext4_ext_rm_idx(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* This routine returns max. credits extent tree can consume.		* ext4_ext_calc_credits_for_insert:
			* This routine returns max. credits that the extent tree can consume.
	* It should be OK for low-performance paths like ->writepage()		* It should be OK for low-performance paths like ->writepage()
	* To allow many writing process to fit a single transaction,		* To allow many writing processes to fit into a single transaction,
	* caller should calculate credits under truncate_mutex and		* the caller should calculate credits under truncate_mutex and
	* pass actual path.		* pass the actual path.
	*/		*/
	int inline ext4_ext_calc_credits_for_insert(struct inode *inode,		int inline ext4_ext_calc_credits_for_insert(struct inode *inode,
	struct ext4_ext_path *path)		struct ext4_ext_path *path)
	@@ -1500,9 +1527,9 @@ int inline ext4_ext_calc_credits_for_insert(struct inode *inode,
	}		}

	/*		/*
	* given 32bit logical block (4294967296 blocks), max. tree		* given 32-bit logical block (4294967296 blocks), max. tree
	* can be 4 levels in depth -- 4 * 340^4 == 53453440000.		* can be 4 levels in depth -- 4 * 340^4 == 53453440000.
	* let's also add one more level for imbalance.		* Let's also add one more level for imbalance.
	*/		*/
	depth = 5;		depth = 5;

	@@ -1510,13 +1537,13 @@ int inline ext4_ext_calc_credits_for_insert(struct inode *inode,
	needed = 2;		needed = 2;

	/*		/*
	* tree can be full, so it'd need to grow in depth:		* tree can be full, so it would need to grow in depth:
	* allocation + old root + new root		* allocation + old root + new root
	*/		*/
	needed += 2 + 1 + 1;		needed += 2 + 1 + 1;

	/*		/*
	* Index split can happen, we'd need:		* Index split can happen, we would need:
	* allocate intermediate indexes (bitmap + group)		* allocate intermediate indexes (bitmap + group)
	* + change two blocks at each level, but root (already included)		* + change two blocks at each level, but root (already included)
	*/		*/
	@@ -1634,7 +1661,7 @@ ext4_ext_rm_leaf(handle_t handle, struct inode inode,
	BUG_ON(b != ex_ee_block + ex_ee_len - 1);		BUG_ON(b != ex_ee_block + ex_ee_len - 1);
	}		}

	/* at present, extent can't cross block group */		/* at present, extent can't cross block group: */
	/* leaf + bitmap + group desc + sb + inode */		/* leaf + bitmap + group desc + sb + inode */
	credits = 5;		credits = 5;
	if (ex == EXT_FIRST_EXTENT(eh)) {		if (ex == EXT_FIRST_EXTENT(eh)) {
	@@ -1660,7 +1687,7 @@ ext4_ext_rm_leaf(handle_t handle, struct inode inode,
	goto out;		goto out;

	if (num == 0) {		if (num == 0) {
	/* this extent is removed entirely mark slot unused */		/* this extent is removed; mark slot entirely unused */
	ext4_ext_store_pblock(ex, 0);		ext4_ext_store_pblock(ex, 0);
	eh->eh_entries = cpu_to_le16(le16_to_cpu(eh->eh_entries)-1);		eh->eh_entries = cpu_to_le16(le16_to_cpu(eh->eh_entries)-1);
	}		}
	@@ -1692,7 +1719,8 @@ ext4_ext_rm_leaf(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* returns 1 if current index have to be freed (even partial)		* ext4_ext_more_to_rm:
			* returns 1 if current index has to be freed (even partial)
	*/		*/
	static int inline		static int inline
	ext4_ext_more_to_rm(struct ext4_ext_path *path)		ext4_ext_more_to_rm(struct ext4_ext_path *path)
	@@ -1703,7 +1731,7 @@ ext4_ext_more_to_rm(struct ext4_ext_path *path)
	return 0;		return 0;

	/*		/*
	* if truncate on deeper level happened it it wasn't partial		* if truncate on deeper level happened, it wasn't partial,
	* so we have to consider current index for truncation		* so we have to consider current index for truncation
	*/		*/
	if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block)		if (le16_to_cpu(path->p_hdr->eh_entries) == path->p_block)
	@@ -1729,8 +1757,8 @@ int ext4_ext_remove_space(struct inode *inode, unsigned long start)
	ext4_ext_invalidate_cache(inode);		ext4_ext_invalidate_cache(inode);

	/*		/*
	* we start scanning from right side freeing all the blocks		* We start scanning from right side, freeing all the blocks
	* after i_size and walking into the deep		* after i_size and walking into the tree depth-wise.
	*/		*/
	path = kmalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_KERNEL);		path = kmalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_KERNEL);
	if (path == NULL) {		if (path == NULL) {
	@@ -1749,7 +1777,7 @@ int ext4_ext_remove_space(struct inode *inode, unsigned long start)
	if (i == depth) {		if (i == depth) {
	/* this is leaf block */		/* this is leaf block */
	err = ext4_ext_rm_leaf(handle, inode, path, start);		err = ext4_ext_rm_leaf(handle, inode, path, start);
	/* root level have p_bh == NULL, brelse() eats this */		/* root level has p_bh == NULL, brelse() eats this */
	brelse(path[i].p_bh);		brelse(path[i].p_bh);
	path[i].p_bh = NULL;		path[i].p_bh = NULL;
	i--;		i--;
	@@ -1772,14 +1800,14 @@ int ext4_ext_remove_space(struct inode *inode, unsigned long start)
	BUG_ON(path[i].p_hdr->eh_magic != EXT4_EXT_MAGIC);		BUG_ON(path[i].p_hdr->eh_magic != EXT4_EXT_MAGIC);

	if (!path[i].p_idx) {		if (!path[i].p_idx) {
	/* this level hasn't touched yet */		/* this level hasn't been touched yet */
	path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr);		path[i].p_idx = EXT_LAST_INDEX(path[i].p_hdr);
	path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1;		path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries)+1;
	ext_debug("init index ptr: hdr 0x%p, num %d\n",		ext_debug("init index ptr: hdr 0x%p, num %d\n",
	path[i].p_hdr,		path[i].p_hdr,
	le16_to_cpu(path[i].p_hdr->eh_entries));		le16_to_cpu(path[i].p_hdr->eh_entries));
	} else {		} else {
	/* we've already was here, see at next index */		/* we were already here, see at next index */
	path[i].p_idx--;		path[i].p_idx--;
	}		}

	@@ -1799,19 +1827,19 @@ int ext4_ext_remove_space(struct inode *inode, unsigned long start)
	break;		break;
	}		}

	/* put actual number of indexes to know is this		/* save actual number of indexes since this
	* number got changed at the next iteration */		* number is changed at the next iteration */
	path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries);		path[i].p_block = le16_to_cpu(path[i].p_hdr->eh_entries);
	i++;		i++;
	} else {		} else {
	/* we finish processing this index, go up */		/* we finished processing this index, go up */
	if (path[i].p_hdr->eh_entries == 0 && i > 0) {		if (path[i].p_hdr->eh_entries == 0 && i > 0) {
	/* index is empty, remove it		/* index is empty, remove it;
	* handle must be already prepared by the		* handle must be already prepared by the
	* truncatei_leaf() */		* truncatei_leaf() */
	err = ext4_ext_rm_idx(handle, inode, path + i);		err = ext4_ext_rm_idx(handle, inode, path + i);
	}		}
	/* root level have p_bh == NULL, brelse() eats this */		/* root level has p_bh == NULL, brelse() eats this */
	brelse(path[i].p_bh);		brelse(path[i].p_bh);
	path[i].p_bh = NULL;		path[i].p_bh = NULL;
	i--;		i--;
	@@ -1822,8 +1850,8 @@ int ext4_ext_remove_space(struct inode *inode, unsigned long start)
	/* TODO: flexible tree reduction should be here */		/* TODO: flexible tree reduction should be here */
	if (path->p_hdr->eh_entries == 0) {		if (path->p_hdr->eh_entries == 0) {
	/*		/*
	* truncate to zero freed all the tree		* truncate to zero freed all the tree,
	* so, we need to correct eh_depth		* so we need to correct eh_depth
	*/		*/
	err = ext4_ext_get_access(handle, inode, path);		err = ext4_ext_get_access(handle, inode, path);
	if (err == 0) {		if (err == 0) {
	@@ -1912,7 +1940,7 @@ int ext4_ext_get_blocks(handle_t handle, struct inode inode,
	if (goal == EXT4_EXT_CACHE_GAP) {		if (goal == EXT4_EXT_CACHE_GAP) {
	if (!create) {		if (!create) {
	/* block isn't allocated yet and		/* block isn't allocated yet and
	* user don't want to allocate it */		* user doesn't want to allocate it */
	goto out2;		goto out2;
	}		}
	/* we should allocate requested block */		/* we should allocate requested block */
	@@ -1921,7 +1949,7 @@ int ext4_ext_get_blocks(handle_t handle, struct inode inode,
	newblock = iblock		newblock = iblock
	- le32_to_cpu(newex.ee_block)		- le32_to_cpu(newex.ee_block)
	+ ext_pblock(&newex);		+ ext_pblock(&newex);
	/* number of remain blocks in the extent */		/* number of remaining blocks in the extent */
	allocated = le16_to_cpu(newex.ee_len) -		allocated = le16_to_cpu(newex.ee_len) -
	(iblock - le32_to_cpu(newex.ee_block));		(iblock - le32_to_cpu(newex.ee_block));
	goto out;		goto out;
	@@ -1941,8 +1969,8 @@ int ext4_ext_get_blocks(handle_t handle, struct inode inode,
	depth = ext_depth(inode);		depth = ext_depth(inode);

	/*		/*
	* consistent leaf must not be empty		* consistent leaf must not be empty;
	* this situations is possible, though, _during_ tree modification		* this situation is possible, though, _during_ tree modification;
	* this is why assert can't be put in ext4_ext_find_extent()		* this is why assert can't be put in ext4_ext_find_extent()
	*/		*/
	BUG_ON(path[depth].p_ext == NULL && depth != 0);		BUG_ON(path[depth].p_ext == NULL && depth != 0);
	@@ -1960,10 +1988,10 @@ int ext4_ext_get_blocks(handle_t handle, struct inode inode,
	*/		*/
	if (ee_len > EXT_MAX_LEN)		if (ee_len > EXT_MAX_LEN)
	goto out2;		goto out2;
	/* if found exent covers block, simple return it */		/* if found extent covers block, simply return it */
	if (iblock >= ee_block && iblock < ee_block + ee_len) {		if (iblock >= ee_block && iblock < ee_block + ee_len) {
	newblock = iblock - ee_block + ee_start;		newblock = iblock - ee_block + ee_start;
	/* number of remain blocks in the extent */		/* number of remaining blocks in the extent */
	allocated = ee_len - (iblock - ee_block);		allocated = ee_len - (iblock - ee_block);
	ext_debug("%d fit into %lu:%d -> "E3FSBLK"\n", (int) iblock,		ext_debug("%d fit into %lu:%d -> "E3FSBLK"\n", (int) iblock,
	ee_block, ee_len, newblock);		ee_block, ee_len, newblock);
	@@ -1974,17 +2002,18 @@ int ext4_ext_get_blocks(handle_t handle, struct inode inode,
	}		}

	/*		/*
	* requested block isn't allocated yet		* requested block isn't allocated yet;
	* we couldn't try to create block if create flag is zero		* we couldn't try to create block if create flag is zero
	*/		*/
	if (!create) {		if (!create) {
	/* put just found gap into cache to speedup subsequest reqs */		/* put just found gap into cache to speed up
			* subsequent requests */
	ext4_ext_put_gap_in_cache(inode, path, iblock);		ext4_ext_put_gap_in_cache(inode, path, iblock);
	goto out2;		goto out2;
	}		}
	/*		/*
	* Okay, we need to do block allocation. Lazily initialize the block		* Okay, we need to do block allocation. Lazily initialize the block
	* allocation info here if necessary		* allocation info here if necessary.
	*/		*/
	if (S_ISREG(inode->i_mode) && (!EXT4_I(inode)->i_block_alloc_info))		if (S_ISREG(inode->i_mode) && (!EXT4_I(inode)->i_block_alloc_info))
	ext4_init_block_alloc_info(inode);		ext4_init_block_alloc_info(inode);
	@@ -2062,9 +2091,9 @@ void ext4_ext_truncate(struct inode * inode, struct page *page)
	ext4_ext_invalidate_cache(inode);		ext4_ext_invalidate_cache(inode);

	/*		/*
	* TODO: optimization is possible here		* TODO: optimization is possible here.
	* probably we need not scaning at all,		* Probably we need not scan at all,
	* because page truncation is enough		* because page truncation is enough.
	*/		*/
	if (ext4_orphan_add(handle, inode))		if (ext4_orphan_add(handle, inode))
	goto out_stop;		goto out_stop;
	@@ -2078,13 +2107,13 @@ void ext4_ext_truncate(struct inode * inode, struct page *page)
	err = ext4_ext_remove_space(inode, last_block);		err = ext4_ext_remove_space(inode, last_block);

	/* In a multi-transaction truncate, we only make the final		/* In a multi-transaction truncate, we only make the final
	* transaction synchronous */		* transaction synchronous. */
	if (IS_SYNC(inode))		if (IS_SYNC(inode))
	handle->h_sync = 1;		handle->h_sync = 1;

	out_stop:		out_stop:
	/*		/*
	* If this was a simple ftruncate(), and the file will remain alive		* If this was a simple ftruncate() and the file will remain alive,
	* then we need to clear up the orphan record which we created above.		* then we need to clear up the orphan record which we created above.
	* However, if this was a real unlink then we were called by		* However, if this was a real unlink then we were called by
	* ext4_delete_inode(), and we allow that function to clean up the		* ext4_delete_inode(), and we allow that function to clean up the
	@@ -2098,7 +2127,8 @@ void ext4_ext_truncate(struct inode * inode, struct page *page)
	}		}

	/*		/*
	* this routine calculate max number of blocks we could modify		* ext4_ext_writepage_trans_blocks:
			* calculate max number of blocks we could modify
	* in order to allocate new block for an inode		* in order to allocate new block for an inode
	*/		*/
	int ext4_ext_writepage_trans_blocks(struct inode *inode, int num)		int ext4_ext_writepage_trans_blocks(struct inode *inode, int num)
	@@ -2107,7 +2137,7 @@ int ext4_ext_writepage_trans_blocks(struct inode *inode, int num)

	needed = ext4_ext_calc_credits_for_insert(inode, NULL);		needed = ext4_ext_calc_credits_for_insert(inode, NULL);

	/* caller want to allocate num blocks, but note it includes sb */		/* caller wants to allocate num blocks, but note it includes sb */
	needed = needed * num - (num - 1);		needed = needed * num - (num - 1);

	#ifdef CONFIG_QUOTA		#ifdef CONFIG_QUOTA

include/linux/ext4_fs_extents.h

+27 −27

Original line number	Original line	Diff line number	Diff line
	@@ -22,29 +22,29 @@
	#include <linux/ext4_fs.h>		#include <linux/ext4_fs.h>

	/*		/*
	* with AGRESSIVE_TEST defined capacity of index/leaf blocks		* With AGRESSIVE_TEST defined, the capacity of index/leaf blocks
	* become very little, so index split, in-depth growing and		* becomes very small, so index split, in-depth growing and
	* other hard changes happens much more often		* other hard changes happen much more often.
	* this is for debug purposes only		* This is for debug purposes only.
	*/		*/
	#define AGRESSIVE_TEST_		#define AGRESSIVE_TEST_

	/*		/*
	* with EXTENTS_STATS defined number of blocks and extents		* With EXTENTS_STATS defined, the number of blocks and extents
	* are collected in truncate path. they'll be showed at		* are collected in the truncate path. They'll be shown at
	* umount time		* umount time.
	*/		*/
	#define EXTENTS_STATS__		#define EXTENTS_STATS__

	/*		/*
	* if CHECK_BINSEARCH defined, then results of binary search		* If CHECK_BINSEARCH is defined, then the results of the binary search
	* will be checked by linear search		* will also be checked by linear search.
	*/		*/
	#define CHECK_BINSEARCH__		#define CHECK_BINSEARCH__

	/*		/*
	* if EXT_DEBUG is defined you can use 'extdebug' mount option		* If EXT_DEBUG is defined you can use the 'extdebug' mount option
	* to get lots of info what's going on		* to get lots of info about what's going on.
	*/		*/
	#define EXT_DEBUG__		#define EXT_DEBUG__
	#ifdef EXT_DEBUG		#ifdef EXT_DEBUG
	@@ -54,32 +54,32 @@
	#endif		#endif

	/*		/*
	* if EXT_STATS is defined then stats numbers are collected		* If EXT_STATS is defined then stats numbers are collected.
	* these number will be displayed at umount time		* These number will be displayed at umount time.
	*/		*/
	#define EXT_STATS_		#define EXT_STATS_


	/*		/*
	* ext4_inode has i_block array (60 bytes total)		* ext4_inode has i_block array (60 bytes total).
	* first 12 bytes store ext4_extent_header		* The first 12 bytes store ext4_extent_header;
	* the remain stores array of ext4_extent		* the remainder stores an array of ext4_extent.
	*/		*/

	/*		/*
	* this is extent on-disk structure		* This is the extent on-disk structure.
	* it's used at the bottom of the tree		* It's used at the bottom of the tree.
	*/		*/
	struct ext4_extent {		struct ext4_extent {
	__le32 ee_block; /* first logical block extent covers */		__le32 ee_block; /* first logical block extent covers */
	__le16 ee_len; /* number of blocks covered by extent */		__le16 ee_len; /* number of blocks covered by extent */
	__le16 ee_start_hi; /* high 16 bits of physical block */		__le16 ee_start_hi; /* high 16 bits of physical block */
	__le32 ee_start; /* low 32 bigs of physical block */		__le32 ee_start; /* low 32 bits of physical block */
	};		};

	/*		/*
	* this is index on-disk structure		* This is index on-disk structure.
	* it's used at all the levels, but the bottom		* It's used at all the levels except the bottom.
	*/		*/
	struct ext4_extent_idx {		struct ext4_extent_idx {
	__le32 ei_block; /* index covers logical blocks from 'block' */		__le32 ei_block; /* index covers logical blocks from 'block' */
	@@ -90,22 +90,22 @@ struct ext4_extent_idx {
	};		};

	/*		/*
	* each block (leaves and indexes), even inode-stored has header		* Each block (leaves and indexes), even inode-stored has header.
	*/		*/
	struct ext4_extent_header {		struct ext4_extent_header {
	__le16 eh_magic; /* probably will support different formats */		__le16 eh_magic; /* probably will support different formats */
	__le16 eh_entries; /* number of valid entries */		__le16 eh_entries; /* number of valid entries */
	__le16 eh_max; /* capacity of store in entries */		__le16 eh_max; /* capacity of store in entries */
	__le16 eh_depth; /* has tree real underlaying blocks? */		__le16 eh_depth; /* has tree real underlying blocks? */
	__le32 eh_generation; /* generation of the tree */		__le32 eh_generation; /* generation of the tree */
	};		};

	#define EXT4_EXT_MAGIC cpu_to_le16(0xf30a)		#define EXT4_EXT_MAGIC cpu_to_le16(0xf30a)

	/*		/*
	* array of ext4_ext_path contains path to some extent		* Array of ext4_ext_path contains path to some extent.
	* creation/lookup routines use it for traversal/splitting/etc		* Creation/lookup routines use it for traversal/splitting/etc.
	* truncate uses it to simulate recursive walking		* Truncate uses it to simulate recursive walking.
	*/		*/
	struct ext4_ext_path {		struct ext4_ext_path {
	ext4_fsblk_t p_block;		ext4_fsblk_t p_block;

include/linux/ext4_jbd2.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -29,7 +29,7 @@
	* block to complete the transaction.		* block to complete the transaction.
	*		*
	* For extents-enabled fs we may have to allocate and modify up to		* For extents-enabled fs we may have to allocate and modify up to
	* 5 levels of tree + root which is stored in inode. */		* 5 levels of tree + root which are stored in the inode. */

	#define EXT4_SINGLEDATA_TRANS_BLOCKS(sb) \		#define EXT4_SINGLEDATA_TRANS_BLOCKS(sb) \
	(EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS) \		(EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS) \