Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 57042651 authored by Theodore Ts'o's avatar Theodore Ts'o
Browse files

ext4: convert s_{dirty,free}blocks_counter to s_{dirty,free}clusters_counter 



Convert the percpu counters s_dirtyblocks_counter and
s_freeblocks_counter in struct ext4_super_info to be
s_dirtyclusters_counter and s_freeclusters_counter.

Signed-off-by: default avatar"Theodore Ts'o" <tytso@mit.edu>
parent 0aa06000

fs/ext4/balloc.c

+5 −5
Original line number Diff line number Diff line
@@ -414,16 +414,16 @@ static int ext4_has_free_blocks(struct ext4_sb_info *sbi, 
				s64 nblocks, unsigned int flags)

{

	s64 free_blocks, dirty_blocks, root_blocks;

	struct percpu_counter *fbc = &sbi->s_freeblocks_counter;

	struct percpu_counter *dbc = &sbi->s_dirtyblocks_counter;

	struct percpu_counter *fcc = &sbi->s_freeclusters_counter;

	struct percpu_counter *dbc = &sbi->s_dirtyclusters_counter;



	free_blocks  = percpu_counter_read_positive(fbc);

	free_blocks  = percpu_counter_read_positive(fcc);

	dirty_blocks = percpu_counter_read_positive(dbc);

	root_blocks = ext4_r_blocks_count(sbi->s_es);



	if (free_blocks - (nblocks + root_blocks + dirty_blocks) <

						EXT4_FREEBLOCKS_WATERMARK) {

		free_blocks  = percpu_counter_sum_positive(fbc);

		free_blocks  = EXT4_C2B(sbi, percpu_counter_sum_positive(fcc));

		dirty_blocks = percpu_counter_sum_positive(dbc);

	}

	/* Check whether we have space after
@@ -449,7 +449,7 @@ int ext4_claim_free_blocks(struct ext4_sb_info *sbi, 
			   s64 nblocks, unsigned int flags)

{

	if (ext4_has_free_blocks(sbi, nblocks, flags)) {

		percpu_counter_add(&sbi->s_dirtyblocks_counter, nblocks);

		percpu_counter_add(&sbi->s_dirtyclusters_counter, nblocks);

		return 0;

	} else

		return -ENOSPC;

fs/ext4/ext4.h

+3 −2
Original line number Diff line number Diff line
@@ -855,6 +855,7 @@ struct ext4_inode_info { 
	ext4_group_t	i_last_alloc_group;



	/* allocation reservation info for delalloc */

	/* In case of bigalloc, these refer to clusters rather than blocks */

	unsigned int i_reserved_data_blocks;

	unsigned int i_reserved_meta_blocks;

	unsigned int i_allocated_meta_blocks;
@@ -1144,10 +1145,10 @@ struct ext4_sb_info { 
	u32 s_hash_seed[4];

	int s_def_hash_version;

	int s_hash_unsigned;	/* 3 if hash should be signed, 0 if not */

	struct percpu_counter s_freeblocks_counter;

	struct percpu_counter s_freeclusters_counter;

	struct percpu_counter s_freeinodes_counter;

	struct percpu_counter s_dirs_counter;

	struct percpu_counter s_dirtyblocks_counter;

	struct percpu_counter s_dirtyclusters_counter;

	struct blockgroup_lock *s_blockgroup_lock;

	struct proc_dir_entry *s_proc;

	struct kobject s_kobj;

fs/ext4/ialloc.c

+2 −1
Original line number Diff line number Diff line
@@ -490,7 +490,8 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent, 


	freei = percpu_counter_read_positive(&sbi->s_freeinodes_counter);

	avefreei = freei / ngroups;

	freeb = percpu_counter_read_positive(&sbi->s_freeblocks_counter);

	freeb = EXT4_C2B(sbi,

		percpu_counter_read_positive(&sbi->s_freeclusters_counter));

	avefreeb = freeb;

	do_div(avefreeb, ngroups);

	ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);

fs/ext4/inode.c

+10 −8
Original line number Diff line number Diff line
@@ -281,7 +281,7 @@ void ext4_da_update_reserve_space(struct inode *inode, 
	/* Update per-inode reservations */

	ei->i_reserved_data_blocks -= used;

	ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks;

	percpu_counter_sub(&sbi->s_dirtyblocks_counter,

	percpu_counter_sub(&sbi->s_dirtyclusters_counter,

			   used + ei->i_allocated_meta_blocks);

	ei->i_allocated_meta_blocks = 0;
@@ -291,7 +291,7 @@ void ext4_da_update_reserve_space(struct inode *inode, 
		 * only when we have written all of the delayed

		 * allocation blocks.

		 */

		percpu_counter_sub(&sbi->s_dirtyblocks_counter,

		percpu_counter_sub(&sbi->s_dirtyclusters_counter,

				   ei->i_reserved_meta_blocks);

		ei->i_reserved_meta_blocks = 0;

		ei->i_da_metadata_calc_len = 0;
@@ -1119,14 +1119,14 @@ static void ext4_da_release_space(struct inode *inode, int to_free) 
		 * only when we have written all of the delayed

		 * allocation blocks.

		 */

		percpu_counter_sub(&sbi->s_dirtyblocks_counter,

		percpu_counter_sub(&sbi->s_dirtyclusters_counter,

				   ei->i_reserved_meta_blocks);

		ei->i_reserved_meta_blocks = 0;

		ei->i_da_metadata_calc_len = 0;

	}



	/* update fs dirty data blocks counter */

	percpu_counter_sub(&sbi->s_dirtyblocks_counter, to_free);

	percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free);



	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
@@ -1349,9 +1349,10 @@ static void ext4_print_free_blocks(struct inode *inode) 
	       ext4_count_free_blocks(inode->i_sb));

	printk(KERN_CRIT "Free/Dirty block details\n");

	printk(KERN_CRIT "free_blocks=%lld\n",

	       (long long) percpu_counter_sum(&sbi->s_freeblocks_counter));

	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),

		percpu_counter_sum(&sbi->s_freeclusters_counter)));

	printk(KERN_CRIT "dirty_blocks=%lld\n",

	       (long long) percpu_counter_sum(&sbi->s_dirtyblocks_counter));

	       (long long) percpu_counter_sum(&sbi->s_dirtyclusters_counter));

	printk(KERN_CRIT "Block reservation details\n");

	printk(KERN_CRIT "i_reserved_data_blocks=%u\n",

	       EXT4_I(inode)->i_reserved_data_blocks);
