reiserfs: rename p_s_sb to sb (a9dd3643) · Commits · e / devices / android_kernel_teracube_2e

fs/reiserfs/fix_node.c

+23 −23

Original line number	Diff line number	Diff line
		@@ -785,7 +785,7 @@ static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h)
		b_blocknr_t *p_n_blocknr, a_n_blocknrs[MAX_AMOUNT_NEEDED] = { 0, };
		int n_counter, n_number_of_freeblk, n_amount_needed, /* number of needed empty blocks */
		n_retval = CARRY_ON;
		struct super_block *p_s_sb = p_s_tb->tb_sb;
		struct super_block *sb = p_s_tb->tb_sb;

		/* number_of_freeblk is the number of empty blocks which have been
		acquired for use by the balancing algorithm minus the number of
		@@ -830,7 +830,7 @@ static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h)
		RFALSE(!*p_n_blocknr,
		"PAP-8135: reiserfs_new_blocknrs failed when got new blocks");

		p_s_new_bh = sb_getblk(p_s_sb, *p_n_blocknr);
		p_s_new_bh = sb_getblk(sb, *p_n_blocknr);
		RFALSE(buffer_dirty(p_s_new_bh) \|\|
		buffer_journaled(p_s_new_bh) \|\|
		buffer_journal_dirty(p_s_new_bh),
		@@ -899,7 +899,7 @@ static int get_rfree(struct tree_balance *tb, int h)
		static int is_left_neighbor_in_cache(struct tree_balance *p_s_tb, int n_h)
		{
		struct buffer_head p_s_father, left;
		struct super_block *p_s_sb = p_s_tb->tb_sb;
		struct super_block *sb = p_s_tb->tb_sb;
		b_blocknr_t n_left_neighbor_blocknr;
		int n_left_neighbor_position;

		@@ -924,7 +924,7 @@ static int is_left_neighbor_in_cache(struct tree_balance *p_s_tb, int n_h)
		n_left_neighbor_blocknr =
		B_N_CHILD_NUM(p_s_tb->FL[n_h], n_left_neighbor_position);
		/* Look for the left neighbor in the cache. */
		if ((left = sb_find_get_block(p_s_sb, n_left_neighbor_blocknr))) {
		if ((left = sb_find_get_block(sb, n_left_neighbor_blocknr))) {

		RFALSE(buffer_uptodate(left) && !B_IS_IN_TREE(left),
		"vs-8170: left neighbor (%b %z) is not in the tree",
		@@ -1942,14 +1942,14 @@ static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
		int n_child_position,
		n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h + 1);
		unsigned long n_son_number;
		struct super_block *p_s_sb = p_s_tb->tb_sb;
		struct super_block *sb = p_s_tb->tb_sb;
		struct buffer_head *p_s_bh;

		PROC_INFO_INC(p_s_sb, get_neighbors[n_h]);
		PROC_INFO_INC(sb, get_neighbors[n_h]);

		if (p_s_tb->lnum[n_h]) {
		/* We need left neighbor to balance S[n_h]. */
		PROC_INFO_INC(p_s_sb, need_l_neighbor[n_h]);
		PROC_INFO_INC(sb, need_l_neighbor[n_h]);
		p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);

		RFALSE(p_s_bh == p_s_tb->FL[n_h] &&
		@@ -1961,12 +1961,12 @@ static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
		p_s_tb->FL[n_h]) ? p_s_tb->lkey[n_h] : B_NR_ITEMS(p_s_tb->
		FL[n_h]);
		n_son_number = B_N_CHILD_NUM(p_s_tb->FL[n_h], n_child_position);
		p_s_bh = sb_bread(p_s_sb, n_son_number);
		p_s_bh = sb_bread(sb, n_son_number);
		if (!p_s_bh)
		return IO_ERROR;
		if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
		brelse(p_s_bh);
		PROC_INFO_INC(p_s_sb, get_neighbors_restart[n_h]);
		PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
		return REPEAT_SEARCH;
		}

		@@ -1986,7 +1986,7 @@ static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
		}

		if (p_s_tb->rnum[n_h]) { /* We need right neighbor to balance S[n_path_offset]. */
		PROC_INFO_INC(p_s_sb, need_r_neighbor[n_h]);
		PROC_INFO_INC(sb, need_r_neighbor[n_h]);
		p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);

		RFALSE(p_s_bh == p_s_tb->FR[n_h] &&
		@@ -1998,12 +1998,12 @@ static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
		n_child_position =
		(p_s_bh == p_s_tb->FR[n_h]) ? p_s_tb->rkey[n_h] + 1 : 0;
		n_son_number = B_N_CHILD_NUM(p_s_tb->FR[n_h], n_child_position);
		p_s_bh = sb_bread(p_s_sb, n_son_number);
		p_s_bh = sb_bread(sb, n_son_number);
		if (!p_s_bh)
		return IO_ERROR;
		if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
		brelse(p_s_bh);
		PROC_INFO_INC(p_s_sb, get_neighbors_restart[n_h]);
		PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
		return REPEAT_SEARCH;
		}
		brelse(p_s_tb->R[n_h]);
		@@ -2089,51 +2089,51 @@ static int get_mem_for_virtual_node(struct tree_balance *tb)
		}

		#ifdef CONFIG_REISERFS_CHECK
		static void tb_buffer_sanity_check(struct super_block *p_s_sb,
		static void tb_buffer_sanity_check(struct super_block *sb,
		struct buffer_head *p_s_bh,
		const char *descr, int level)
		{
		if (p_s_bh) {
		if (atomic_read(&(p_s_bh->b_count)) <= 0) {

		reiserfs_panic(p_s_sb, "jmacd-1", "negative or zero "
		reiserfs_panic(sb, "jmacd-1", "negative or zero "
		"reference counter for buffer %s[%d] "
		"(%b)", descr, level, p_s_bh);
		}

		if (!buffer_uptodate(p_s_bh)) {
		reiserfs_panic(p_s_sb, "jmacd-2", "buffer is not up "
		reiserfs_panic(sb, "jmacd-2", "buffer is not up "
		"to date %s[%d] (%b)",
		descr, level, p_s_bh);
		}

		if (!B_IS_IN_TREE(p_s_bh)) {
		reiserfs_panic(p_s_sb, "jmacd-3", "buffer is not "
		reiserfs_panic(sb, "jmacd-3", "buffer is not "
		"in tree %s[%d] (%b)",
		descr, level, p_s_bh);
		}

		if (p_s_bh->b_bdev != p_s_sb->s_bdev) {
		reiserfs_panic(p_s_sb, "jmacd-4", "buffer has wrong "
		if (p_s_bh->b_bdev != sb->s_bdev) {
		reiserfs_panic(sb, "jmacd-4", "buffer has wrong "
		"device %s[%d] (%b)",
		descr, level, p_s_bh);
		}

		if (p_s_bh->b_size != p_s_sb->s_blocksize) {
		reiserfs_panic(p_s_sb, "jmacd-5", "buffer has wrong "
		if (p_s_bh->b_size != sb->s_blocksize) {
		reiserfs_panic(sb, "jmacd-5", "buffer has wrong "
		"blocksize %s[%d] (%b)",
		descr, level, p_s_bh);
		}

		if (p_s_bh->b_blocknr > SB_BLOCK_COUNT(p_s_sb)) {
		reiserfs_panic(p_s_sb, "jmacd-6", "buffer block "
		if (p_s_bh->b_blocknr > SB_BLOCK_COUNT(sb)) {
		reiserfs_panic(sb, "jmacd-6", "buffer block "
		"number too high %s[%d] (%b)",
		descr, level, p_s_bh);
		}
		}
		}
		#else
		static void tb_buffer_sanity_check(struct super_block *p_s_sb,
		static void tb_buffer_sanity_check(struct super_block *sb,
		struct buffer_head *p_s_bh,
		const char *descr, int level)
		{;

fs/reiserfs/journal.c

+367 −368

File changed.

Preview size limit exceeded, changes collapsed.

fs/reiserfs/stree.c

+63 −63

Original line number	Diff line number	Diff line
		@@ -245,7 +245,7 @@ static const struct reiserfs_key MAX_KEY = {
		static inline const struct reiserfs_key *get_lkey(const struct treepath
		*p_s_chk_path,
		const struct super_block
		*p_s_sb)
		*sb)
		{
		int n_position, n_path_offset = p_s_chk_path->path_length;
		struct buffer_head *p_s_parent;
		@@ -282,14 +282,14 @@ static inline const struct reiserfs_key *get_lkey(const struct treepath
		}
		/* Return MIN_KEY if we are in the root of the buffer tree. */
		if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)->
		b_blocknr == SB_ROOT_BLOCK(p_s_sb))
		b_blocknr == SB_ROOT_BLOCK(sb))
		return &MIN_KEY;
		return &MAX_KEY;
		}

		/* Get delimiting key of the buffer at the path and its right neighbor. */
		inline const struct reiserfs_key get_rkey(const struct treepath p_s_chk_path,
		const struct super_block *p_s_sb)
		const struct super_block *sb)
		{
		int n_position, n_path_offset = p_s_chk_path->path_length;
		struct buffer_head *p_s_parent;
		@@ -325,7 +325,7 @@ inline const struct reiserfs_key get_rkey(const struct treepath p_s_chk_path,
		}
		/* Return MAX_KEY if we are in the root of the buffer tree. */
		if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)->
		b_blocknr == SB_ROOT_BLOCK(p_s_sb))
		b_blocknr == SB_ROOT_BLOCK(sb))
		return &MAX_KEY;
		return &MIN_KEY;
		}
		@@ -337,7 +337,7 @@ inline const struct reiserfs_key get_rkey(const struct treepath p_s_chk_path,
		this case get_lkey and get_rkey return a special key which is MIN_KEY or MAX_KEY. */
		static inline int key_in_buffer(struct treepath p_s_chk_path, / Path which should be checked. */
		const struct cpu_key p_s_key, / Key which should be checked. */
		struct super_block p_s_sb / Super block pointer. */
		struct super_block sb / Super block pointer. */
		)
		{

		@@ -348,11 +348,11 @@ static inline int key_in_buffer(struct treepath p_s_chk_path, / Path which sho
		RFALSE(!PATH_PLAST_BUFFER(p_s_chk_path)->b_bdev,
		"PAP-5060: device must not be NODEV");

		if (comp_keys(get_lkey(p_s_chk_path, p_s_sb), p_s_key) == 1)
		if (comp_keys(get_lkey(p_s_chk_path, sb), p_s_key) == 1)
		/* left delimiting key is bigger, that the key we look for */
		return 0;
		// if ( comp_keys(p_s_key, get_rkey(p_s_chk_path, p_s_sb)) != -1 )
		if (comp_keys(get_rkey(p_s_chk_path, p_s_sb), p_s_key) != 1)
		// if ( comp_keys(p_s_key, get_rkey(p_s_chk_path, sb)) != -1 )
		if (comp_keys(get_rkey(p_s_chk_path, sb), p_s_key) != 1)
		/* p_s_key must be less than right delimitiing key */
		return 0;
		return 1;
		@@ -546,7 +546,7 @@ static void search_by_key_reada(struct super_block *s,
		/**************************************************************************
		* Algorithm SearchByKey *
		* look for item in the Disk S+Tree by its key *
		* Input: p_s_sb - super block *
		* Input: sb - super block *
		* p_s_key - pointer to the key to search *
		* Output: ITEM_FOUND, ITEM_NOT_FOUND or IO_ERROR *
		* p_s_search_path - path from the root to the needed leaf *
		@@ -566,7 +566,7 @@ static void search_by_key_reada(struct super_block *s,
		correctness of the top of the path but need not be checked for the
		correctness of the bottom of the path */
		/* The function is NOT SCHEDULE-SAFE! */
		int search_by_key(struct super_block p_s_sb, const struct cpu_key p_s_key, /* Key to search. */
		int search_by_key(struct super_block sb, const struct cpu_key p_s_key, /* Key to search. */
		struct treepath p_s_search_path,/ This structure was
		allocated and initialized
		by the calling
		@@ -592,7 +592,7 @@ int search_by_key(struct super_block p_s_sb, const struct cpu_key p_s_key, /*
		int n_repeat_counter = 0;
		#endif

		PROC_INFO_INC(p_s_sb, search_by_key);
		PROC_INFO_INC(sb, search_by_key);

		/* As we add each node to a path we increase its count. This means that
		we must be careful to release all nodes in a path before we either
		@@ -605,13 +605,13 @@ int search_by_key(struct super_block p_s_sb, const struct cpu_key p_s_key, /*
		/* With each iteration of this loop we search through the items in the
		current node, and calculate the next current node(next path element)
		for the next iteration of this loop.. */
		n_block_number = SB_ROOT_BLOCK(p_s_sb);
		n_block_number = SB_ROOT_BLOCK(sb);
		expected_level = -1;
		while (1) {

		#ifdef CONFIG_REISERFS_CHECK
		if (!(++n_repeat_counter % 50000))
		reiserfs_warning(p_s_sb, "PAP-5100",
		reiserfs_warning(sb, "PAP-5100",
		"%s: there were %d iterations of "
		"while loop looking for key %K",
		current->comm, n_repeat_counter,
		@@ -622,14 +622,14 @@ int search_by_key(struct super_block p_s_sb, const struct cpu_key p_s_key, /*
		p_s_last_element =
		PATH_OFFSET_PELEMENT(p_s_search_path,
		++p_s_search_path->path_length);
		fs_gen = get_generation(p_s_sb);
		fs_gen = get_generation(sb);

		/* Read the next tree node, and set the last element in the path to
		have a pointer to it. */
		if ((p_s_bh = p_s_last_element->pe_buffer =
		sb_getblk(p_s_sb, n_block_number))) {
		sb_getblk(sb, n_block_number))) {
		if (!buffer_uptodate(p_s_bh) && reada_count > 1) {
		search_by_key_reada(p_s_sb, reada_bh,
		search_by_key_reada(sb, reada_bh,
		reada_blocks, reada_count);
		}
		ll_rw_block(READ, 1, &p_s_bh);
		@@ -644,25 +644,25 @@ int search_by_key(struct super_block p_s_sb, const struct cpu_key p_s_key, /*
		}
		reada_count = 0;
		if (expected_level == -1)
		expected_level = SB_TREE_HEIGHT(p_s_sb);
		expected_level = SB_TREE_HEIGHT(sb);
		expected_level--;

		/* It is possible that schedule occurred. We must check whether the key
		to search is still in the tree rooted from the current buffer. If
		not then repeat search from the root. */
		if (fs_changed(fs_gen, p_s_sb) &&
		if (fs_changed(fs_gen, sb) &&
		(!B_IS_IN_TREE(p_s_bh) \|\|
		B_LEVEL(p_s_bh) != expected_level \|\|
		!key_in_buffer(p_s_search_path, p_s_key, p_s_sb))) {
		PROC_INFO_INC(p_s_sb, search_by_key_fs_changed);
		PROC_INFO_INC(p_s_sb, search_by_key_restarted);
		PROC_INFO_INC(p_s_sb,
		!key_in_buffer(p_s_search_path, p_s_key, sb))) {
		PROC_INFO_INC(sb, search_by_key_fs_changed);
		PROC_INFO_INC(sb, search_by_key_restarted);
		PROC_INFO_INC(sb,
		sbk_restarted[expected_level - 1]);
		pathrelse(p_s_search_path);

		/* Get the root block number so that we can repeat the search
		starting from the root. */
		n_block_number = SB_ROOT_BLOCK(p_s_sb);
		n_block_number = SB_ROOT_BLOCK(sb);
		expected_level = -1;
		right_neighbor_of_leaf_node = 0;

		@@ -674,12 +674,12 @@ int search_by_key(struct super_block p_s_sb, const struct cpu_key p_s_key, /*
		equal to the MAX_KEY. Latter case is only possible in
		"finish_unfinished()" processing during mount. */
		RFALSE(comp_keys(&MAX_KEY, p_s_key) &&
		!key_in_buffer(p_s_search_path, p_s_key, p_s_sb),
		!key_in_buffer(p_s_search_path, p_s_key, sb),
		"PAP-5130: key is not in the buffer");
		#ifdef CONFIG_REISERFS_CHECK
		if (cur_tb) {
		print_cur_tb("5140");
		reiserfs_panic(p_s_sb, "PAP-5140",
		reiserfs_panic(sb, "PAP-5140",
		"schedule occurred in do_balance!");
		}
		#endif
		@@ -687,7 +687,7 @@ int search_by_key(struct super_block p_s_sb, const struct cpu_key p_s_key, /*
		// make sure, that the node contents look like a node of
		// certain level
		if (!is_tree_node(p_s_bh, expected_level)) {
		reiserfs_error(p_s_sb, "vs-5150",
		reiserfs_error(sb, "vs-5150",
		"invalid format found in block %ld. "
		"Fsck?", p_s_bh->b_blocknr);
		pathrelse(p_s_search_path);
		@@ -697,7 +697,7 @@ int search_by_key(struct super_block p_s_sb, const struct cpu_key p_s_key, /*
		/* ok, we have acquired next formatted node in the tree */
		n_node_level = B_LEVEL(p_s_bh);

		PROC_INFO_BH_STAT(p_s_sb, p_s_bh, n_node_level - 1);
		PROC_INFO_BH_STAT(sb, p_s_bh, n_node_level - 1);

		RFALSE(n_node_level < n_stop_level,
		"vs-5152: tree level (%d) is less than stop level (%d)",
		@@ -776,7 +776,7 @@ int search_by_key(struct super_block p_s_sb, const struct cpu_key p_s_key, /*
		units of directory entries. */

		/* The function is NOT SCHEDULE-SAFE! */
		int search_for_position_by_key(struct super_block p_s_sb, / Pointer to the super block. */
		int search_for_position_by_key(struct super_block sb, / Pointer to the super block. */
		const struct cpu_key p_cpu_key, / Key to search (cpu variable) */
		struct treepath p_s_search_path / Filled up by this function. */
		)
		@@ -789,13 +789,13 @@ int search_for_position_by_key(struct super_block p_s_sb, / Pointer to the sup

		/* If searching for directory entry. */
		if (is_direntry_cpu_key(p_cpu_key))
		return search_by_entry_key(p_s_sb, p_cpu_key, p_s_search_path,
		return search_by_entry_key(sb, p_cpu_key, p_s_search_path,
		&de);

		/* If not searching for directory entry. */

		/* If item is found. */
		retval = search_item(p_s_sb, p_cpu_key, p_s_search_path);
		retval = search_item(sb, p_cpu_key, p_s_search_path);
		if (retval == IO_ERROR)
		return retval;
		if (retval == ITEM_FOUND) {
		@@ -817,7 +817,7 @@ int search_for_position_by_key(struct super_block p_s_sb, / Pointer to the sup
		p_le_ih =
		B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_search_path),
		--PATH_LAST_POSITION(p_s_search_path));
		n_blk_size = p_s_sb->s_blocksize;
		n_blk_size = sb->s_blocksize;

		if (comp_short_keys(&(p_le_ih->ih_key), p_cpu_key)) {
		return FILE_NOT_FOUND;
		@@ -957,7 +957,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
		int p_n_cut_size, unsigned long long n_new_file_length / MAX_KEY_OFFSET in case of delete. */
		)
		{
		struct super_block *p_s_sb = inode->i_sb;
		struct super_block *sb = inode->i_sb;
		struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_path);
		struct buffer_head *p_s_bh = PATH_PLAST_BUFFER(p_s_path);

		@@ -986,7 +986,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st

		/* Case of an indirect item. */
		{
		int blk_size = p_s_sb->s_blocksize;
		int blk_size = sb->s_blocksize;
		struct item_head s_ih;
		int need_re_search;
		int delete = 0;
		@@ -1023,9 +1023,9 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
		block = get_block_num(unfm, 0);

		if (block != 0) {
		reiserfs_prepare_for_journal(p_s_sb, p_s_bh, 1);
		reiserfs_prepare_for_journal(sb, p_s_bh, 1);
		put_block_num(unfm, 0, 0);
		journal_mark_dirty (th, p_s_sb, p_s_bh);
		journal_mark_dirty (th, sb, p_s_bh);
		reiserfs_free_block(th, inode, block, 1);
		}

		@@ -1049,9 +1049,9 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
		/* a trick. If the buffer has been logged, this will do nothing. If
		** we've broken the loop without logging it, it will restore the
		** buffer */
		reiserfs_restore_prepared_buffer(p_s_sb, p_s_bh);
		reiserfs_restore_prepared_buffer(sb, p_s_bh);
		} while (need_re_search &&
		search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path) == POSITION_FOUND);
		search_for_position_by_key(sb, p_s_item_key, p_s_path) == POSITION_FOUND);
		pos_in_item(p_s_path) = pos * UNFM_P_SIZE;

		if (*p_n_cut_size == 0) {
		@@ -1090,7 +1090,7 @@ static int calc_deleted_bytes_number(struct tree_balance *p_s_tb, char c_mode)

		static void init_tb_struct(struct reiserfs_transaction_handle *th,
		struct tree_balance *p_s_tb,
		struct super_block *p_s_sb,
		struct super_block *sb,
		struct treepath *p_s_path, int n_size)
		{

		@@ -1098,7 +1098,7 @@ static void init_tb_struct(struct reiserfs_transaction_handle *th,

		memset(p_s_tb, '\0', sizeof(struct tree_balance));
		p_s_tb->transaction_handle = th;
		p_s_tb->tb_sb = p_s_sb;
		p_s_tb->tb_sb = sb;
		p_s_tb->tb_path = p_s_path;
		PATH_OFFSET_PBUFFER(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL;
		PATH_OFFSET_POSITION(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0;
		@@ -1147,7 +1147,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
		struct inode p_s_inode, / inode is here just to update i_blocks and quotas */
		struct buffer_head *p_s_un_bh)
		{ /* NULL or unformatted node pointer. */
		struct super_block *p_s_sb = p_s_inode->i_sb;
		struct super_block *sb = p_s_inode->i_sb;
		struct tree_balance s_del_balance;
		struct item_head s_ih;
		struct item_head *q_ih;
		@@ -1161,7 +1161,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath

		BUG_ON(!th->t_trans_id);

		init_tb_struct(th, &s_del_balance, p_s_sb, p_s_path,
		init_tb_struct(th, &s_del_balance, sb, p_s_path,
		0 /size is unknown / );

		while (1) {
		@@ -1185,15 +1185,15 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
		if (n_ret_value != REPEAT_SEARCH)
		break;

		PROC_INFO_INC(p_s_sb, delete_item_restarted);
		PROC_INFO_INC(sb, delete_item_restarted);

		// file system changed, repeat search
		n_ret_value =
		search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path);
		search_for_position_by_key(sb, p_s_item_key, p_s_path);
		if (n_ret_value == IO_ERROR)
		break;
		if (n_ret_value == FILE_NOT_FOUND) {
		reiserfs_warning(p_s_sb, "vs-5340",
		reiserfs_warning(sb, "vs-5340",
		"no items of the file %K found",
		p_s_item_key);
		break;
		@@ -1216,8 +1216,8 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
		** the unfm node once
		*/
		if (!S_ISLNK(p_s_inode->i_mode) && is_direct_le_ih(q_ih)) {
		if ((le_ih_k_offset(q_ih) & (p_s_sb->s_blocksize - 1)) == 1) {
		quota_cut_bytes = p_s_sb->s_blocksize + UNFM_P_SIZE;
		if ((le_ih_k_offset(q_ih) & (sb->s_blocksize - 1)) == 1) {
		quota_cut_bytes = sb->s_blocksize + UNFM_P_SIZE;
		} else {
		quota_cut_bytes = 0;
		}
		@@ -1258,7 +1258,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
		do_balance(&s_del_balance, NULL, NULL, M_DELETE);

		#ifdef REISERQUOTA_DEBUG
		reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
		reiserfs_debug(sb, REISERFS_DEBUG_CODE,
		"reiserquota delete_item(): freeing %u, id=%u type=%c",
		quota_cut_bytes, p_s_inode->i_uid, head2type(&s_ih));
		#endif
		@@ -1430,8 +1430,8 @@ static int maybe_indirect_to_direct(struct reiserfs_transaction_handle *th,
		const struct cpu_key *p_s_item_key,
		loff_t n_new_file_size, char *p_c_mode)
		{
		struct super_block *p_s_sb = p_s_inode->i_sb;
		int n_block_size = p_s_sb->s_blocksize;
		struct super_block *sb = p_s_inode->i_sb;
		int n_block_size = sb->s_blocksize;
		int cut_bytes;
		BUG_ON(!th->t_trans_id);
		BUG_ON(n_new_file_size != p_s_inode->i_size);
		@@ -1509,7 +1509,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
		struct inode *p_s_inode,
		struct page *page, loff_t n_new_file_size)
		{
		struct super_block *p_s_sb = p_s_inode->i_sb;
		struct super_block *sb = p_s_inode->i_sb;
		/* Every function which is going to call do_balance must first
		create a tree_balance structure. Then it must fill up this
		structure by using the init_tb_struct and fix_nodes functions.
		@@ -1560,7 +1560,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
		/* removing of last unformatted node will change value we
		have to return to truncate. Save it */
		retval2 = n_ret_value;
		/retval2 = p_s_sb->s_blocksize - (n_new_file_size & (p_s_sb->s_blocksize - 1)); /
		/retval2 = sb->s_blocksize - (n_new_file_size & (sb->s_blocksize - 1)); /

		/* So, we have performed the first part of the conversion:
		inserting the new direct item. Now we are removing the
		@@ -1569,16 +1569,16 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
		set_cpu_key_k_type(p_s_item_key, TYPE_INDIRECT);
		p_s_item_key->key_length = 4;
		n_new_file_size -=
		(n_new_file_size & (p_s_sb->s_blocksize - 1));
		(n_new_file_size & (sb->s_blocksize - 1));
		tail_pos = n_new_file_size;
		set_cpu_key_k_offset(p_s_item_key, n_new_file_size + 1);
		if (search_for_position_by_key
		(p_s_sb, p_s_item_key,
		(sb, p_s_item_key,
		p_s_path) == POSITION_NOT_FOUND) {
		print_block(PATH_PLAST_BUFFER(p_s_path), 3,
		PATH_LAST_POSITION(p_s_path) - 1,
		PATH_LAST_POSITION(p_s_path) + 1);
		reiserfs_panic(p_s_sb, "PAP-5580", "item to "
		reiserfs_panic(sb, "PAP-5580", "item to "
		"convert does not exist (%K)",
		p_s_item_key);
		}
		@@ -1595,14 +1595,14 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
		if (n_ret_value != REPEAT_SEARCH)
		break;

		PROC_INFO_INC(p_s_sb, cut_from_item_restarted);
		PROC_INFO_INC(sb, cut_from_item_restarted);

		n_ret_value =
		search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path);
		search_for_position_by_key(sb, p_s_item_key, p_s_path);
		if (n_ret_value == POSITION_FOUND)
		continue;

		reiserfs_warning(p_s_sb, "PAP-5610", "item %K not found",
		reiserfs_warning(sb, "PAP-5610", "item %K not found",
		p_s_item_key);
		unfix_nodes(&s_cut_balance);
		return (n_ret_value == IO_ERROR) ? -EIO : -ENOENT;
		@@ -1616,7 +1616,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
		indirect_to_direct_roll_back(th, p_s_inode, p_s_path);
		}
		if (n_ret_value == NO_DISK_SPACE)
		reiserfs_warning(p_s_sb, "reiserfs-5092",
		reiserfs_warning(sb, "reiserfs-5092",
		"NO_DISK_SPACE");
		unfix_nodes(&s_cut_balance);
		return -EIO;
		@@ -1642,11 +1642,11 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
		p_le_ih = PATH_PITEM_HEAD(s_cut_balance.tb_path);
		if (!S_ISLNK(p_s_inode->i_mode) && is_direct_le_ih(p_le_ih)) {
		if (c_mode == M_DELETE &&
		(le_ih_k_offset(p_le_ih) & (p_s_sb->s_blocksize - 1)) ==
		(le_ih_k_offset(p_le_ih) & (sb->s_blocksize - 1)) ==
		1) {
		// FIXME: this is to keep 3.5 happy
		REISERFS_I(p_s_inode)->i_first_direct_byte = U32_MAX;
		quota_cut_bytes = p_s_sb->s_blocksize + UNFM_P_SIZE;
		quota_cut_bytes = sb->s_blocksize + UNFM_P_SIZE;
		} else {
		quota_cut_bytes = 0;
		}
		@@ -1659,18 +1659,18 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
		sure, that we exactly remove last unformatted node pointer
		of the item */
		if (!is_indirect_le_ih(le_ih))
		reiserfs_panic(p_s_sb, "vs-5652",
		reiserfs_panic(sb, "vs-5652",
		"item must be indirect %h", le_ih);

		if (c_mode == M_DELETE && ih_item_len(le_ih) != UNFM_P_SIZE)
		reiserfs_panic(p_s_sb, "vs-5653", "completing "
		reiserfs_panic(sb, "vs-5653", "completing "
		"indirect2direct conversion indirect "
		"item %h being deleted must be of "
		"4 byte long", le_ih);

		if (c_mode == M_CUT
		&& s_cut_balance.insert_size[0] != -UNFM_P_SIZE) {
		reiserfs_panic(p_s_sb, "vs-5654", "can not complete "
		reiserfs_panic(sb, "vs-5654", "can not complete "
		"indirect2direct conversion of %h "
		"(CUT, insert_size==%d)",
		le_ih, s_cut_balance.insert_size[0]);

fs/reiserfs/tail_conversion.c

+8 −8

Original line number	Diff line number	Diff line
		@@ -175,9 +175,9 @@ int indirect2direct(struct reiserfs_transaction_handle th, struct inode p_s_in
		loff_t n_new_file_size, /* New file size. */
		char *p_c_mode)
		{
		struct super_block *p_s_sb = p_s_inode->i_sb;
		struct super_block *sb = p_s_inode->i_sb;
		struct item_head s_ih;
		unsigned long n_block_size = p_s_sb->s_blocksize;
		unsigned long n_block_size = sb->s_blocksize;
		char *tail;
		int tail_len, round_tail_len;
		loff_t pos, pos1; /* position of first byte of the tail */
		@@ -185,7 +185,7 @@ int indirect2direct(struct reiserfs_transaction_handle th, struct inode p_s_in

		BUG_ON(!th->t_trans_id);

		REISERFS_SB(p_s_sb)->s_indirect2direct++;
		REISERFS_SB(sb)->s_indirect2direct++;

		*p_c_mode = M_SKIP_BALANCING;

		@@ -200,7 +200,7 @@ int indirect2direct(struct reiserfs_transaction_handle th, struct inode p_s_in

		pos =
		le_ih_k_offset(&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE -
		1) * p_s_sb->s_blocksize;
		1) * sb->s_blocksize;
		pos1 = pos;

		// we are protected by i_mutex. The tail can not disapper, not
		@@ -211,18 +211,18 @@ int indirect2direct(struct reiserfs_transaction_handle th, struct inode p_s_in

		if (path_changed(&s_ih, p_s_path)) {
		/* re-search indirect item */
		if (search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path)
		if (search_for_position_by_key(sb, p_s_item_key, p_s_path)
		== POSITION_NOT_FOUND)
		reiserfs_panic(p_s_sb, "PAP-5520",
		reiserfs_panic(sb, "PAP-5520",
		"item to be converted %K does not exist",
		p_s_item_key);
		copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
		#ifdef CONFIG_REISERFS_CHECK
		pos = le_ih_k_offset(&s_ih) - 1 +
		(ih_item_len(&s_ih) / UNFM_P_SIZE -
		1) * p_s_sb->s_blocksize;
		1) * sb->s_blocksize;
		if (pos != pos1)
		reiserfs_panic(p_s_sb, "vs-5530", "tail position "
		reiserfs_panic(sb, "vs-5530", "tail position "
		"changed while we were reading it");
		#endif
		}

include/linux/reiserfs_fs.h

+7 −7

Original line number	Diff line number	Diff line
		@@ -1769,12 +1769,12 @@ int journal_end_sync(struct reiserfs_transaction_handle , struct super_block ,
		int journal_mark_freed(struct reiserfs_transaction_handle *,
		struct super_block *, b_blocknr_t blocknr);
		int journal_transaction_should_end(struct reiserfs_transaction_handle *, int);
		int reiserfs_in_journal(struct super_block *p_s_sb, unsigned int bmap_nr,
		int reiserfs_in_journal(struct super_block *sb, unsigned int bmap_nr,
		int bit_nr, int searchall, b_blocknr_t *next);
		int journal_begin(struct reiserfs_transaction_handle *,
		struct super_block *p_s_sb, unsigned long);
		struct super_block *sb, unsigned long);
		int journal_join_abort(struct reiserfs_transaction_handle *,
		struct super_block *p_s_sb, unsigned long);
		struct super_block *sb, unsigned long);
		void reiserfs_abort_journal(struct super_block *sb, int errno);
		void reiserfs_abort(struct super_block sb, int errno, const char fmt, ...);
		int reiserfs_allocate_list_bitmaps(struct super_block *s,
		@@ -1830,11 +1830,11 @@ static inline void copy_key(struct reiserfs_key *to,

		int comp_items(const struct item_head stored_ih, const struct treepath p_s_path);
		const struct reiserfs_key get_rkey(const struct treepath p_s_chk_path,
		const struct super_block *p_s_sb);
		const struct super_block *sb);
		int search_by_key(struct super_block , const struct cpu_key ,
		struct treepath *, int);
		#define search_item(s,key,path) search_by_key (s, key, path, DISK_LEAF_NODE_LEVEL)
		int search_for_position_by_key(struct super_block *p_s_sb,
		int search_for_position_by_key(struct super_block *sb,
		const struct cpu_key *p_s_cpu_key,
		struct treepath *p_s_search_path);
		extern void decrement_bcount(struct buffer_head *p_s_bh);
		@@ -1978,7 +1978,7 @@ int reiserfs_global_version_in_proc(char buffer, char *start, off_t offset,
		#define PROC_INFO_MAX( sb, field, value ) VOID_V
		#define PROC_INFO_INC( sb, field ) VOID_V
		#define PROC_INFO_ADD( sb, field, val ) VOID_V
		#define PROC_INFO_BH_STAT( p_s_sb, p_s_bh, n_node_level ) VOID_V
		#define PROC_INFO_BH_STAT(sb, p_s_bh, n_node_level) VOID_V
		#endif

		/* dir.c */