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

Commit e8546d06 authored by Marcin Slusarz's avatar Marcin Slusarz Committed by Theodore Ts'o
Browse files

ext4: le*_add_cpu conversion 



replace all:
little_endian_variable = cpu_to_leX(leX_to_cpu(little_endian_variable) +
					expression_in_cpu_byteorder);
with:
	leX_add_cpu(&little_endian_variable, expression_in_cpu_byteorder);
generated with semantic patch

Signed-off-by: default avatarMarcin Slusarz <marcin.slusarz@gmail.com>
Signed-off-by: default avatar"Theodore Ts'o" <tytso@mit.edu>
Cc: linux-ext4@vger.kernel.org
Cc: sct@redhat.com
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: adilger@clusterfs.com
Cc: Mingming Cao <cmm@us.ibm.com>
parent 9a0762c5

fs/ext4/balloc.c

+2 −5
Original line number Diff line number Diff line
@@ -752,9 +752,7 @@ void ext4_free_blocks_sb(handle_t *handle, struct super_block *sb, 
	jbd_unlock_bh_state(bitmap_bh);



	spin_lock(sb_bgl_lock(sbi, block_group));

	desc->bg_free_blocks_count =

		cpu_to_le16(le16_to_cpu(desc->bg_free_blocks_count) +

			group_freed);

	le16_add_cpu(&desc->bg_free_blocks_count, group_freed);

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

	spin_unlock(sb_bgl_lock(sbi, block_group));

	percpu_counter_add(&sbi->s_freeblocks_counter, count);
@@ -1823,8 +1821,7 @@ ext4_fsblk_t ext4_new_blocks_old(handle_t *handle, struct inode *inode, 
	spin_lock(sb_bgl_lock(sbi, group_no));

	if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))

		gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);

	gdp->bg_free_blocks_count =

			cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count)-num);

	le16_add_cpu(&gdp->bg_free_blocks_count, -num);

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

	spin_unlock(sb_bgl_lock(sbi, group_no));

	percpu_counter_sub(&sbi->s_freeblocks_counter, num);

fs/ext4/extents.c

+9 −11
Original line number Diff line number Diff line
@@ -614,7 +614,7 @@ static int ext4_ext_insert_index(handle_t *handle, struct inode *inode, 


	ix->ei_block = cpu_to_le32(logical);

	ext4_idx_store_pblock(ix, ptr);

	curp->p_hdr->eh_entries = cpu_to_le16(le16_to_cpu(curp->p_hdr->eh_entries)+1);

	le16_add_cpu(&curp->p_hdr->eh_entries, 1);



	BUG_ON(le16_to_cpu(curp->p_hdr->eh_entries)

			     > le16_to_cpu(curp->p_hdr->eh_max));
@@ -736,7 +736,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode, 
	}

	if (m) {

		memmove(ex, path[depth].p_ext-m, sizeof(struct ext4_extent)*m);

		neh->eh_entries = cpu_to_le16(le16_to_cpu(neh->eh_entries)+m);

		le16_add_cpu(&neh->eh_entries, m);

	}



	set_buffer_uptodate(bh);
@@ -753,8 +753,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode, 
		err = ext4_ext_get_access(handle, inode, path + depth);

		if (err)

			goto cleanup;

		path[depth].p_hdr->eh_entries =

		     cpu_to_le16(le16_to_cpu(path[depth].p_hdr->eh_entries)-m);

		le16_add_cpu(&path[depth].p_hdr->eh_entries, -m);

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

		if (err)

			goto cleanup;
@@ -817,8 +816,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode, 
		if (m) {

			memmove(++fidx, path[i].p_idx - m,

				sizeof(struct ext4_extent_idx) * m);

			neh->eh_entries =

				cpu_to_le16(le16_to_cpu(neh->eh_entries) + m);

			le16_add_cpu(&neh->eh_entries, m);

		}

		set_buffer_uptodate(bh);

		unlock_buffer(bh);
@@ -834,7 +832,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode, 
			err = ext4_ext_get_access(handle, inode, path + i);

			if (err)

				goto cleanup;

			path[i].p_hdr->eh_entries = cpu_to_le16(le16_to_cpu(path[i].p_hdr->eh_entries)-m);

			le16_add_cpu(&path[i].p_hdr->eh_entries, -m);

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

			if (err)

				goto cleanup;
@@ -1369,7 +1367,7 @@ int ext4_ext_try_to_merge(struct inode *inode, 
				* sizeof(struct ext4_extent);

			memmove(ex + 1, ex + 2, len);

		}

		eh->eh_entries = cpu_to_le16(le16_to_cpu(eh->eh_entries) - 1);

		le16_add_cpu(&eh->eh_entries, -1);

		merge_done = 1;

		WARN_ON(eh->eh_entries == 0);

		if (!eh->eh_entries)