@@ -2226,8 +2227,9 @@ static int ext4_nonda_switch(struct super_block *sb) 
	 * Delalloc need an accurate free block accounting. So switch

	 * to non delalloc when we are near to error range.

	 */

	free_blocks  = percpu_counter_read_positive(&sbi->s_freeblocks_counter);

	dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyblocks_counter);

	free_blocks  = EXT4_C2B(sbi,

		percpu_counter_read_positive(&sbi->s_freeclusters_counter));

	dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);

	if (2 * free_blocks < 3 * dirty_blocks ||

		free_blocks < (dirty_blocks + EXT4_FREEBLOCKS_WATERMARK)) {

		/*

fs/ext4/mballoc.c

+7 −5
Original line number Diff line number Diff line
@@ -2834,13 +2834,14 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac, 
	gdp->bg_checksum = ext4_group_desc_csum(sbi, ac->ac_b_ex.fe_group, gdp);



	ext4_unlock_group(sb, ac->ac_b_ex.fe_group);

	percpu_counter_sub(&sbi->s_freeblocks_counter, ac->ac_b_ex.fe_len);

	percpu_counter_sub(&sbi->s_freeclusters_counter, ac->ac_b_ex.fe_len);

	/*

	 * Now reduce the dirty block count also. Should not go negative

	 */

	if (!(ac->ac_flags & EXT4_MB_DELALLOC_RESERVED))

		/* release all the reserved blocks if non delalloc */

		percpu_counter_sub(&sbi->s_dirtyblocks_counter, reserv_clstrs);

		percpu_counter_sub(&sbi->s_dirtyclusters_counter,

				   reserv_clstrs);



	if (sbi->s_log_groups_per_flex) {

		ext4_group_t flex_group = ext4_flex_group(sbi,
@@ -4384,7 +4385,7 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle, 
		if (!ext4_test_inode_state(ar->inode,

					   EXT4_STATE_DELALLOC_RESERVED))

			/* release all the reserved blocks if non delalloc */

			percpu_counter_sub(&sbi->s_dirtyblocks_counter,

			percpu_counter_sub(&sbi->s_dirtyclusters_counter,

						reserv_clstrs);

	}
@@ -4691,7 +4692,7 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode, 
	ext4_free_blks_set(sb, gdp, ret);

	gdp->bg_checksum = ext4_group_desc_csum(sbi, block_group, gdp);

	ext4_unlock_group(sb, block_group);

	percpu_counter_add(&sbi->s_freeblocks_counter, count);

	percpu_counter_add(&sbi->s_freeclusters_counter, count_clusters);



	if (sbi->s_log_groups_per_flex) {

		ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
@@ -4833,7 +4834,8 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb, 
	ext4_free_blks_set(sb, desc, blk_free_count);

	desc->bg_checksum = ext4_group_desc_csum(sbi, block_group, desc);

	ext4_unlock_group(sb, block_group);

	percpu_counter_add(&sbi->s_freeblocks_counter, blocks_freed);

	percpu_counter_add(&sbi->s_freeclusters_counter,

			   EXT4_B2C(sbi, blocks_freed));



	if (sbi->s_log_groups_per_flex) {

		ext4_group_t flex_group = ext4_flex_group(sbi, block_group);