reiserfs: cleanup, reformat comments to normal kernel style (098297b2) · Commits · e / devices / android_kernel_fairphone_FP3

fs/reiserfs/bitmap.c

+156 −81

Original line number	Original line	Diff line number	Diff line
	@@ -50,8 +50,10 @@ static inline void get_bit_address(struct super_block *s,
	unsigned int *bmap_nr,		unsigned int *bmap_nr,
	unsigned int *offset)		unsigned int *offset)
	{		{
	/* It is in the bitmap block number equal to the block		/*
	* number divided by the number of bits in a block. */		* It is in the bitmap block number equal to the block
			* number divided by the number of bits in a block.
			*/
	*bmap_nr = block >> (s->s_blocksize_bits + 3);		*bmap_nr = block >> (s->s_blocksize_bits + 3);
	/* Within that bitmap block it is located at bit offset offset. /		/* Within that bitmap block it is located at bit offset offset. /
	*offset = block & ((s->s_blocksize << 3) - 1);		*offset = block & ((s->s_blocksize << 3) - 1);
	@@ -71,8 +73,10 @@ int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)

	get_bit_address(s, block, &bmap, &offset);		get_bit_address(s, block, &bmap, &offset);

	/* Old format filesystem? Unlikely, but the bitmaps are all up front so		/*
	* we need to account for it. */		* Old format filesystem? Unlikely, but the bitmaps are all
			* up front so we need to account for it.
			*/
	if (unlikely(test_bit(REISERFS_OLD_FORMAT,		if (unlikely(test_bit(REISERFS_OLD_FORMAT,
	&(REISERFS_SB(s)->s_properties)))) {		&(REISERFS_SB(s)->s_properties)))) {
	b_blocknr_t bmap1 = REISERFS_SB(s)->s_sbh->b_blocknr + 1;		b_blocknr_t bmap1 = REISERFS_SB(s)->s_sbh->b_blocknr + 1;
	@@ -108,8 +112,11 @@ int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
	return 1;		return 1;
	}		}

	/* searches in journal structures for a given block number (bmap, off). If block		/*
	is found in reiserfs journal it suggests next free block candidate to test. */		* Searches in journal structures for a given block number (bmap, off).
			* If block is found in reiserfs journal it suggests next free block
			* candidate to test.
			*/
	static inline int is_block_in_journal(struct super_block *s, unsigned int bmap,		static inline int is_block_in_journal(struct super_block *s, unsigned int bmap,
	int off, int *next)		int off, int *next)
	{		{
	@@ -129,8 +136,10 @@ static inline int is_block_in_journal(struct super_block *s, unsigned int bmap,
	return 0;		return 0;
	}		}

	/* it searches for a window of zero bits with given minimum and maximum lengths in one bitmap		/*
	* block; */		* Searches for a window of zero bits with given minimum and maximum
			* lengths in one bitmap block
			*/
	static int scan_bitmap_block(struct reiserfs_transaction_handle *th,		static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
	unsigned int bmap_n, int *beg, int boundary,		unsigned int bmap_n, int *beg, int boundary,
	int min, int max, int unfm)		int min, int max, int unfm)
	@@ -146,10 +155,6 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
	RFALSE(bmap_n >= reiserfs_bmap_count(s), "Bitmap %u is out of "		RFALSE(bmap_n >= reiserfs_bmap_count(s), "Bitmap %u is out of "
	"range (0..%u)", bmap_n, reiserfs_bmap_count(s) - 1);		"range (0..%u)", bmap_n, reiserfs_bmap_count(s) - 1);
	PROC_INFO_INC(s, scan_bitmap.bmap);		PROC_INFO_INC(s, scan_bitmap.bmap);
	/* this is unclear and lacks comments, explain how journal bitmaps
	work here for the reader. Convey a sense of the design here. What
	is a window? */
	/* - I mean `a window of zero bits' as in description of this function - Zam. */

	if (!bi) {		if (!bi) {
	reiserfs_error(s, "jdm-4055", "NULL bitmap info pointer "		reiserfs_error(s, "jdm-4055", "NULL bitmap info pointer "
	@@ -165,15 +170,18 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
	cont:		cont:
	if (bi->free_count < min) {		if (bi->free_count < min) {
	brelse(bh);		brelse(bh);
	return 0; // No free blocks in this bitmap		return 0; /* No free blocks in this bitmap */
	}		}

	/* search for a first zero bit -- beginning of a window */		/* search for a first zero bit -- beginning of a window */
	*beg = reiserfs_find_next_zero_le_bit		*beg = reiserfs_find_next_zero_le_bit
	((unsigned long )(bh->b_data), boundary, beg);		((unsigned long )(bh->b_data), boundary, beg);

	if (beg + min > boundary) { / search for a zero bit fails or the rest of bitmap block		/*
	* cannot contain a zero window of minimum size */		* search for a zero bit fails or the rest of bitmap block
			* cannot contain a zero window of minimum size
			*/
			if (*beg + min > boundary) {
	brelse(bh);		brelse(bh);
	return 0;		return 0;
	}		}
	@@ -187,37 +195,63 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
	next = end;		next = end;
	break;		break;
	}		}
	/* finding the other end of zero bit window requires looking into journal structures (in
	* case of searching for free blocks for unformatted nodes) */		/*
			* finding the other end of zero bit window requires
			* looking into journal structures (in case of
			* searching for free blocks for unformatted nodes)
			*/
	if (unfm && is_block_in_journal(s, bmap_n, end, &next))		if (unfm && is_block_in_journal(s, bmap_n, end, &next))
	break;		break;
	}		}

	/* now (*beg) points to beginning of zero bits window,		/*
	* (end) points to one bit after the window end */		* now (*beg) points to beginning of zero bits window,
	if (end - beg >= min) { / it seems we have found window of proper size */		* (end) points to one bit after the window end
			*/

			/* found window of proper size */
			if (end - *beg >= min) {
	int i;		int i;
	reiserfs_prepare_for_journal(s, bh, 1);		reiserfs_prepare_for_journal(s, bh, 1);
	/* try to set all blocks used checking are they still free */		/*
			* try to set all blocks used checking are
			* they still free
			*/
	for (i = *beg; i < end; i++) {		for (i = *beg; i < end; i++) {
	/* It seems that we should not check in journal again. */		/* Don't check in journal again. */
	if (reiserfs_test_and_set_le_bit		if (reiserfs_test_and_set_le_bit
	(i, bh->b_data)) {		(i, bh->b_data)) {
	/* bit was set by another process		/*
	* while we slept in prepare_for_journal() */		* bit was set by another process while
			* we slept in prepare_for_journal()
			*/
	PROC_INFO_INC(s, scan_bitmap.stolen);		PROC_INFO_INC(s, scan_bitmap.stolen);
	if (i >= beg + min) { / we can continue with smaller set of allocated blocks,
	* if length of this set is more or equal to `min' */		/*
			* we can continue with smaller set
			* of allocated blocks, if length of
			* this set is more or equal to `min'
			*/
			if (i >= *beg + min) {
	end = i;		end = i;
	break;		break;
	}		}
	/* otherwise we clear all bit were set ... */
			/*
			* otherwise we clear all bit
			* were set ...
			*/
	while (--i >= *beg)		while (--i >= *beg)
	reiserfs_clear_le_bit		reiserfs_clear_le_bit
	(i, bh->b_data);		(i, bh->b_data);
	reiserfs_restore_prepared_buffer(s, bh);		reiserfs_restore_prepared_buffer(s, bh);
	*beg = org;		*beg = org;
	/* ... and search again in current block from beginning */
			/*
			* Search again in current block
			* from beginning
			*/
	goto cont;		goto cont;
	}		}
	}		}
	@@ -268,11 +302,13 @@ static inline int block_group_used(struct super_block *s, u32 id)
	int bm = bmap_hash_id(s, id);		int bm = bmap_hash_id(s, id);
	struct reiserfs_bitmap_info *info = &SB_AP_BITMAP(s)[bm];		struct reiserfs_bitmap_info *info = &SB_AP_BITMAP(s)[bm];

	/* If we don't have cached information on this bitmap block, we're		/*
			* If we don't have cached information on this bitmap block, we're
	* going to have to load it later anyway. Loading it here allows us		* going to have to load it later anyway. Loading it here allows us
	* to make a better decision. This favors long-term performance gain		* to make a better decision. This favors long-term performance gain
	* with a better on-disk layout vs. a short term gain of skipping the		* with a better on-disk layout vs. a short term gain of skipping the
	* read and potentially having a bad placement. */		* read and potentially having a bad placement.
			*/
	if (info->free_count == UINT_MAX) {		if (info->free_count == UINT_MAX) {
	struct buffer_head *bh = reiserfs_read_bitmap_block(s, bm);		struct buffer_head *bh = reiserfs_read_bitmap_block(s, bm);
	brelse(bh);		brelse(bh);
	@@ -305,17 +341,16 @@ __le32 reiserfs_choose_packing(struct inode * dir)
	return packing;		return packing;
	}		}

	/* Tries to find contiguous zero bit window (given size) in given region of		/*
	* bitmap and place new blocks there. Returns number of allocated blocks. */		* Tries to find contiguous zero bit window (given size) in given region of
			* bitmap and place new blocks there. Returns number of allocated blocks.
			*/
	static int scan_bitmap(struct reiserfs_transaction_handle *th,		static int scan_bitmap(struct reiserfs_transaction_handle *th,
	b_blocknr_t * start, b_blocknr_t finish,		b_blocknr_t * start, b_blocknr_t finish,
	int min, int max, int unfm, sector_t file_block)		int min, int max, int unfm, sector_t file_block)
	{		{
	int nr_allocated = 0;		int nr_allocated = 0;
	struct super_block *s = th->t_super;		struct super_block *s = th->t_super;
	/* find every bm and bmap and bmap_nr in this file, and change them all to bitmap_blocknr
	* - Hans, it is not a block number - Zam. */

	unsigned int bm, off;		unsigned int bm, off;
	unsigned int end_bm, end_off;		unsigned int end_bm, end_off;
	unsigned int off_max = s->s_blocksize << 3;		unsigned int off_max = s->s_blocksize << 3;
	@@ -323,8 +358,10 @@ static int scan_bitmap(struct reiserfs_transaction_handle *th,
	BUG_ON(!th->t_trans_id);		BUG_ON(!th->t_trans_id);

	PROC_INFO_INC(s, scan_bitmap.call);		PROC_INFO_INC(s, scan_bitmap.call);

			/* No point in looking for more free blocks */
	if (SB_FREE_BLOCKS(s) <= 0)		if (SB_FREE_BLOCKS(s) <= 0)
	return 0; // No point in looking for more free blocks		return 0;

	get_bit_address(s, *start, &bm, &off);		get_bit_address(s, *start, &bm, &off);
	get_bit_address(s, finish, &end_bm, &end_off);		get_bit_address(s, finish, &end_bm, &end_off);
	@@ -333,7 +370,8 @@ static int scan_bitmap(struct reiserfs_transaction_handle *th,
	if (end_bm > reiserfs_bmap_count(s))		if (end_bm > reiserfs_bmap_count(s))
	end_bm = reiserfs_bmap_count(s);		end_bm = reiserfs_bmap_count(s);

	/* When the bitmap is more than 10% free, anyone can allocate.		/*
			* When the bitmap is more than 10% free, anyone can allocate.
	* When it's less than 10% free, only files that already use the		* When it's less than 10% free, only files that already use the
	* bitmap are allowed. Once we pass 80% full, this restriction		* bitmap are allowed. Once we pass 80% full, this restriction
	* is lifted.		* is lifted.
	@@ -532,7 +570,8 @@ int reiserfs_parse_alloc_options(struct super_block s, char options)
	{		{
	char this_char, value;		char this_char, value;

	REISERFS_SB(s)->s_alloc_options.bits = 0; /* clear default settings */		/* clear default settings */
			REISERFS_SB(s)->s_alloc_options.bits = 0;

	while ((this_char = strsep(&options, ":")) != NULL) {		while ((this_char = strsep(&options, ":")) != NULL) {
	if ((value = strchr(this_char, '=')) != NULL)		if ((value = strchr(this_char, '=')) != NULL)
	@@ -733,7 +772,7 @@ static inline void new_hashed_relocation(reiserfs_blocknr_hint_t * hint)
	hash_in = (char *)&hint->key.k_dir_id;		hash_in = (char *)&hint->key.k_dir_id;
	} else {		} else {
	if (!hint->inode) {		if (!hint->inode) {
	//hint->search_start = hint->beg;		/hint->search_start = hint->beg;/
	hash_in = (char *)&hint->key.k_dir_id;		hash_in = (char *)&hint->key.k_dir_id;
	} else		} else
	if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))		if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
	@@ -786,7 +825,8 @@ static void oid_groups(reiserfs_blocknr_hint_t * hint)

	dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);		dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);

	/* keep the root dir and it's first set of subdirs close to		/*
			* keep the root dir and it's first set of subdirs close to
	* the start of the disk		* the start of the disk
	*/		*/
	if (dirid <= 2)		if (dirid <= 2)
	@@ -800,7 +840,8 @@ static void oid_groups(reiserfs_blocknr_hint_t * hint)
	}		}
	}		}

	/* returns 1 if it finds an indirect item and gets valid hint info		/*
			* returns 1 if it finds an indirect item and gets valid hint info
	* from it, otherwise 0		* from it, otherwise 0
	*/		*/
	static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)		static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
	@@ -812,8 +853,11 @@ static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
	__le32 *item;		__le32 *item;
	int ret = 0;		int ret = 0;

	if (!hint->path) /* reiserfs code can call this function w/o pointer to path		/*
	* structure supplied; then we rely on supplied search_start */		* reiserfs code can call this function w/o pointer to path
			* structure supplied; then we rely on supplied search_start
			*/
			if (!hint->path)
	return 0;		return 0;

	path = hint->path;		path = hint->path;
	@@ -825,12 +869,13 @@ static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)

	hint->search_start = bh->b_blocknr;		hint->search_start = bh->b_blocknr;

			/*
			* for indirect item: go to left and look for the first non-hole entry
			* in the indirect item
			*/
	if (!hint->formatted_node && is_indirect_le_ih(ih)) {		if (!hint->formatted_node && is_indirect_le_ih(ih)) {
	/* for indirect item: go to left and look for the first non-hole entry
	in the indirect item */
	if (pos_in_item == I_UNFM_NUM(ih))		if (pos_in_item == I_UNFM_NUM(ih))
	pos_in_item--;		pos_in_item--;
	// pos_in_item = I_UNFM_NUM (ih) - 1;
	while (pos_in_item >= 0) {		while (pos_in_item >= 0) {
	int t = get_block_num(item, pos_in_item);		int t = get_block_num(item, pos_in_item);
	if (t) {		if (t) {
	@@ -846,10 +891,12 @@ static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
	return ret;		return ret;
	}		}

	/* should be, if formatted node, then try to put on first part of the device		/*
	specified as number of percent with mount option device, else try to put		* should be, if formatted node, then try to put on first part of the device
	on last of device. This is not to say it is good code to do so,		* specified as number of percent with mount option device, else try to put
	but the effect should be measured. */		* on last of device. This is not to say it is good code to do so,
			* but the effect should be measured.
			*/
	static inline void set_border_in_hint(struct super_block *s,		static inline void set_border_in_hint(struct super_block *s,
	reiserfs_blocknr_hint_t * hint)		reiserfs_blocknr_hint_t * hint)
	{		{
	@@ -975,21 +1022,27 @@ static void determine_search_start(reiserfs_blocknr_hint_t * hint,
	set_border_in_hint(s, hint);		set_border_in_hint(s, hint);

	#ifdef DISPLACE_NEW_PACKING_LOCALITIES		#ifdef DISPLACE_NEW_PACKING_LOCALITIES
	/* whenever we create a new directory, we displace it. At first we will		/*
	hash for location, later we might look for a moderately empty place for		* whenever we create a new directory, we displace it. At first
	it */		* we will hash for location, later we might look for a moderately
			* empty place for it
			*/
	if (displacing_new_packing_localities(s)		if (displacing_new_packing_localities(s)
	&& hint->th->displace_new_blocks) {		&& hint->th->displace_new_blocks) {
	displace_new_packing_locality(hint);		displace_new_packing_locality(hint);

	/* we do not continue determine_search_start,		/*
	* if new packing locality is being displaced */		* we do not continue determine_search_start,
			* if new packing locality is being displaced
			*/
	return;		return;
	}		}
	#endif		#endif

	/* all persons should feel encouraged to add more special cases here and		/*
	* test them */		* all persons should feel encouraged to add more special cases
			* here and test them
			*/

	if (displacing_large_files(s) && !hint->formatted_node		if (displacing_large_files(s) && !hint->formatted_node
	&& this_blocknr_allocation_would_make_it_a_large_file(hint)) {		&& this_blocknr_allocation_would_make_it_a_large_file(hint)) {
	@@ -997,8 +1050,10 @@ static void determine_search_start(reiserfs_blocknr_hint_t * hint,
	return;		return;
	}		}

	/* if none of our special cases is relevant, use the left neighbor in the		/*
	tree order of the new node we are allocating for */		* if none of our special cases is relevant, use the left
			* neighbor in the tree order of the new node we are allocating for
			*/
	if (hint->formatted_node && TEST_OPTION(hashed_formatted_nodes, s)) {		if (hint->formatted_node && TEST_OPTION(hashed_formatted_nodes, s)) {
	hash_formatted_node(hint);		hash_formatted_node(hint);
	return;		return;
	@@ -1006,10 +1061,13 @@ static void determine_search_start(reiserfs_blocknr_hint_t * hint,

	unfm_hint = get_left_neighbor(hint);		unfm_hint = get_left_neighbor(hint);

	/* Mimic old block allocator behaviour, that is if VFS allowed for preallocation,		/*
	new blocks are displaced based on directory ID. Also, if suggested search_start		* Mimic old block allocator behaviour, that is if VFS allowed for
	is less than last preallocated block, we start searching from it, assuming that		* preallocation, new blocks are displaced based on directory ID.
	HDD dataflow is faster in forward direction */		* Also, if suggested search_start is less than last preallocated
			* block, we start searching from it, assuming that HDD dataflow
			* is faster in forward direction
			*/
	if (TEST_OPTION(old_way, s)) {		if (TEST_OPTION(old_way, s)) {
	if (!hint->formatted_node) {		if (!hint->formatted_node) {
	if (!reiserfs_hashed_relocation(s))		if (!reiserfs_hashed_relocation(s))
	@@ -1038,11 +1096,13 @@ static void determine_search_start(reiserfs_blocknr_hint_t * hint,
	TEST_OPTION(old_hashed_relocation, s)) {		TEST_OPTION(old_hashed_relocation, s)) {
	old_hashed_relocation(hint);		old_hashed_relocation(hint);
	}		}

	/* new_hashed_relocation works with both formatted/unformatted nodes */		/* new_hashed_relocation works with both formatted/unformatted nodes */
	if ((!unfm_hint \|\| hint->formatted_node) &&		if ((!unfm_hint \|\| hint->formatted_node) &&
	TEST_OPTION(new_hashed_relocation, s)) {		TEST_OPTION(new_hashed_relocation, s)) {
	new_hashed_relocation(hint);		new_hashed_relocation(hint);
	}		}

	/* dirid grouping works only on unformatted nodes */		/* dirid grouping works only on unformatted nodes */
	if (!unfm_hint && !hint->formatted_node && TEST_OPTION(dirid_groups, s)) {		if (!unfm_hint && !hint->formatted_node && TEST_OPTION(dirid_groups, s)) {
	dirid_groups(hint);		dirid_groups(hint);
	@@ -1080,8 +1140,6 @@ static int determine_prealloc_size(reiserfs_blocknr_hint_t * hint)
	return CARRY_ON;		return CARRY_ON;
	}		}

	/* XXX I know it could be merged with upper-level function;
	but may be result function would be too complex. */
	static inline int allocate_without_wrapping_disk(reiserfs_blocknr_hint_t * hint,		static inline int allocate_without_wrapping_disk(reiserfs_blocknr_hint_t * hint,
	b_blocknr_t * new_blocknrs,		b_blocknr_t * new_blocknrs,
	b_blocknr_t start,		b_blocknr_t start,
	@@ -1109,7 +1167,10 @@ static inline int allocate_without_wrapping_disk(reiserfs_blocknr_hint_t * hint,

	/* do we have something to fill prealloc. array also ? */		/* do we have something to fill prealloc. array also ? */
	if (nr_allocated > 0) {		if (nr_allocated > 0) {
	/* it means prealloc_size was greater that 0 and we do preallocation */		/*
			* it means prealloc_size was greater that 0 and
			* we do preallocation
			*/
	list_add(&REISERFS_I(hint->inode)->i_prealloc_list,		list_add(&REISERFS_I(hint->inode)->i_prealloc_list,
	&SB_JOURNAL(hint->th->t_super)->		&SB_JOURNAL(hint->th->t_super)->
	j_prealloc_list);		j_prealloc_list);
	@@ -1177,7 +1238,8 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
	start = 0;		start = 0;
	finish = hint->beg;		finish = hint->beg;
	break;		break;
	default: /* We've tried searching everywhere, not enough space */		default:
			/* We've tried searching everywhere, not enough space */
	/* Free the blocks */		/* Free the blocks */
	if (!hint->formatted_node) {		if (!hint->formatted_node) {
	#ifdef REISERQUOTA_DEBUG		#ifdef REISERQUOTA_DEBUG
	@@ -1262,8 +1324,11 @@ static int use_preallocated_list_if_available(reiserfs_blocknr_hint_t * hint,
	return amount_needed;		return amount_needed;
	}		}

	int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t * hint, b_blocknr_t * new_blocknrs, int amount_needed, int reserved_by_us /* Amount of blocks we have		int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *hint,
	already reserved */ )		b_blocknr_t *new_blocknrs,
			int amount_needed,
			/* Amount of blocks we have already reserved */
			int reserved_by_us)
	{		{
	int initial_amount_needed = amount_needed;		int initial_amount_needed = amount_needed;
	int ret;		int ret;
	@@ -1275,15 +1340,21 @@ int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t * hint, b_blocknr_t * new
	return NO_DISK_SPACE;		return NO_DISK_SPACE;
	/* should this be if !hint->inode && hint->preallocate? */		/* should this be if !hint->inode && hint->preallocate? */
	/* do you mean hint->formatted_node can be removed ? - Zam */		/* do you mean hint->formatted_node can be removed ? - Zam */
	/* hint->formatted_node cannot be removed because we try to access		/*
	inode information here, and there is often no inode assotiated with		* hint->formatted_node cannot be removed because we try to access
	metadata allocations - green */		* inode information here, and there is often no inode associated with
			* metadata allocations - green
			*/

	if (!hint->formatted_node && hint->preallocate) {		if (!hint->formatted_node && hint->preallocate) {
	amount_needed = use_preallocated_list_if_available		amount_needed = use_preallocated_list_if_available
	(hint, new_blocknrs, amount_needed);		(hint, new_blocknrs, amount_needed);
	if (amount_needed == 0) /* all blocknrs we need we got from
	prealloc. list */		/*
			* We have all the block numbers we need from the
			* prealloc list
			*/
			if (amount_needed == 0)
	return CARRY_ON;		return CARRY_ON;
	new_blocknrs += (initial_amount_needed - amount_needed);		new_blocknrs += (initial_amount_needed - amount_needed);
	}		}
	@@ -1297,10 +1368,12 @@ int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t * hint, b_blocknr_t * new
	ret = blocknrs_and_prealloc_arrays_from_search_start		ret = blocknrs_and_prealloc_arrays_from_search_start
	(hint, new_blocknrs, amount_needed);		(hint, new_blocknrs, amount_needed);

	/* we used prealloc. list to fill (partially) new_blocknrs array. If final allocation fails we		/*
	* need to return blocks back to prealloc. list or just free them. -- Zam (I chose second		* We used prealloc. list to fill (partially) new_blocknrs array.
	* variant) */		* If final allocation fails we need to return blocks back to
			* prealloc. list or just free them. -- Zam (I chose second
			* variant)
			*/
	if (ret != CARRY_ON) {		if (ret != CARRY_ON) {
	while (amount_needed++ < initial_amount_needed) {		while (amount_needed++ < initial_amount_needed) {
	reiserfs_free_block(hint->th, hint->inode,		reiserfs_free_block(hint->th, hint->inode,
	@@ -1339,8 +1412,10 @@ struct buffer_head reiserfs_read_bitmap_block(struct super_block sb,
	struct reiserfs_bitmap_info *info = SB_AP_BITMAP(sb) + bitmap;		struct reiserfs_bitmap_info *info = SB_AP_BITMAP(sb) + bitmap;
	struct buffer_head *bh;		struct buffer_head *bh;

	/* Way old format filesystems had the bitmaps packed up front.		/*
	* I doubt there are any of these left, but just in case... */		* Way old format filesystems had the bitmaps packed up front.
			* I doubt there are any of these left, but just in case...
			*/
	if (unlikely(test_bit(REISERFS_OLD_FORMAT,		if (unlikely(test_bit(REISERFS_OLD_FORMAT,
	&(REISERFS_SB(sb)->s_properties))))		&(REISERFS_SB(sb)->s_properties))))
	block = REISERFS_SB(sb)->s_sbh->b_blocknr + 1 + bitmap;		block = REISERFS_SB(sb)->s_sbh->b_blocknr + 1 + bitmap;

fs/reiserfs/dir.c

+52 −25

Original line number	Original line	Diff line number	Diff line
	@@ -59,7 +59,10 @@ static inline bool is_privroot_deh(struct inode dir, struct reiserfs_de_head d

	int reiserfs_readdir_inode(struct inode inode, struct dir_context ctx)		int reiserfs_readdir_inode(struct inode inode, struct dir_context ctx)
	{		{
	struct cpu_key pos_key; /* key of current position in the directory (key of directory entry) */
			/* key of current position in the directory (key of directory entry) */
			struct cpu_key pos_key;

	INITIALIZE_PATH(path_to_entry);		INITIALIZE_PATH(path_to_entry);
	struct buffer_head *bh;		struct buffer_head *bh;
	int item_num, entry_num;		int item_num, entry_num;
	@@ -77,21 +80,28 @@ int reiserfs_readdir_inode(struct inode inode, struct dir_context ctx)

	reiserfs_check_lock_depth(inode->i_sb, "readdir");		reiserfs_check_lock_depth(inode->i_sb, "readdir");

	/* form key for search the next directory entry using f_pos field of		/*
	file structure */		* form key for search the next directory entry using
			* f_pos field of file structure
			*/
	make_cpu_key(&pos_key, inode, ctx->pos ?: DOT_OFFSET, TYPE_DIRENTRY, 3);		make_cpu_key(&pos_key, inode, ctx->pos ?: DOT_OFFSET, TYPE_DIRENTRY, 3);
	next_pos = cpu_key_k_offset(&pos_key);		next_pos = cpu_key_k_offset(&pos_key);

	path_to_entry.reada = PATH_READA;		path_to_entry.reada = PATH_READA;
	while (1) {		while (1) {
	research:		research:
	/* search the directory item, containing entry with specified key */		/*
			* search the directory item, containing entry with
			* specified key
			*/
	search_res =		search_res =
	search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,		search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,
	&de);		&de);
	if (search_res == IO_ERROR) {		if (search_res == IO_ERROR) {
	// FIXME: we could just skip part of directory which could		/*
	// not be read		* FIXME: we could just skip part of directory
			* which could not be read
			*/
	ret = -EIO;		ret = -EIO;
	goto out;		goto out;
	}		}
	@@ -109,14 +119,20 @@ int reiserfs_readdir_inode(struct inode inode, struct dir_context ctx)
	"vs-9005 item_num == %d, item amount == %d",		"vs-9005 item_num == %d, item amount == %d",
	item_num, B_NR_ITEMS(bh));		item_num, B_NR_ITEMS(bh));

	/* and entry must be not more than number of entries in the item */		/*
			* and entry must be not more than number of entries
			* in the item
			*/
	RFALSE(ih_entry_count(ih) < entry_num,		RFALSE(ih_entry_count(ih) < entry_num,
	"vs-9010: entry number is too big %d (%d)",		"vs-9010: entry number is too big %d (%d)",
	entry_num, ih_entry_count(ih));		entry_num, ih_entry_count(ih));

			/*
			* go through all entries in the directory item beginning
			* from the entry, that has been found
			*/
	if (search_res == POSITION_FOUND		if (search_res == POSITION_FOUND
	\|\| entry_num < ih_entry_count(ih)) {		\|\| entry_num < ih_entry_count(ih)) {
	/* go through all entries in the directory item beginning from the entry, that has been found */
	struct reiserfs_de_head *deh =		struct reiserfs_de_head *deh =
	B_I_DEH(bh, ih) + entry_num;		B_I_DEH(bh, ih) + entry_num;

	@@ -127,16 +143,18 @@ int reiserfs_readdir_inode(struct inode inode, struct dir_context ctx)
	ino_t d_ino;		ino_t d_ino;
	loff_t cur_pos = deh_offset(deh);		loff_t cur_pos = deh_offset(deh);

	if (!de_visible(deh))
	/* it is hidden entry */		/* it is hidden entry */
			if (!de_visible(deh))
	continue;		continue;
	d_reclen = entry_length(bh, ih, entry_num);		d_reclen = entry_length(bh, ih, entry_num);
	d_name = B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh);		d_name = B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh);

	if (d_reclen <= 0 \|\|		if (d_reclen <= 0 \|\|
	d_name + d_reclen > bh->b_data + bh->b_size) {		d_name + d_reclen > bh->b_data + bh->b_size) {
	/* There is corrupted data in entry,		/*
	* We'd better stop here */		* There is corrupted data in entry,
			* We'd better stop here
			*/
	pathrelse(&path_to_entry);		pathrelse(&path_to_entry);
	ret = -EIO;		ret = -EIO;
	goto out;		goto out;
	@@ -145,10 +163,10 @@ int reiserfs_readdir_inode(struct inode inode, struct dir_context ctx)
	if (!d_name[d_reclen - 1])		if (!d_name[d_reclen - 1])
	d_reclen = strlen(d_name);		d_reclen = strlen(d_name);

			/* too big to send back to VFS */
	if (d_reclen >		if (d_reclen >
	REISERFS_MAX_NAME(inode->i_sb->		REISERFS_MAX_NAME(inode->i_sb->
	s_blocksize)) {		s_blocksize)) {
	/* too big to send back to VFS */
	continue;		continue;
	}		}

	@@ -173,10 +191,14 @@ int reiserfs_readdir_inode(struct inode inode, struct dir_context ctx)
	goto research;		goto research;
	}		}
	}		}
	// Note, that we copy name to user space via temporary
	// buffer (local_buf) because filldir will block if		/*
	// user space buffer is swapped out. At that time		* Note, that we copy name to user space via
	// entry can move to somewhere else		* temporary buffer (local_buf) because
			* filldir will block if user space buffer is
			* swapped out. At that time entry can move to
			* somewhere else
			*/
	memcpy(local_buf, d_name, d_reclen);		memcpy(local_buf, d_name, d_reclen);

	/*		/*
	@@ -209,22 +231,26 @@ int reiserfs_readdir_inode(struct inode inode, struct dir_context ctx)
	} /* for */		} /* for */
	}		}

			/* end of directory has been reached */
	if (item_num != B_NR_ITEMS(bh) - 1)		if (item_num != B_NR_ITEMS(bh) - 1)
	// end of directory has been reached
	goto end;		goto end;

	/* item we went through is last item of node. Using right		/*
	delimiting key check is it directory end */		* item we went through is last item of node. Using right
			* delimiting key check is it directory end
			*/
	rkey = get_rkey(&path_to_entry, inode->i_sb);		rkey = get_rkey(&path_to_entry, inode->i_sb);
	if (!comp_le_keys(rkey, &MIN_KEY)) {		if (!comp_le_keys(rkey, &MIN_KEY)) {
	/* set pos_key to key, that is the smallest and greater		/*
	that key of the last entry in the item */		* set pos_key to key, that is the smallest and greater
			* that key of the last entry in the item
			*/
	set_cpu_key_k_offset(&pos_key, next_pos);		set_cpu_key_k_offset(&pos_key, next_pos);
	continue;		continue;
	}		}

			/* end of directory has been reached */
	if (COMP_SHORT_KEYS(rkey, &pos_key)) {		if (COMP_SHORT_KEYS(rkey, &pos_key)) {
	// end of directory has been reached
	goto end;		goto end;
	}		}

	@@ -248,9 +274,10 @@ static int reiserfs_readdir(struct file file, struct dir_context ctx)
	return reiserfs_readdir_inode(file_inode(file), ctx);		return reiserfs_readdir_inode(file_inode(file), ctx);
	}		}

	/* compose directory item containing "." and ".." entries (entries are		/*
	not aligned to 4 byte boundary) */		* compose directory item containing "." and ".." entries (entries are
	/* the last four params are LE */		* not aligned to 4 byte boundary)
			*/
	void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,		void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,
	__le32 par_dirid, __le32 par_objid)		__le32 par_dirid, __le32 par_objid)
	{		{

fs/reiserfs/do_balan.c

+154 −122

File changed.

Preview size limit exceeded, changes collapsed.

fs/reiserfs/file.c

+35 −27

Original line number	Original line	Diff line number	Diff line
	@@ -15,19 +15,19 @@
	#include <linux/quotaops.h>		#include <linux/quotaops.h>

	/*		/*
	** We pack the tails of files on file close, not at the time they are written.		* We pack the tails of files on file close, not at the time they are written.
	** This implies an unnecessary copy of the tail and an unnecessary indirect item		* This implies an unnecessary copy of the tail and an unnecessary indirect item
	** insertion/balancing, for files that are written in one write.		* insertion/balancing, for files that are written in one write.
	** It avoids unnecessary tail packings (balances) for files that are written in		* It avoids unnecessary tail packings (balances) for files that are written in
	** multiple writes and are small enough to have tails.		* multiple writes and are small enough to have tails.
	**		*
	** file_release is called by the VFS layer when the file is closed. If		* file_release is called by the VFS layer when the file is closed. If
	** this is the last open file descriptor, and the file		* this is the last open file descriptor, and the file
	** small enough to have a tail, and the tail is currently in an		* small enough to have a tail, and the tail is currently in an
	** unformatted node, the tail is converted back into a direct item.		* unformatted node, the tail is converted back into a direct item.
	**		*
	** We use reiserfs_truncate_file to pack the tail, since it already has		* We use reiserfs_truncate_file to pack the tail, since it already has
	** all the conditions coded.		* all the conditions coded.
	*/		*/
	static int reiserfs_file_release(struct inode inode, struct file filp)		static int reiserfs_file_release(struct inode inode, struct file filp)
	{		{
	@@ -57,14 +57,16 @@ static int reiserfs_file_release(struct inode inode, struct file filp)
	}		}

	reiserfs_write_lock(inode->i_sb);		reiserfs_write_lock(inode->i_sb);
	/* freeing preallocation only involves relogging blocks that		/*
			* freeing preallocation only involves relogging blocks that
	* are already in the current transaction. preallocation gets		* are already in the current transaction. preallocation gets
	* freed at the end of each transaction, so it is impossible for		* freed at the end of each transaction, so it is impossible for
	* us to log any additional blocks (including quota blocks)		* us to log any additional blocks (including quota blocks)
	*/		*/
	err = journal_begin(&th, inode->i_sb, 1);		err = journal_begin(&th, inode->i_sb, 1);
	if (err) {		if (err) {
	/* uh oh, we can't allow the inode to go away while there		/*
			* uh oh, we can't allow the inode to go away while there
	* is still preallocation blocks pending. Try to join the		* is still preallocation blocks pending. Try to join the
	* aborted transaction		* aborted transaction
	*/		*/
	@@ -72,11 +74,13 @@ static int reiserfs_file_release(struct inode inode, struct file filp)
	err = journal_join_abort(&th, inode->i_sb, 1);		err = journal_join_abort(&th, inode->i_sb, 1);

	if (err) {		if (err) {
	/* hmpf, our choices here aren't good. We can pin the inode		/*
	* which will disallow unmount from every happening, we can		* hmpf, our choices here aren't good. We can pin
	* do nothing, which will corrupt random memory on unmount,		* the inode which will disallow unmount from ever
	* or we can forcibly remove the file from the preallocation		* happening, we can do nothing, which will corrupt
	* list, which will leak blocks on disk. Lets pin the inode		* random memory on unmount, or we can forcibly
			* remove the file from the preallocation list, which
			* will leak blocks on disk. Lets pin the inode
	* and let the admin know what is going on.		* and let the admin know what is going on.
	*/		*/
	igrab(inode);		igrab(inode);
	@@ -102,10 +106,12 @@ static int reiserfs_file_release(struct inode inode, struct file filp)
	(REISERFS_I(inode)->i_flags & i_pack_on_close_mask) &&		(REISERFS_I(inode)->i_flags & i_pack_on_close_mask) &&
	tail_has_to_be_packed(inode)) {		tail_has_to_be_packed(inode)) {

	/* if regular file is released by last holder and it has been		/*
	appended (we append by unformatted node only) or its direct		* if regular file is released by last holder and it has been
	item(s) had to be converted, then it may have to be		* appended (we append by unformatted node only) or its direct
	indirect2direct converted */		* item(s) had to be converted, then it may have to be
			* indirect2direct converted
			*/
	err = reiserfs_truncate_file(inode, 0);		err = reiserfs_truncate_file(inode, 0);
	}		}
	out:		out:
	@@ -117,8 +123,9 @@ static int reiserfs_file_release(struct inode inode, struct file filp)
	static int reiserfs_file_open(struct inode inode, struct file file)		static int reiserfs_file_open(struct inode inode, struct file file)
	{		{
	int err = dquot_file_open(inode, file);		int err = dquot_file_open(inode, file);
	if (!atomic_inc_not_zero(&REISERFS_I(inode)->openers)) {
	/* somebody might be tailpacking on final close; wait for it */		/* somebody might be tailpacking on final close; wait for it */
			if (!atomic_inc_not_zero(&REISERFS_I(inode)->openers)) {
	mutex_lock(&(REISERFS_I(inode)->tailpack));		mutex_lock(&(REISERFS_I(inode)->tailpack));
	atomic_inc(&REISERFS_I(inode)->openers);		atomic_inc(&REISERFS_I(inode)->openers);
	mutex_unlock(&(REISERFS_I(inode)->tailpack));		mutex_unlock(&(REISERFS_I(inode)->tailpack));
	@@ -208,7 +215,8 @@ int reiserfs_commit_page(struct inode inode, struct page page,
	journal_mark_dirty(&th, s, bh);		journal_mark_dirty(&th, s, bh);
	} else if (!buffer_dirty(bh)) {		} else if (!buffer_dirty(bh)) {
	mark_buffer_dirty(bh);		mark_buffer_dirty(bh);
	/* do data=ordered on any page past the end		/*
			* do data=ordered on any page past the end
	* of file and any buffer marked BH_New.		* of file and any buffer marked BH_New.
	*/		*/
	if (reiserfs_data_ordered(inode->i_sb) &&		if (reiserfs_data_ordered(inode->i_sb) &&

fs/reiserfs/fix_node.c

+598 −369

File changed.

Preview size limit exceeded, changes collapsed.