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

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

ext4: rename ext4_has_free_blocks() to ext4_has_free_clusters() 



Rename the function so it is more clear what is going on.  Also rename
the various variables so it's clearer what's happening.

Also fix a missing blocks to cluster conversion when reading the
number of reserved blocks for root.

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

fs/ext4/balloc.c

+22 −21
Original line number Diff line number Diff line
@@ -403,42 +403,43 @@ ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group) 
}



/**

 * ext4_has_free_blocks()

 * ext4_has_free_clusters()

 * @sbi:	in-core super block structure.

 * @nblocks:	number of needed blocks

 * @nclusters:	number of needed blocks

 * @flags:	flags from ext4_mb_new_blocks()

 *

 * Check if filesystem has nblocks free & available for allocation.

 * Check if filesystem has nclusters free & available for allocation.

 * On success return 1, return 0 on failure.

 */

static int ext4_has_free_blocks(struct ext4_sb_info *sbi,

				s64 nblocks, unsigned int flags)

static int ext4_has_free_clusters(struct ext4_sb_info *sbi,

				  s64 nclusters, unsigned int flags)

{

	s64 free_blocks, dirty_blocks, root_blocks;

	s64 free_clusters, dirty_clusters, root_clusters;

	struct percpu_counter *fcc = &sbi->s_freeclusters_counter;

	struct percpu_counter *dbc = &sbi->s_dirtyclusters_counter;

	struct percpu_counter *dcc = &sbi->s_dirtyclusters_counter;



	free_blocks  = percpu_counter_read_positive(fcc);

	dirty_blocks = percpu_counter_read_positive(dbc);

	root_blocks = ext4_r_blocks_count(sbi->s_es);

	free_clusters  = percpu_counter_read_positive(fcc);

	dirty_clusters = percpu_counter_read_positive(dcc);

	root_clusters = EXT4_B2C(sbi, ext4_r_blocks_count(sbi->s_es));



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

						EXT4_FREEBLOCKS_WATERMARK) {

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

		dirty_blocks = percpu_counter_sum_positive(dbc);

	if (free_clusters - (nclusters + root_clusters + dirty_clusters) <

					EXT4_FREECLUSTERS_WATERMARK) {

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

		dirty_clusters = percpu_counter_sum_positive(dcc);

	}

	/* Check whether we have space after

	 * accounting for current dirty blocks & root reserved blocks.

	/* Check whether we have space after accounting for current

	 * dirty clusters & root reserved clusters.

	 */

	if (free_blocks >= ((root_blocks + nblocks) + dirty_blocks))

	if (free_clusters >= ((root_clusters + nclusters) + dirty_clusters))

		return 1;



	/* Hm, nope.  Are (enough) root reserved blocks available? */

	/* Hm, nope.  Are (enough) root reserved clusters available? */

	if (sbi->s_resuid == current_fsuid() ||

	    ((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) ||

	    capable(CAP_SYS_RESOURCE) ||

		(flags & EXT4_MB_USE_ROOT_BLOCKS)) {



		if (free_blocks >= (nblocks + dirty_blocks))

		if (free_clusters >= (nclusters + dirty_clusters))

			return 1;

	}
@@ -448,7 +449,7 @@ static int ext4_has_free_blocks(struct ext4_sb_info *sbi, 
int ext4_claim_free_clusters(struct ext4_sb_info *sbi,

			     s64 nclusters, unsigned int flags)

{

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

	if (ext4_has_free_clusters(sbi, nclusters, flags)) {

		percpu_counter_add(&sbi->s_dirtyclusters_counter, nclusters);

		return 0;

	} else
@@ -469,7 +470,7 @@ int ext4_claim_free_clusters(struct ext4_sb_info *sbi, 
 */

int ext4_should_retry_alloc(struct super_block *sb, int *retries)

{

	if (!ext4_has_free_blocks(EXT4_SB(sb), 1, 0) ||

	if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) ||

	    (*retries)++ > 3 ||

	    !EXT4_SB(sb)->s_journal)

		return 0;

fs/ext4/ext4.h

+4 −4
Original line number Diff line number Diff line
@@ -2103,13 +2103,13 @@ do { \ 
} while (0)



#ifdef CONFIG_SMP

/* Each CPU can accumulate percpu_counter_batch blocks in their local

 * counters. So we need to make sure we have free blocks more

/* Each CPU can accumulate percpu_counter_batch clusters in their local

 * counters. So we need to make sure we have free clusters more

 * than percpu_counter_batch  * nr_cpu_ids. Also add a window of 4 times.

 */

#define EXT4_FREEBLOCKS_WATERMARK (4 * (percpu_counter_batch * nr_cpu_ids))

#define EXT4_FREECLUSTERS_WATERMARK (4 * (percpu_counter_batch * nr_cpu_ids))

#else

#define EXT4_FREEBLOCKS_WATERMARK 0

#define EXT4_FREECLUSTERS_WATERMARK 0

#endif



static inline void ext4_update_i_disksize(struct inode *inode, loff_t newsize)

fs/ext4/inode.c

+1 −1
Original line number Diff line number Diff line
@@ -2255,7 +2255,7 @@ static int ext4_nonda_switch(struct super_block *sb) 
		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)) {

		free_blocks < (dirty_blocks + EXT4_FREECLUSTERS_WATERMARK)) {

		/*

		 * free block count is less than 150% of dirty blocks

		 * or free blocks is less than watermark