@@ -1560,7 +1558,7 @@ int ext4_ext_insert_extent(handle_t *handle, struct inode *inode, 
		path[depth].p_ext = nearex;

	}



	eh->eh_entries = cpu_to_le16(le16_to_cpu(eh->eh_entries)+1);

	le16_add_cpu(&eh->eh_entries, 1);

	nearex = path[depth].p_ext;

	nearex->ee_block = newext->ee_block;

	ext4_ext_store_pblock(nearex, ext_pblock(newext));
@@ -1699,7 +1697,7 @@ static int ext4_ext_rm_idx(handle_t *handle, struct inode *inode, 
	err = ext4_ext_get_access(handle, inode, path);

	if (err)

		return err;

	path->p_hdr->eh_entries = cpu_to_le16(le16_to_cpu(path->p_hdr->eh_entries)-1);

	le16_add_cpu(&path->p_hdr->eh_entries, -1);

	err = ext4_ext_dirty(handle, inode, path);

	if (err)

		return err;
@@ -1902,7 +1900,7 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode, 
		if (num == 0) {

			/* this extent is removed; mark slot entirely unused */

			ext4_ext_store_pblock(ex, 0);

			eh->eh_entries = cpu_to_le16(le16_to_cpu(eh->eh_entries)-1);

			le16_add_cpu(&eh->eh_entries, -1);

		}



		ex->ee_block = cpu_to_le32(block);

fs/ext4/ialloc.c

+4 −8
Original line number Diff line number Diff line
@@ -223,11 +223,9 @@ void ext4_free_inode (handle_t *handle, struct inode * inode) 


		if (gdp) {

			spin_lock(sb_bgl_lock(sbi, block_group));

			gdp->bg_free_inodes_count = cpu_to_le16(

				le16_to_cpu(gdp->bg_free_inodes_count) + 1);

			le16_add_cpu(&gdp->bg_free_inodes_count, 1);

			if (is_directory)

				gdp->bg_used_dirs_count = cpu_to_le16(

				  le16_to_cpu(gdp->bg_used_dirs_count) - 1);

				le16_add_cpu(&gdp->bg_used_dirs_count, -1);

			gdp->bg_checksum = ext4_group_desc_csum(sbi,

							block_group, gdp);

			spin_unlock(sb_bgl_lock(sbi, block_group));
@@ -664,11 +662,9 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode) 
				cpu_to_le16(EXT4_INODES_PER_GROUP(sb) - ino);

	}



	gdp->bg_free_inodes_count =

		cpu_to_le16(le16_to_cpu(gdp->bg_free_inodes_count) - 1);

	le16_add_cpu(&gdp->bg_free_inodes_count, -1);

	if (S_ISDIR(mode)) {

		gdp->bg_used_dirs_count =

			cpu_to_le16(le16_to_cpu(gdp->bg_used_dirs_count) + 1);

		le16_add_cpu(&gdp->bg_used_dirs_count, 1);

	}

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

	spin_unlock(sb_bgl_lock(sbi, group));

fs/ext4/mballoc.c

+2 −5
Original line number Diff line number Diff line
@@ -3099,9 +3099,7 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac, 
						ac->ac_b_ex.fe_group,

						gdp));

	}

	gdp->bg_free_blocks_count =

		cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count)

				- ac->ac_b_ex.fe_len);

	le16_add_cpu(&gdp->bg_free_blocks_count, -ac->ac_b_ex.fe_len);

	gdp->bg_checksum = ext4_group_desc_csum(sbi, ac->ac_b_ex.fe_group, gdp);

	spin_unlock(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group));

	percpu_counter_sub(&sbi->s_freeblocks_counter, ac->ac_b_ex.fe_len);
@@ -4593,8 +4591,7 @@ void ext4_mb_free_blocks(handle_t *handle, struct inode *inode, 
	}



	spin_lock(sb_bgl_lock(sbi, block_group));

	gdp->bg_free_blocks_count =

		cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count) + count);

	le16_add_cpu(&gdp->bg_free_blocks_count, count);

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

	spin_unlock(sb_bgl_lock(sbi, block_group));

	percpu_counter_add(&sbi->s_freeblocks_counter, count);

fs/ext4/resize.c

+2 −4
Original line number Diff line number Diff line
@@ -502,8 +502,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode, 
	EXT4_SB(sb)->s_gdb_count++;

	kfree(o_group_desc);



	es->s_reserved_gdt_blocks =

		cpu_to_le16(le16_to_cpu(es->s_reserved_gdt_blocks) - 1);

	le16_add_cpu(&es->s_reserved_gdt_blocks, -1);

	ext4_journal_dirty_metadata(handle, EXT4_SB(sb)->s_sbh);



	return 0;
@@ -877,8 +876,7 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input) 
	 */

	ext4_blocks_count_set(es, ext4_blocks_count(es) +

		input->blocks_count);

	es->s_inodes_count = cpu_to_le32(le32_to_cpu(es->s_inodes_count) +

		EXT4_INODES_PER_GROUP(sb));

	le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb));



	/*

	 * We need to protect s_groups_count against other CPUs seeing