[PATCH 65/76] fs/reiserfs: Use inode_sb() helper instead of inode->i_sb

[Mark Fasheh]

Signed-off-by: Mark Fasheh <mfasheh@xxxxxxx>
---
 fs/reiserfs/bitmap.c          |  12 +-
 fs/reiserfs/dir.c             |  27 ++--
 fs/reiserfs/file.c            |  22 +--
 fs/reiserfs/inode.c           | 321 +++++++++++++++++++++---------------------
 fs/reiserfs/ioctl.c           |  18 +--
 fs/reiserfs/journal.c         |  10 +-
 fs/reiserfs/namei.c           | 190 +++++++++++++------------
 fs/reiserfs/reiserfs.h        |   8 +-
 fs/reiserfs/stree.c           |  69 ++++-----
 fs/reiserfs/super.c           |  31 ++--
 fs/reiserfs/tail_conversion.c |   6 +-
 fs/reiserfs/xattr.c           |  36 ++---
 fs/reiserfs/xattr.h           |  13 +-
 fs/reiserfs/xattr_acl.c       |  14 +-
 fs/reiserfs/xattr_security.c  |   2 +-
 fs/reiserfs/xattr_user.c      |   4 +-
 16 files changed, 397 insertions(+), 386 deletions(-)

diff --git a/fs/reiserfs/bitmap.c b/fs/reiserfs/bitmap.c
index edc8ef78b63f..9d73c0df3bf3 100644
--- a/fs/reiserfs/bitmap.c
+++ b/fs/reiserfs/bitmap.c
@@ -325,13 +325,13 @@ static inline int block_group_used(struct super_block *s, u32 id)
 __le32 reiserfs_choose_packing(struct inode * dir)
 {
 	__le32 packing;
-	if (TEST_OPTION(packing_groups, dir->i_sb)) {
+	if (TEST_OPTION(packing_groups, inode_sb(dir))) {
 		u32 parent_dir = le32_to_cpu(INODE_PKEY(dir)->k_dir_id);
 		/*
 		 * some versions of reiserfsck expect packing locality 1 to be
 		 * special
 		 */
-		if (parent_dir == 1 || block_group_used(dir->i_sb, parent_dir))
+		if (parent_dir == 1 || block_group_used(inode_sb(dir), parent_dir))
 			packing = INODE_PKEY(dir)->k_objectid;
 		else
 			packing = INODE_PKEY(dir)->k_dir_id;
@@ -837,11 +837,11 @@ static void oid_groups(reiserfs_blocknr_hint_t * hint)
 		 * the start of the disk
 		 */
 		if (dirid <= 2)
-			hash = (hint->inode->i_sb->s_blocksize << 3);
+			hash = (inode_sb(hint->inode)->s_blocksize << 3);
 		else {
 			oid = le32_to_cpu(INODE_PKEY(hint->inode)->k_objectid);
-			bm = bmap_hash_id(hint->inode->i_sb, oid);
-			hash = bm * (hint->inode->i_sb->s_blocksize << 3);
+			bm = bmap_hash_id(inode_sb(hint->inode), oid);
+			hash = bm * (inode_sb(hint->inode)->s_blocksize << 3);
 		}
 		hint->search_start = hash;
 	}
@@ -1139,7 +1139,7 @@ static int determine_prealloc_size(reiserfs_blocknr_hint_t * hint)
 		if (S_ISREG(hint->inode->i_mode) && !IS_PRIVATE(hint->inode)
 		    && hint->inode->i_size >=
 		    REISERFS_SB(hint->th->t_super)->s_alloc_options.
-		    preallocmin * hint->inode->i_sb->s_blocksize)
+		    preallocmin * inode_sb(hint->inode)->s_blocksize)
 			hint->prealloc_size =
 			    REISERFS_SB(hint->th->t_super)->s_alloc_options.
 			    preallocsize - 1;
diff --git a/fs/reiserfs/dir.c b/fs/reiserfs/dir.c
index 5b50689d8539..d9aff9f826cc 100644
--- a/fs/reiserfs/dir.c
+++ b/fs/reiserfs/dir.c
@@ -39,9 +39,9 @@ static int reiserfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
 		return err;
 
 	inode_lock(inode);
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 	err = reiserfs_commit_for_inode(inode);
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 	inode_unlock(inode);
 	if (err < 0)
 		return err;
@@ -52,7 +52,7 @@ static int reiserfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
 
 static inline bool is_privroot_deh(struct inode *dir, struct reiserfs_de_head *deh)
 {
-	struct dentry *privroot = REISERFS_SB(dir->i_sb)->priv_root;
+	struct dentry *privroot = REISERFS_SB(inode_sb(dir))->priv_root;
 	return (d_really_is_positive(privroot) &&
 	        deh->deh_objectid == INODE_PKEY(d_inode(privroot))->k_objectid);
 }
@@ -76,9 +76,9 @@ int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)
 	int ret = 0;
 	int depth;
 
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 
-	reiserfs_check_lock_depth(inode->i_sb, "readdir");
+	reiserfs_check_lock_depth(inode_sb(inode), "readdir");
 
 	/*
 	 * form key for search the next directory entry using
@@ -95,7 +95,8 @@ int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)
 		 * specified key
 		 */
 		search_res =
-		    search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,
+		    search_by_entry_key(inode_sb(inode), &pos_key,
+					&path_to_entry,
 					&de);
 		if (search_res == IO_ERROR) {
 			/*
@@ -165,7 +166,7 @@ int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)
 
 				/* too big to send back to VFS */
 				if (d_reclen >
-				    REISERFS_MAX_NAME(inode->i_sb->
+				    REISERFS_MAX_NAME(inode_sb(inode)->
 						      s_blocksize)) {
 					continue;
 				}
@@ -205,17 +206,19 @@ int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)
 				 * Since filldir might sleep, we can release
 				 * the write lock here for other waiters
 				 */
-				depth = reiserfs_write_unlock_nested(inode->i_sb);
+				depth = reiserfs_write_unlock_nested(inode_sb(inode));
 				if (!dir_emit
 				    (ctx, local_buf, d_reclen, d_ino,
 				     DT_UNKNOWN)) {
-					reiserfs_write_lock_nested(inode->i_sb, depth);
+					reiserfs_write_lock_nested(inode_sb(inode),
+								   depth);
 					if (local_buf != small_buf) {
 						kfree(local_buf);
 					}
 					goto end;
 				}
-				reiserfs_write_lock_nested(inode->i_sb, depth);
+				reiserfs_write_lock_nested(inode_sb(inode),
+							   depth);
 				if (local_buf != small_buf) {
 					kfree(local_buf);
 				}
@@ -239,7 +242,7 @@ int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)
 		 * 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_sb(inode));
 		if (!comp_le_keys(rkey, &MIN_KEY)) {
 			/*
 			 * set pos_key to key, that is the smallest and greater
@@ -265,7 +268,7 @@ int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)
 	pathrelse(&path_to_entry);
 	reiserfs_check_path(&path_to_entry);
 out:
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 	return ret;
 }
 
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index 843aadcc123c..8b41044bbd12 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -56,14 +56,14 @@ static int reiserfs_file_release(struct inode *inode, struct file *filp)
 		return 0;
 	}
 
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 	/*
 	 * freeing preallocation only involves relogging blocks that
 	 * are already in the current transaction.  preallocation gets
 	 * freed at the end of each transaction, so it is impossible for
 	 * us to log any additional blocks (including quota blocks)
 	 */
-	err = journal_begin(&th, inode->i_sb, 1);
+	err = journal_begin(&th, inode_sb(inode), 1);
 	if (err) {
 		/*
 		 * uh oh, we can't allow the inode to go away while there
@@ -71,7 +71,7 @@ static int reiserfs_file_release(struct inode *inode, struct file *filp)
 		 * aborted transaction
 		 */
 		jbegin_failure = err;
-		err = journal_join_abort(&th, inode->i_sb);
+		err = journal_join_abort(&th, inode_sb(inode));
 
 		if (err) {
 			/*
@@ -84,7 +84,7 @@ static int reiserfs_file_release(struct inode *inode, struct file *filp)
 			 * and let the admin know what is going on.
 			 */
 			igrab(inode);
-			reiserfs_warning(inode->i_sb, "clm-9001",
+			reiserfs_warning(inode_sb(inode), "clm-9001",
 					 "pinning inode %lu because the "
 					 "preallocation can't be freed",
 					 inode->i_ino);
@@ -115,7 +115,7 @@ static int reiserfs_file_release(struct inode *inode, struct file *filp)
 		err = reiserfs_truncate_file(inode, 0);
 	}
 out:
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 	mutex_unlock(&REISERFS_I(inode)->tailpack);
 	return err;
 }
@@ -161,11 +161,11 @@ static int reiserfs_sync_file(struct file *filp, loff_t start, loff_t end,
 	inode_lock(inode);
 	BUG_ON(!S_ISREG(inode->i_mode));
 	err = sync_mapping_buffers(inode->i_mapping);
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 	barrier_done = reiserfs_commit_for_inode(inode);
-	reiserfs_write_unlock(inode->i_sb);
-	if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb))
-		blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
+	reiserfs_write_unlock(inode_sb(inode));
+	if (barrier_done != 1 && reiserfs_barrier_flush(inode_sb(inode)))
+		blkdev_issue_flush(inode_sb(inode)->s_bdev, GFP_KERNEL, NULL);
 	inode_unlock(inode);
 	if (barrier_done < 0)
 		return barrier_done;
@@ -183,7 +183,7 @@ int reiserfs_commit_page(struct inode *inode, struct page *page,
 	unsigned long i_size_index = inode->i_size >> PAGE_SHIFT;
 	int new;
 	int logit = reiserfs_file_data_log(inode);
-	struct super_block *s = inode->i_sb;
+	struct super_block *s = inode_sb(inode);
 	int bh_per_page = PAGE_SIZE / s->s_blocksize;
 	struct reiserfs_transaction_handle th;
 	int ret = 0;
@@ -219,7 +219,7 @@ int reiserfs_commit_page(struct inode *inode, struct page *page,
 				 * do data=ordered on any page past the end
 				 * of file and any buffer marked BH_New.
 				 */
-				if (reiserfs_data_ordered(inode->i_sb) &&
+				if (reiserfs_data_ordered(inode_sb(inode)) &&
 				    (new || page->index >= i_size_index)) {
 					reiserfs_add_ordered_list(inode, bh);
 				}
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index b13fc024d2ee..a3c814ddb774 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -32,7 +32,7 @@ void reiserfs_evict_inode(struct inode *inode)
 	 */
 	int jbegin_count =
 	    JOURNAL_PER_BALANCE_CNT * 2 +
-	    2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);
+	    2 * REISERFS_QUOTA_INIT_BLOCKS(inode_sb(inode));
 	struct reiserfs_transaction_handle th;
 	int err;
 
@@ -52,9 +52,9 @@ void reiserfs_evict_inode(struct inode *inode)
 
 		reiserfs_delete_xattrs(inode);
 
-		reiserfs_write_lock(inode->i_sb);
+		reiserfs_write_lock(inode_sb(inode));
 
-		if (journal_begin(&th, inode->i_sb, jbegin_count))
+		if (journal_begin(&th, inode_sb(inode), jbegin_count))
 			goto out;
 		reiserfs_update_inode_transaction(inode);
 
@@ -68,9 +68,9 @@ void reiserfs_evict_inode(struct inode *inode)
 		 * go into the same transaction as stat data deletion
 		 */
 		if (!err) {
-			int depth = reiserfs_write_unlock_nested(inode->i_sb);
+			int depth = reiserfs_write_unlock_nested(inode_sb(inode));
 			dquot_free_inode(inode);
-			reiserfs_write_lock_nested(inode->i_sb, depth);
+			reiserfs_write_lock_nested(inode_sb(inode), depth);
 		}
 
 		if (journal_end(&th))
@@ -90,7 +90,7 @@ void reiserfs_evict_inode(struct inode *inode)
 		 */
 		remove_save_link(inode, 0 /* not truncate */);
 out:
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 	} else {
 		/* no object items are in the tree */
 		;
@@ -231,7 +231,7 @@ static inline int indirect_item_found(int retval, struct item_head *ih)
 static inline void set_block_dev_mapped(struct buffer_head *bh,
 					b_blocknr_t block, struct inode *inode)
 {
-	map_bh(bh, inode->i_sb, block);
+	map_bh(bh, inode_sb(inode), block);
 }
 
 /*
@@ -243,7 +243,7 @@ static int file_capable(struct inode *inode, sector_t block)
 	/* it is new file. */
 	if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 ||
 	    /* old file, but 'block' is inside of 2gb */
-	    block < (1 << (31 - inode->i_sb->s_blocksize_bits)))
+	    block < (1 << (31 - inode_sb(inode)->s_blocksize_bits)))
 		return 1;
 
 	return 0;
@@ -299,10 +299,11 @@ static int _get_block_create_0(struct inode *inode, sector_t block,
 
 	/* prepare the key to look for the 'block'-th block of file */
 	make_cpu_key(&key, inode,
-		     (loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,
+		     (loff_t) block * inode_sb(inode)->s_blocksize + 1,
+		     TYPE_ANY,
 		     3);
 
-	result = search_for_position_by_key(inode->i_sb, &key, &path);
+	result = search_for_position_by_key(inode_sb(inode), &key, &path);
 	if (result != POSITION_FOUND) {
 		pathrelse(&path);
 		if (p)
@@ -334,7 +335,7 @@ static int _get_block_create_0(struct inode *inode, sector_t block,
 		blocknr = get_block_num(ind_item, path.pos_in_item);
 		ret = 0;
 		if (blocknr) {
-			map_bh(bh_result, inode->i_sb, blocknr);
+			map_bh(bh_result, inode_sb(inode), blocknr);
 			if (path.pos_in_item ==
 			    ((ih_item_len(ih) / UNFM_P_SIZE) - 1)) {
 				set_buffer_boundary(bh_result);
@@ -400,7 +401,7 @@ static int _get_block_create_0(struct inode *inode, sector_t block,
 		p = (char *)kmap(bh_result->b_page);
 
 	p += offset;
-	memset(p, 0, inode->i_sb->s_blocksize);
+	memset(p, 0, inode_sb(inode)->s_blocksize);
 	do {
 		if (!is_direct_le_ih(ih)) {
 			BUG();
@@ -439,7 +440,8 @@ static int _get_block_create_0(struct inode *inode, sector_t block,
 
 		/* update key to look for the next piece */
 		set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + chars);
-		result = search_for_position_by_key(inode->i_sb, &key, &path);
+		result = search_for_position_by_key(inode_sb(inode), &key,
+						    &path);
 		if (result != POSITION_FOUND)
 			/* i/o error most likely */
 			break;
@@ -460,7 +462,7 @@ static int _get_block_create_0(struct inode *inode, sector_t block,
 	 * this buffer has valid data, but isn't valid for io.  mapping it to
 	 * block #0 tells the rest of reiserfs it just has a tail in it
 	 */
-	map_bh(bh_result, inode->i_sb, 0);
+	map_bh(bh_result, inode_sb(inode), 0);
 	set_buffer_uptodate(bh_result);
 	return 0;
 }
@@ -475,10 +477,10 @@ static int reiserfs_bmap(struct inode *inode, sector_t block,
 	if (!file_capable(inode, block))
 		return -EFBIG;
 
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 	/* do not read the direct item */
 	_get_block_create_0(inode, block, bh_result, 0);
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 	return 0;
 }
 
@@ -549,12 +551,12 @@ static int reiserfs_get_blocks_direct_io(struct inode *inode,
 	if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {
 		int err;
 
-		reiserfs_write_lock(inode->i_sb);
+		reiserfs_write_lock(inode_sb(inode));
 
 		err = reiserfs_commit_for_inode(inode);
 		REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
 
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 
 		if (err < 0)
 			ret = err;
@@ -679,17 +681,17 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 	 */
 	int jbegin_count =
 	    JOURNAL_PER_BALANCE_CNT * 3 + 1 +
-	    2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
+	    2 * REISERFS_QUOTA_TRANS_BLOCKS(inode_sb(inode));
 	int version;
 	int dangle = 1;
 	loff_t new_offset =
-	    (((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;
+	    (((loff_t) block) << inode_sb(inode)->s_blocksize_bits) + 1;
 
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 	version = get_inode_item_key_version(inode);
 
 	if (!file_capable(inode, block)) {
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 		return -EFBIG;
 	}
 
@@ -702,7 +704,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 		/* find number of block-th logical block of the file */
 		ret = _get_block_create_0(inode, block, bh_result,
 					  create | GET_BLOCK_READ_DIRECT);
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 		return ret;
 	}
 
@@ -711,7 +713,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 	 * any new transactions we start in this func
 	 */
 	if ((create & GET_BLOCK_NO_DANGLE) ||
-	    reiserfs_transaction_running(inode->i_sb))
+	    reiserfs_transaction_running(inode_sb(inode)))
 		dangle = 0;
 
 	/*
@@ -719,17 +721,18 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 	 * tails are enabled  we should mark it as possibly needing
 	 * tail packing on close
 	 */
-	if ((have_large_tails(inode->i_sb)
+	if ((have_large_tails(inode_sb(inode))
 	     && inode->i_size < i_block_size(inode) * 4)
-	    || (have_small_tails(inode->i_sb)
+	    || (have_small_tails(inode_sb(inode))
 		&& inode->i_size < i_block_size(inode)))
 		REISERFS_I(inode)->i_flags |= i_pack_on_close_mask;
 
 	/* set the key of the first byte in the 'block'-th block of file */
 	make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 /*key length */ );
-	if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {
+	if ((new_offset + inode_sb(inode)->s_blocksize - 1) > inode->i_size) {
 start_trans:
-		th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);
+		th = reiserfs_persistent_transaction(inode_sb(inode),
+						     jbegin_count);
 		if (!th) {
 			retval = -ENOMEM;
 			goto failure;
@@ -738,7 +741,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 	}
 research:
 
-	retval = search_for_position_by_key(inode->i_sb, &key, &path);
+	retval = search_for_position_by_key(inode_sb(inode), &key, &path);
 	if (retval == IO_ERROR) {
 		retval = -EIO;
 		goto failure;
@@ -749,7 +752,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 	item = tp_item_body(&path);
 	pos_in_item = path.pos_in_item;
 
-	fs_gen = get_generation(inode->i_sb);
+	fs_gen = get_generation(inode_sb(inode));
 	copy_item_head(&tmp_ih, ih);
 
 	if (allocation_needed
@@ -770,7 +773,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 		 * research if we succeed on the second try
 		 */
 		if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {
-			SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;
+			SB_JOURNAL(inode_sb(inode))->j_next_async_flush = 1;
 			retval = restart_transaction(th, inode, &path);
 			if (retval)
 				goto failure;
@@ -788,7 +791,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 			goto failure;
 		}
 
-		if (fs_changed(fs_gen, inode->i_sb)
+		if (fs_changed(fs_gen, inode_sb(inode))
 		    && item_moved(&tmp_ih, &path)) {
 			goto research;
 		}
@@ -804,16 +807,16 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 		unfm_ptr = get_block_num(item, pos_in_item);
 		if (unfm_ptr == 0) {
 			/* use allocated block to plug the hole */
-			reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
-			if (fs_changed(fs_gen, inode->i_sb)
+			reiserfs_prepare_for_journal(inode_sb(inode), bh, 1);
+			if (fs_changed(fs_gen, inode_sb(inode))
 			    && item_moved(&tmp_ih, &path)) {
-				reiserfs_restore_prepared_buffer(inode->i_sb,
+				reiserfs_restore_prepared_buffer(inode_sb(inode),
 								 bh);
 				goto research;
 			}
 			set_buffer_new(bh_result);
 			if (buffer_dirty(bh_result)
-			    && reiserfs_data_ordered(inode->i_sb))
+			    && reiserfs_data_ordered(inode_sb(inode)))
 				reiserfs_add_ordered_list(inode, bh_result);
 			put_block_num(item, pos_in_item, allocated_block_nr);
 			unfm_ptr = allocated_block_nr;
@@ -826,7 +829,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 		if (!dangle && th)
 			retval = reiserfs_end_persistent_transaction(th);
 
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 
 		/*
 		 * the item was found, so new blocks were not added to the file
@@ -890,7 +893,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 
 			tail_offset =
 			    ((le_ih_k_offset(ih) -
-			      1) & ~(inode->i_sb->s_blocksize - 1)) + 1;
+			      1) & ~(inode_sb(inode)->s_blocksize - 1)) + 1;
 
 			/*
 			 * direct item we just found fits into block we have
@@ -930,19 +933,20 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 							  tail_offset);
 				if (retval) {
 					if (retval != -ENOSPC)
-						reiserfs_error(inode->i_sb,
-							"clm-6004",
-							"convert tail failed "
-							"inode %lu, error %d",
-							inode->i_ino,
-							retval);
+						reiserfs_error(inode_sb(inode),
+							       "clm-6004",
+							       "convert tail failed "
+							       "inode %lu, error %d",
+							       inode->i_ino,
+							       retval);
 					if (allocated_block_nr) {
 						/*
 						 * the bitmap, the super,
 						 * and the stat data == 3
 						 */
 						if (!th)
-							th = reiserfs_persistent_transaction(inode->i_sb, 3);
+							th = reiserfs_persistent_transaction(inode_sb(inode),
+											     3);
 						if (th)
 							reiserfs_free_block(th,
 									    inode,
@@ -1015,7 +1019,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 			unp_t unf_single = 0;
 			unp_t *un;
 			__u64 max_to_insert =
-			    MAX_ITEM_LEN(inode->i_sb->s_blocksize) /
+			    MAX_ITEM_LEN(inode_sb(inode)->s_blocksize) /
 			    UNFM_P_SIZE;
 			__u64 blocks_needed;
 
@@ -1030,7 +1034,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 				     le_key_k_offset(version,
 						     &ih->ih_key) +
 				     op_bytes_number(ih,
-						     inode->i_sb->s_blocksize),
+						     inode_sb(inode)->s_blocksize),
 				     TYPE_INDIRECT, 3);
 
 			RFALSE(cpu_key_k_offset(&tmp_key) > cpu_key_k_offset(&key),
@@ -1038,7 +1042,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 			blocks_needed =
 			    1 +
 			    ((cpu_key_k_offset(&key) -
-			      cpu_key_k_offset(&tmp_key)) >> inode->i_sb->
+			      cpu_key_k_offset(&tmp_key)) >> inode_sb(inode)->
 			     s_blocksize_bits);
 
 			if (blocks_needed == 1) {
@@ -1094,7 +1098,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 				 * holes.
 				 */
 				inode->i_size +=
-				    inode->i_sb->s_blocksize * blocks_needed;
+				    inode_sb(inode)->s_blocksize * blocks_needed;
 			}
 		}
 
@@ -1119,15 +1123,16 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 		 * long time.  reschedule if needed and also release the write
 		 * lock for others.
 		 */
-		reiserfs_cond_resched(inode->i_sb);
+		reiserfs_cond_resched(inode_sb(inode));
 
-		retval = search_for_position_by_key(inode->i_sb, &key, &path);
+		retval = search_for_position_by_key(inode_sb(inode), &key,
+						    &path);
 		if (retval == IO_ERROR) {
 			retval = -EIO;
 			goto failure;
 		}
 		if (retval == POSITION_FOUND) {
-			reiserfs_warning(inode->i_sb, "vs-825",
+			reiserfs_warning(inode_sb(inode), "vs-825",
 					 "%K should not be found", &key);
 			retval = -EEXIST;
 			if (allocated_block_nr)
@@ -1154,7 +1159,7 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
 			retval = err;
 	}
 
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 	reiserfs_check_path(&path);
 	return retval;
 }
@@ -1174,7 +1179,7 @@ reiserfs_readpages(struct file *file, struct address_space *mapping,
 static int real_space_diff(struct inode *inode, int sd_size)
 {
 	int bytes;
-	loff_t blocksize = inode->i_sb->s_blocksize;
+	loff_t blocksize = inode_sb(inode)->s_blocksize;
 
 	if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))
 		return sd_size;
@@ -1190,7 +1195,7 @@ static int real_space_diff(struct inode *inode, int sd_size)
 	 */
 	bytes =
 	    ((inode->i_size +
-	      (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +
+	      (blocksize - 1)) >> inode_sb(inode)->s_blocksize_bits) * UNFM_P_SIZE +
 	    sd_size;
 	return bytes;
 }
@@ -1276,7 +1281,7 @@ static void init_inode(struct inode *inode, struct treepath *path)
 		inode->i_blocks = sd_v1_blocks(sd);
 		inode->i_generation = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
 		blocks = (inode->i_size + 511) >> 9;
-		blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9);
+		blocks = _ROUND_UP(blocks, inode_sb(inode)->s_blocksize >> 9);
 
 		/*
 		 * there was a bug in <=3.5.23 when i_blocks could take
@@ -1430,7 +1435,8 @@ static void update_stat_data(struct treepath *path, struct inode *inode,
 	ih = tp_item_head(path);
 
 	if (!is_statdata_le_ih(ih))
-		reiserfs_panic(inode->i_sb, "vs-13065", "key %k, found item %h",
+		reiserfs_panic(inode_sb(inode), "vs-13065",
+			       "key %k, found item %h",
 			       INODE_PKEY(inode), ih);
 
 	/* path points to old stat data */
@@ -1461,9 +1467,9 @@ void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
 	for (;;) {
 		int pos;
 		/* look for the object's stat data */
-		retval = search_item(inode->i_sb, &key, &path);
+		retval = search_item(inode_sb(inode), &key, &path);
 		if (retval == IO_ERROR) {
-			reiserfs_error(inode->i_sb, "vs-13050",
+			reiserfs_error(inode_sb(inode), "vs-13050",
 				       "i/o failure occurred trying to "
 				       "update %K stat data", &key);
 			return;
@@ -1472,10 +1478,10 @@ void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
 			pos = PATH_LAST_POSITION(&path);
 			pathrelse(&path);
 			if (inode->i_nlink == 0) {
-				/*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
+				/*reiserfs_warning (inode_sb(inode), "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
 				return;
 			}
-			reiserfs_warning(inode->i_sb, "vs-13060",
+			reiserfs_warning(inode_sb(inode), "vs-13060",
 					 "stat data of object %k (nlink == %d) "
 					 "not found (pos %d)",
 					 INODE_PKEY(inode), inode->i_nlink,
@@ -1492,13 +1498,13 @@ void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
 		bh = get_last_bh(&path);
 		ih = tp_item_head(&path);
 		copy_item_head(&tmp_ih, ih);
-		fs_gen = get_generation(inode->i_sb);
-		reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
+		fs_gen = get_generation(inode_sb(inode));
+		reiserfs_prepare_for_journal(inode_sb(inode), bh, 1);
 
 		/* Stat_data item has been moved after scheduling. */
-		if (fs_changed(fs_gen, inode->i_sb)
+		if (fs_changed(fs_gen, inode_sb(inode))
 		    && item_moved(&tmp_ih, &path)) {
-			reiserfs_restore_prepared_buffer(inode->i_sb, bh);
+			reiserfs_restore_prepared_buffer(inode_sb(inode), bh);
 			continue;
 		}
 		break;
@@ -1559,9 +1565,9 @@ void reiserfs_read_locked_inode(struct inode *inode,
 	key.on_disk_key.k_type = 0;
 
 	/* look for the object's stat data */
-	retval = search_item(inode->i_sb, &key, &path_to_sd);
+	retval = search_item(inode_sb(inode), &key, &path_to_sd);
 	if (retval == IO_ERROR) {
-		reiserfs_error(inode->i_sb, "vs-13070",
+		reiserfs_error(inode_sb(inode), "vs-13070",
 			       "i/o failure occurred trying to find "
 			       "stat data of %K", &key);
 		reiserfs_make_bad_inode(inode);
@@ -1598,8 +1604,8 @@ void reiserfs_read_locked_inode(struct inode *inode,
 	 * during mount (fs/reiserfs/super.c:finish_unfinished()).
 	 */
 	if ((inode->i_nlink == 0) &&
-	    !REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {
-		reiserfs_warning(inode->i_sb, "vs-13075",
+	    !REISERFS_SB(inode_sb(inode))->s_is_unlinked_ok) {
+		reiserfs_warning(inode_sb(inode), "vs-13075",
 				 "dead inode read from disk %K. "
 				 "This is likely to be race with knfsd. Ignore",
 				 &key);
@@ -1776,7 +1782,7 @@ int reiserfs_write_inode(struct inode *inode, struct writeback_control *wbc)
 	struct reiserfs_transaction_handle th;
 	int jbegin_count = 1;
 
-	if (sb_rdonly(inode->i_sb))
+	if (sb_rdonly(inode_sb(inode)))
 		return -EROFS;
 	/*
 	 * memory pressure can sometimes initiate write_inode calls with
@@ -1786,12 +1792,12 @@ int reiserfs_write_inode(struct inode *inode, struct writeback_control *wbc)
 	 * ignored because the altered inode has already been logged.
 	 */
 	if (wbc->sync_mode == WB_SYNC_ALL && !(current->flags & PF_MEMALLOC)) {
-		reiserfs_write_lock(inode->i_sb);
-		if (!journal_begin(&th, inode->i_sb, jbegin_count)) {
+		reiserfs_write_lock(inode_sb(inode));
+		if (!journal_begin(&th, inode_sb(inode), jbegin_count)) {
 			reiserfs_update_sd(&th, inode);
 			journal_end_sync(&th);
 		}
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 	}
 	return 0;
 }
@@ -1930,7 +1936,7 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
 		       struct inode *inode,
 		       struct reiserfs_security_handle *security)
 {
-	struct super_block *sb = dir->i_sb;
+	struct super_block *sb = inode_sb(dir);
 	struct reiserfs_iget_args args;
 	INITIALIZE_PATH(path_to_key);
 	struct cpu_key key;
@@ -1969,10 +1975,10 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
 	memcpy(INODE_PKEY(inode), &ih.ih_key, KEY_SIZE);
 	args.dirid = le32_to_cpu(ih.ih_key.k_dir_id);
 
-	depth = reiserfs_write_unlock_nested(inode->i_sb);
+	depth = reiserfs_write_unlock_nested(inode_sb(inode));
 	err = insert_inode_locked4(inode, args.objectid,
 			     reiserfs_find_actor, &args);
-	reiserfs_write_lock_nested(inode->i_sb, depth);
+	reiserfs_write_lock_nested(inode_sb(inode), depth);
 	if (err) {
 		err = -EINVAL;
 		goto out_bad_inode;
@@ -2096,27 +2102,27 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
 		goto out_inserted_sd;
 	}
 
-	if (reiserfs_posixacl(inode->i_sb)) {
-		reiserfs_write_unlock(inode->i_sb);
+	if (reiserfs_posixacl(inode_sb(inode))) {
+		reiserfs_write_unlock(inode_sb(inode));
 		retval = reiserfs_inherit_default_acl(th, dir, dentry, inode);
-		reiserfs_write_lock(inode->i_sb);
+		reiserfs_write_lock(inode_sb(inode));
 		if (retval) {
 			err = retval;
 			reiserfs_check_path(&path_to_key);
 			journal_end(th);
 			goto out_inserted_sd;
 		}
-	} else if (inode->i_sb->s_flags & SB_POSIXACL) {
-		reiserfs_warning(inode->i_sb, "jdm-13090",
+	} else if (inode_sb(inode)->s_flags & SB_POSIXACL) {
+		reiserfs_warning(inode_sb(inode), "jdm-13090",
 				 "ACLs aren't enabled in the fs, "
 				 "but vfs thinks they are!");
 	} else if (IS_PRIVATE(dir))
 		inode->i_flags |= S_PRIVATE;
 
 	if (security->name) {
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 		retval = reiserfs_security_write(th, inode, security);
-		reiserfs_write_lock(inode->i_sb);
+		reiserfs_write_lock(inode_sb(inode));
 		if (retval) {
 			err = retval;
 			reiserfs_check_path(&path_to_key);
@@ -2137,9 +2143,9 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
 	INODE_PKEY(inode)->k_objectid = 0;
 
 	/* Quota change must be inside a transaction for journaling */
-	depth = reiserfs_write_unlock_nested(inode->i_sb);
+	depth = reiserfs_write_unlock_nested(inode_sb(inode));
 	dquot_free_inode(inode);
-	reiserfs_write_lock_nested(inode->i_sb, depth);
+	reiserfs_write_lock_nested(inode_sb(inode), depth);
 
 out_end_trans:
 	journal_end(th);
@@ -2147,9 +2153,9 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
 	 * Drop can be outside and it needs more credits so it's better
 	 * to have it outside
 	 */
-	depth = reiserfs_write_unlock_nested(inode->i_sb);
+	depth = reiserfs_write_unlock_nested(inode_sb(inode));
 	dquot_drop(inode);
-	reiserfs_write_lock_nested(inode->i_sb, depth);
+	reiserfs_write_lock_nested(inode_sb(inode), depth);
 	inode->i_flags |= S_NOQUOTA;
 	make_bad_inode(inode);
 
@@ -2186,7 +2192,7 @@ static int grab_tail_page(struct inode *inode,
 	unsigned long index = (inode->i_size - 1) >> PAGE_SHIFT;
 	unsigned long pos = 0;
 	unsigned long start = 0;
-	unsigned long blocksize = inode->i_sb->s_blocksize;
+	unsigned long blocksize = inode_sb(inode)->s_blocksize;
 	unsigned long offset = (inode->i_size) & (PAGE_SIZE - 1);
 	struct buffer_head *bh;
 	struct buffer_head *head;
@@ -2232,7 +2238,7 @@ static int grab_tail_page(struct inode *inode,
 		 * date, I've screwed up the code to find the buffer, or the
 		 * code to call prepare_write
 		 */
-		reiserfs_error(inode->i_sb, "clm-6000",
+		reiserfs_error(inode_sb(inode), "clm-6000",
 			       "error reading block %lu", bh->b_blocknr);
 		error = -EIO;
 		goto unlock;
@@ -2260,14 +2266,14 @@ int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
 	struct reiserfs_transaction_handle th;
 	/* we want the offset for the first byte after the end of the file */
 	unsigned long offset = inode->i_size & (PAGE_SIZE - 1);
-	unsigned blocksize = inode->i_sb->s_blocksize;
+	unsigned blocksize = inode_sb(inode)->s_blocksize;
 	unsigned length;
 	struct page *page = NULL;
 	int error;
 	struct buffer_head *bh = NULL;
 	int err2;
 
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 
 	if (inode->i_size > 0) {
 		error = grab_tail_page(inode, &page, &bh);
@@ -2278,7 +2284,7 @@ int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
 			 * block to read in, which is ok.
 			 */
 			if (error != -ENOENT)
-				reiserfs_error(inode->i_sb, "clm-6001",
+				reiserfs_error(inode_sb(inode), "clm-6001",
 					       "grab_tail_page failed %d",
 					       error);
 			page = NULL;
@@ -2298,7 +2304,7 @@ int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
 	 * one for "save" link adding and another for the first
 	 * cut_from_item. 1 is for update_sd
 	 */
-	error = journal_begin(&th, inode->i_sb,
+	error = journal_begin(&th, inode_sb(inode),
 			      JOURNAL_PER_BALANCE_CNT * 2 + 1);
 	if (error)
 		goto out;
@@ -2342,7 +2348,7 @@ int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
 		put_page(page);
 	}
 
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 
 	return 0;
 out:
@@ -2351,7 +2357,7 @@ int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
 		put_page(page);
 	}
 
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 
 	return error;
 }
@@ -2370,7 +2376,7 @@ static int map_block_for_writepage(struct inode *inode,
 	INITIALIZE_PATH(path);
 	int pos_in_item;
 	int jbegin_count = JOURNAL_PER_BALANCE_CNT;
-	loff_t byte_offset = ((loff_t)block << inode->i_sb->s_blocksize_bits)+1;
+	loff_t byte_offset = ((loff_t)block << inode_sb(inode)->s_blocksize_bits)+1;
 	int retval;
 	int use_get_block = 0;
 	int bytes_copied = 0;
@@ -2389,11 +2395,11 @@ static int map_block_for_writepage(struct inode *inode,
 
 	kmap(bh_result->b_page);
 start_over:
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 	make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);
 
 research:
-	retval = search_for_position_by_key(inode->i_sb, &key, &path);
+	retval = search_for_position_by_key(inode_sb(inode), &key, &path);
 	if (retval != POSITION_FOUND) {
 		use_get_block = 1;
 		goto out;
@@ -2407,7 +2413,7 @@ static int map_block_for_writepage(struct inode *inode,
 	/* we've found an unformatted node */
 	if (indirect_item_found(retval, ih)) {
 		if (bytes_copied > 0) {
-			reiserfs_warning(inode->i_sb, "clm-6002",
+			reiserfs_warning(inode_sb(inode), "clm-6002",
 					 "bytes_copied %d", bytes_copied);
 		}
 		if (!get_block_num(item, pos_in_item)) {
@@ -2423,29 +2429,30 @@ static int map_block_for_writepage(struct inode *inode,
 		p += (byte_offset - 1) & (PAGE_SIZE - 1);
 		copy_size = ih_item_len(ih) - pos_in_item;
 
-		fs_gen = get_generation(inode->i_sb);
+		fs_gen = get_generation(inode_sb(inode));
 		copy_item_head(&tmp_ih, ih);
 
 		if (!trans_running) {
 			/* vs-3050 is gone, no need to drop the path */
-			retval = journal_begin(&th, inode->i_sb, jbegin_count);
+			retval = journal_begin(&th, inode_sb(inode),
+					       jbegin_count);
 			if (retval)
 				goto out;
 			reiserfs_update_inode_transaction(inode);
 			trans_running = 1;
-			if (fs_changed(fs_gen, inode->i_sb)
+			if (fs_changed(fs_gen, inode_sb(inode))
 			    && item_moved(&tmp_ih, &path)) {
-				reiserfs_restore_prepared_buffer(inode->i_sb,
+				reiserfs_restore_prepared_buffer(inode_sb(inode),
 								 bh);
 				goto research;
 			}
 		}
 
-		reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
+		reiserfs_prepare_for_journal(inode_sb(inode), bh, 1);
 
-		if (fs_changed(fs_gen, inode->i_sb)
+		if (fs_changed(fs_gen, inode_sb(inode))
 		    && item_moved(&tmp_ih, &path)) {
-			reiserfs_restore_prepared_buffer(inode->i_sb, bh);
+			reiserfs_restore_prepared_buffer(inode_sb(inode), bh);
 			goto research;
 		}
 
@@ -2465,7 +2472,7 @@ static int map_block_for_writepage(struct inode *inode,
 			goto research;
 		}
 	} else {
-		reiserfs_warning(inode->i_sb, "clm-6003",
+		reiserfs_warning(inode_sb(inode), "clm-6003",
 				 "bad item inode %lu", inode->i_ino);
 		retval = -EIO;
 		goto out;
@@ -2480,7 +2487,7 @@ static int map_block_for_writepage(struct inode *inode,
 			retval = err;
 		trans_running = 0;
 	}
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 
 	/* this is where we fill in holes in the file. */
 	if (use_get_block) {
@@ -2528,7 +2535,7 @@ static int reiserfs_write_full_page(struct page *page,
 	int nr = 0;
 	int checked = PageChecked(page);
 	struct reiserfs_transaction_handle th;
-	struct super_block *s = inode->i_sb;
+	struct super_block *s = inode_sb(inode);
 	int bh_per_page = PAGE_SIZE / s->s_blocksize;
 	th.t_trans_id = 0;
 
@@ -2739,7 +2746,7 @@ static int reiserfs_readpage(struct file *f, struct page *page)
 static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)
 {
 	struct inode *inode = page->mapping->host;
-	reiserfs_wait_on_write_block(inode->i_sb);
+	reiserfs_wait_on_write_block(inode_sb(inode));
 	return reiserfs_write_full_page(page, wbc);
 }
 
@@ -2763,7 +2770,7 @@ static int reiserfs_write_begin(struct file *file,
  	inode = mapping->host;
 	*fsdata = NULL;
  	if (flags & AOP_FLAG_CONT_EXPAND &&
- 	    (pos & (inode->i_sb->s_blocksize - 1)) == 0) {
+ 	    (pos & (inode_sb(inode)->s_blocksize - 1)) == 0) {
  		pos ++;
 		*fsdata = (void *)(unsigned long)flags;
 	}
@@ -2774,9 +2781,9 @@ static int reiserfs_write_begin(struct file *file,
 		return -ENOMEM;
 	*pagep = page;
 
-	reiserfs_wait_on_write_block(inode->i_sb);
+	reiserfs_wait_on_write_block(inode_sb(inode));
 	fix_tail_page_for_writing(page);
-	if (reiserfs_transaction_running(inode->i_sb)) {
+	if (reiserfs_transaction_running(inode_sb(inode))) {
 		struct reiserfs_transaction_handle *th;
 		th = (struct reiserfs_transaction_handle *)current->
 		    journal_info;
@@ -2786,7 +2793,7 @@ static int reiserfs_write_begin(struct file *file,
 		th->t_refcount++;
 	}
 	ret = __block_write_begin(page, pos, len, reiserfs_get_block);
-	if (ret && reiserfs_transaction_running(inode->i_sb)) {
+	if (ret && reiserfs_transaction_running(inode_sb(inode))) {
 		struct reiserfs_transaction_handle *th = current->journal_info;
 		/*
 		 * this gets a little ugly.  If reiserfs_get_block returned an
@@ -2806,9 +2813,9 @@ static int reiserfs_write_begin(struct file *file,
 				th->t_refcount--;
 			else {
 				int err;
-				reiserfs_write_lock(inode->i_sb);
+				reiserfs_write_lock(inode_sb(inode));
 				err = reiserfs_end_persistent_transaction(th);
-				reiserfs_write_unlock(inode->i_sb);
+				reiserfs_write_unlock(inode_sb(inode));
 				if (err)
 					ret = err;
 			}
@@ -2830,12 +2837,12 @@ int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len)
 	int old_ref = 0;
 	int depth;
 
-	depth = reiserfs_write_unlock_nested(inode->i_sb);
-	reiserfs_wait_on_write_block(inode->i_sb);
-	reiserfs_write_lock_nested(inode->i_sb, depth);
+	depth = reiserfs_write_unlock_nested(inode_sb(inode));
+	reiserfs_wait_on_write_block(inode_sb(inode));
+	reiserfs_write_lock_nested(inode_sb(inode), depth);
 
 	fix_tail_page_for_writing(page);
-	if (reiserfs_transaction_running(inode->i_sb)) {
+	if (reiserfs_transaction_running(inode_sb(inode))) {
 		struct reiserfs_transaction_handle *th;
 		th = (struct reiserfs_transaction_handle *)current->
 		    journal_info;
@@ -2846,7 +2853,7 @@ int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len)
 	}
 
 	ret = __block_write_begin(page, from, len, reiserfs_get_block);
-	if (ret && reiserfs_transaction_running(inode->i_sb)) {
+	if (ret && reiserfs_transaction_running(inode_sb(inode))) {
 		struct reiserfs_transaction_handle *th = current->journal_info;
 		/*
 		 * this gets a little ugly.  If reiserfs_get_block returned an
@@ -2866,9 +2873,9 @@ int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len)
 				th->t_refcount--;
 			else {
 				int err;
-				reiserfs_write_lock(inode->i_sb);
+				reiserfs_write_lock(inode_sb(inode));
 				err = reiserfs_end_persistent_transaction(th);
-				reiserfs_write_unlock(inode->i_sb);
+				reiserfs_write_unlock(inode_sb(inode));
 				if (err)
 					ret = err;
 			}
@@ -2897,8 +2904,8 @@ static int reiserfs_write_end(struct file *file, struct address_space *mapping,
 	if ((unsigned long)fsdata & AOP_FLAG_CONT_EXPAND)
 		pos ++;
 
-	reiserfs_wait_on_write_block(inode->i_sb);
-	if (reiserfs_transaction_running(inode->i_sb))
+	reiserfs_wait_on_write_block(inode_sb(inode));
+	if (reiserfs_transaction_running(inode_sb(inode)))
 		th = current->journal_info;
 	else
 		th = NULL;
@@ -2921,20 +2928,20 @@ static int reiserfs_write_end(struct file *file, struct address_space *mapping,
 	 */
 	if (pos + copied > inode->i_size) {
 		struct reiserfs_transaction_handle myth;
-		reiserfs_write_lock(inode->i_sb);
+		reiserfs_write_lock(inode_sb(inode));
 		locked = true;
 		/*
 		 * If the file have grown beyond the border where it
 		 * can have a tail, unmark it as needing a tail
 		 * packing
 		 */
-		if ((have_large_tails(inode->i_sb)
+		if ((have_large_tails(inode_sb(inode))
 		     && inode->i_size > i_block_size(inode) * 4)
-		    || (have_small_tails(inode->i_sb)
+		    || (have_small_tails(inode_sb(inode))
 			&& inode->i_size > i_block_size(inode)))
 			REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
 
-		ret = journal_begin(&myth, inode->i_sb, 1);
+		ret = journal_begin(&myth, inode_sb(inode), 1);
 		if (ret)
 			goto journal_error;
 
@@ -2954,7 +2961,7 @@ static int reiserfs_write_end(struct file *file, struct address_space *mapping,
 	}
 	if (th) {
 		if (!locked) {
-			reiserfs_write_lock(inode->i_sb);
+			reiserfs_write_lock(inode_sb(inode));
 			locked = true;
 		}
 		if (!update_sd)
@@ -2966,7 +2973,7 @@ static int reiserfs_write_end(struct file *file, struct address_space *mapping,
 
 out:
 	if (locked)
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 	unlock_page(page);
 	put_page(page);
 
@@ -2976,7 +2983,7 @@ static int reiserfs_write_end(struct file *file, struct address_space *mapping,
 	return ret == 0 ? copied : ret;
 
 journal_error:
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 	locked = false;
 	if (th) {
 		if (!update_sd)
@@ -2996,11 +3003,11 @@ int reiserfs_commit_write(struct file *f, struct page *page,
 	struct reiserfs_transaction_handle *th = NULL;
 	int depth;
 
-	depth = reiserfs_write_unlock_nested(inode->i_sb);
-	reiserfs_wait_on_write_block(inode->i_sb);
-	reiserfs_write_lock_nested(inode->i_sb, depth);
+	depth = reiserfs_write_unlock_nested(inode_sb(inode));
+	reiserfs_wait_on_write_block(inode_sb(inode));
+	reiserfs_write_lock_nested(inode_sb(inode), depth);
 
-	if (reiserfs_transaction_running(inode->i_sb)) {
+	if (reiserfs_transaction_running(inode_sb(inode))) {
 		th = current->journal_info;
 	}
 	reiserfs_commit_page(inode, page, from, to);
@@ -3017,13 +3024,13 @@ int reiserfs_commit_write(struct file *f, struct page *page,
 		 * can have a tail, unmark it as needing a tail
 		 * packing
 		 */
-		if ((have_large_tails(inode->i_sb)
+		if ((have_large_tails(inode_sb(inode))
 		     && inode->i_size > i_block_size(inode) * 4)
-		    || (have_small_tails(inode->i_sb)
+		    || (have_small_tails(inode_sb(inode))
 			&& inode->i_size > i_block_size(inode)))
 			REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
 
-		ret = journal_begin(&myth, inode->i_sb, 1);
+		ret = journal_begin(&myth, inode_sb(inode), 1);
 		if (ret)
 			goto journal_error;
 
@@ -3064,7 +3071,7 @@ int reiserfs_commit_write(struct file *f, struct page *page,
 
 void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)
 {
-	if (reiserfs_attrs(inode->i_sb)) {
+	if (reiserfs_attrs(inode_sb(inode))) {
 		if (sd_attrs & REISERFS_SYNC_FL)
 			inode->i_flags |= S_SYNC;
 		else
@@ -3095,7 +3102,7 @@ void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)
 static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
 {
 	int ret = 1;
-	struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
+	struct reiserfs_journal *j = SB_JOURNAL(inode_sb(inode));
 
 	lock_buffer(bh);
 	spin_lock(&j->j_dirty_buffers_lock);
@@ -3133,7 +3140,7 @@ static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
 		 * transaction, we need to leave it around
 		 */
 		if (jh && (jl = jh->jl)
-		    && jl != SB_JOURNAL(inode->i_sb)->j_current_jl)
+		    && jl != SB_JOURNAL(inode_sb(inode))->j_current_jl)
 			ret = 0;
 	}
 free_jh:
@@ -3221,7 +3228,7 @@ static int reiserfs_set_page_dirty(struct page *page)
 static int reiserfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
 {
 	struct inode *inode = page->mapping->host;
-	struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
+	struct reiserfs_journal *j = SB_JOURNAL(inode_sb(inode));
 	struct buffer_head *head;
 	struct buffer_head *bh;
 	int ret = 1;
@@ -3296,7 +3303,7 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 		if (error)
 			return error;
 	}
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 	if (attr->ia_valid & ATTR_SIZE) {
 		/*
 		 * version 2 items will be caught by the s_maxbytes check
@@ -3304,7 +3311,7 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 		 */
 		if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 &&
 		    attr->ia_size > MAX_NON_LFS) {
-			reiserfs_write_unlock(inode->i_sb);
+			reiserfs_write_unlock(inode_sb(inode));
 			error = -EFBIG;
 			goto out;
 		}
@@ -3318,7 +3325,7 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 				int err;
 				struct reiserfs_transaction_handle th;
 				/* we're changing at most 2 bitmaps, inode + super */
-				err = journal_begin(&th, inode->i_sb, 4);
+				err = journal_begin(&th, inode_sb(inode), 4);
 				if (!err) {
 					reiserfs_discard_prealloc(&th, inode);
 					err = journal_end(&th);
@@ -3327,7 +3334,7 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 					error = err;
 			}
 			if (error) {
-				reiserfs_write_unlock(inode->i_sb);
+				reiserfs_write_unlock(inode_sb(inode));
 				goto out;
 			}
 			/*
@@ -3337,7 +3344,7 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 			attr->ia_valid |= (ATTR_MTIME | ATTR_CTIME);
 		}
 	}
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 
 	if ((((attr->ia_valid & ATTR_UID) && (from_kuid(&init_user_ns, attr->ia_uid) & ~0xffff)) ||
 	     ((attr->ia_valid & ATTR_GID) && (from_kgid(&init_user_ns, attr->ia_gid) & ~0xffff))) &&
@@ -3352,8 +3359,8 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 		struct reiserfs_transaction_handle th;
 		int jbegin_count =
 		    2 *
-		    (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +
-		     REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +
+		    (REISERFS_QUOTA_INIT_BLOCKS(inode_sb(inode)) +
+		     REISERFS_QUOTA_DEL_BLOCKS(inode_sb(inode))) +
 		    2;
 
 		error = reiserfs_chown_xattrs(inode, attr);
@@ -3365,16 +3372,16 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 		 * (user+group)*(old+new) structure - we count quota
 		 * info and , inode write (sb, inode)
 		 */
-		reiserfs_write_lock(inode->i_sb);
-		error = journal_begin(&th, inode->i_sb, jbegin_count);
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_lock(inode_sb(inode));
+		error = journal_begin(&th, inode_sb(inode), jbegin_count);
+		reiserfs_write_unlock(inode_sb(inode));
 		if (error)
 			goto out;
 		error = dquot_transfer(inode, attr);
-		reiserfs_write_lock(inode->i_sb);
+		reiserfs_write_lock(inode_sb(inode));
 		if (error) {
 			journal_end(&th);
-			reiserfs_write_unlock(inode->i_sb);
+			reiserfs_write_unlock(inode_sb(inode));
 			goto out;
 		}
 
@@ -3388,7 +3395,7 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 			inode->i_gid = attr->ia_gid;
 		mark_inode_dirty(inode);
 		error = journal_end(&th);
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 		if (error)
 			goto out;
 	}
@@ -3413,7 +3420,7 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 		mark_inode_dirty(inode);
 	}
 
-	if (!error && reiserfs_posixacl(inode->i_sb)) {
+	if (!error && reiserfs_posixacl(inode_sb(inode))) {
 		if (attr->ia_valid & ATTR_MODE)
 			error = reiserfs_acl_chmod(inode);
 	}
diff --git a/fs/reiserfs/ioctl.c b/fs/reiserfs/ioctl.c
index acbbaf7a0bb2..122dfdfe69c9 100644
--- a/fs/reiserfs/ioctl.c
+++ b/fs/reiserfs/ioctl.c
@@ -26,7 +26,7 @@ long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 	unsigned int flags;
 	int err = 0;
 
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 
 	switch (cmd) {
 	case REISERFS_IOC_UNPACK:
@@ -41,7 +41,7 @@ long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 		 * Card (card@xxxxxxxxxxx)
 		 */
 	case REISERFS_IOC_GETFLAGS:
-		if (!reiserfs_attrs(inode->i_sb)) {
+		if (!reiserfs_attrs(inode_sb(inode))) {
 			err = -ENOTTY;
 			break;
 		}
@@ -50,7 +50,7 @@ long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 		err = put_user(flags, (int __user *)arg);
 		break;
 	case REISERFS_IOC_SETFLAGS:{
-			if (!reiserfs_attrs(inode->i_sb)) {
+			if (!reiserfs_attrs(inode_sb(inode))) {
 				err = -ENOTTY;
 				break;
 			}
@@ -123,7 +123,7 @@ long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 		err = -ENOTTY;
 	}
 
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 
 	return err;
 }
@@ -174,7 +174,7 @@ int reiserfs_unpack(struct inode *inode, struct file *filp)
 	struct page *page;
 	struct address_space *mapping;
 	unsigned long write_from;
-	unsigned long blocksize = inode->i_sb->s_blocksize;
+	unsigned long blocksize = inode_sb(inode)->s_blocksize;
 
 	if (inode->i_size == 0) {
 		REISERFS_I(inode)->i_flags |= i_nopack_mask;
@@ -187,12 +187,12 @@ int reiserfs_unpack(struct inode *inode, struct file *filp)
 
 	/* we need to make sure nobody is changing the file size beneath us */
 {
-	int depth = reiserfs_write_unlock_nested(inode->i_sb);
+	int depth = reiserfs_write_unlock_nested(inode_sb(inode));
 	inode_lock(inode);
-	reiserfs_write_lock_nested(inode->i_sb, depth);
+	reiserfs_write_lock_nested(inode_sb(inode), depth);
 }
 
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 
 	write_from = inode->i_size & (blocksize - 1);
 	/* if we are on a block boundary, we are already unpacked.  */
@@ -228,6 +228,6 @@ int reiserfs_unpack(struct inode *inode, struct file *filp)
 
 out:
 	inode_unlock(inode);
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 	return retval;
 }
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 70057359fbaf..aefcb77de3fd 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -782,11 +782,11 @@ static inline int __add_jh(struct reiserfs_journal *j, struct buffer_head *bh,
 
 int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh)
 {
-	return __add_jh(SB_JOURNAL(inode->i_sb), bh, 1);
+	return __add_jh(SB_JOURNAL(inode_sb(inode)), bh, 1);
 }
 int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh)
 {
-	return __add_jh(SB_JOURNAL(inode->i_sb), bh, 0);
+	return __add_jh(SB_JOURNAL(inode_sb(inode)), bh, 0);
 }
 
 #define JH_ENTRY(l) list_entry((l), struct reiserfs_jh, list)
@@ -3825,7 +3825,7 @@ int journal_mark_freed(struct reiserfs_transaction_handle *th,
 
 void reiserfs_update_inode_transaction(struct inode *inode)
 {
-	struct reiserfs_journal *journal = SB_JOURNAL(inode->i_sb);
+	struct reiserfs_journal *journal = SB_JOURNAL(inode_sb(inode));
 	REISERFS_I(inode)->i_jl = journal->j_current_jl;
 	REISERFS_I(inode)->i_trans_id = journal->j_trans_id;
 }
@@ -3838,7 +3838,7 @@ static int __commit_trans_jl(struct inode *inode, unsigned long id,
 			     struct reiserfs_journal_list *jl)
 {
 	struct reiserfs_transaction_handle th;
-	struct super_block *sb = inode->i_sb;
+	struct super_block *sb = inode_sb(inode);
 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
 	int ret = 0;
 
@@ -3881,7 +3881,7 @@ static int __commit_trans_jl(struct inode *inode, unsigned long id,
 		 * if we've got a larger transaction id than the oldest list
 		 */
 flush_commit_only:
-		if (journal_list_still_alive(inode->i_sb, id)) {
+		if (journal_list_still_alive(inode_sb(inode), id)) {
 			/*
 			 * we only set ret to 1 when we know for sure
 			 * the barrier hasn't been started yet on the commit
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index bd39a998843d..70c1da7d9ef1 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -308,20 +308,20 @@ static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
 	struct cpu_key key_to_search;
 	int retval;
 
-	if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
+	if (namelen > REISERFS_MAX_NAME(inode_sb(dir)->s_blocksize))
 		return NAME_NOT_FOUND;
 
 	/* we will search for this key in the tree */
 	make_cpu_key(&key_to_search, dir,
-		     get_third_component(dir->i_sb, name, namelen),
+		     get_third_component(inode_sb(dir), name, namelen),
 		     TYPE_DIRENTRY, 3);
 
 	while (1) {
 		retval =
-		    search_by_entry_key(dir->i_sb, &key_to_search,
+		    search_by_entry_key(inode_sb(dir), &key_to_search,
 					path_to_entry, de);
 		if (retval == IO_ERROR) {
-			reiserfs_error(dir->i_sb, "zam-7001", "io error");
+			reiserfs_error(inode_sb(dir), "zam-7001", "io error");
 			return IO_ERROR;
 		}
 
@@ -357,10 +357,10 @@ static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
 	struct reiserfs_dir_entry de;
 	INITIALIZE_PATH(path_to_entry);
 
-	if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
+	if (REISERFS_MAX_NAME(inode_sb(dir)->s_blocksize) < dentry->d_name.len)
 		return ERR_PTR(-ENAMETOOLONG);
 
-	reiserfs_write_lock(dir->i_sb);
+	reiserfs_write_lock(inode_sb(dir));
 
 	de.de_gen_number_bit_string = NULL;
 	retval =
@@ -368,10 +368,10 @@ static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
 				&path_to_entry, &de);
 	pathrelse(&path_to_entry);
 	if (retval == NAME_FOUND) {
-		inode = reiserfs_iget(dir->i_sb,
+		inode = reiserfs_iget(inode_sb(dir),
 				      (struct cpu_key *)&de.de_dir_id);
 		if (!inode || IS_ERR(inode)) {
-			reiserfs_write_unlock(dir->i_sb);
+			reiserfs_write_unlock(inode_sb(dir));
 			return ERR_PTR(-EACCES);
 		}
 
@@ -382,7 +382,7 @@ static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
 		if (IS_PRIVATE(dir))
 			inode->i_flags |= S_PRIVATE;
 	}
-	reiserfs_write_unlock(dir->i_sb);
+	reiserfs_write_unlock(inode_sb(dir));
 	if (retval == IO_ERROR) {
 		return ERR_PTR(-EIO);
 	}
@@ -407,15 +407,15 @@ struct dentry *reiserfs_get_parent(struct dentry *child)
 	}
 	de.de_gen_number_bit_string = NULL;
 
-	reiserfs_write_lock(dir->i_sb);
+	reiserfs_write_lock(inode_sb(dir));
 	retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
 	pathrelse(&path_to_entry);
 	if (retval != NAME_FOUND) {
-		reiserfs_write_unlock(dir->i_sb);
+		reiserfs_write_unlock(inode_sb(dir));
 		return ERR_PTR(-ENOENT);
 	}
-	inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&de.de_dir_id);
-	reiserfs_write_unlock(dir->i_sb);
+	inode = reiserfs_iget(inode_sb(dir), (struct cpu_key *)&de.de_dir_id);
+	reiserfs_write_unlock(inode_sb(dir));
 
 	return d_obtain_alias(inode);
 }
@@ -453,12 +453,12 @@ static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
 	if (!namelen)
 		return -EINVAL;
 
-	if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
+	if (namelen > REISERFS_MAX_NAME(inode_sb(dir)->s_blocksize))
 		return -ENAMETOOLONG;
 
 	/* each entry has unique key. compose it */
 	make_cpu_key(&entry_key, dir,
-		     get_third_component(dir->i_sb, name, namelen),
+		     get_third_component(inode_sb(dir), name, namelen),
 		     TYPE_DIRENTRY, 3);
 
 	/* get memory for composing the entry */
@@ -515,7 +515,7 @@ static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
 		}
 
 		if (retval != NAME_FOUND) {
-			reiserfs_error(dir->i_sb, "zam-7002",
+			reiserfs_error(inode_sb(dir), "zam-7002",
 				       "reiserfs_find_entry() returned "
 				       "unexpected value (%d)", retval);
 		}
@@ -528,7 +528,7 @@ static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
 				MAX_GENERATION_NUMBER + 1);
 	if (gen_number > MAX_GENERATION_NUMBER) {
 		/* there is no free generation number */
-		reiserfs_warning(dir->i_sb, "reiserfs-7010",
+		reiserfs_warning(inode_sb(dir), "reiserfs-7010",
 				 "Congratulations! we have got hash function "
 				 "screwed up");
 		if (buffer != small_buf)
@@ -545,9 +545,9 @@ static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
 
 	/* we need to re-search for the insertion point */
 	if (gen_number != 0) {
-		if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
+		if (search_by_entry_key(inode_sb(dir), &entry_key, &path, &de) !=
 		    NAME_NOT_FOUND) {
-			reiserfs_warning(dir->i_sb, "vs-7032",
+			reiserfs_warning(inode_sb(dir), "vs-7032",
 					 "entry with this key (%K) already "
 					 "exists", &entry_key);
 
@@ -627,8 +627,8 @@ static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mod
 	 */
 	int jbegin_count =
 	    JOURNAL_PER_BALANCE_CNT * 2 +
-	    2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
-		 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
+	    2 * (REISERFS_QUOTA_INIT_BLOCKS(inode_sb(dir)) +
+		 REISERFS_QUOTA_TRANS_BLOCKS(inode_sb(dir)));
 	struct reiserfs_transaction_handle th;
 	struct reiserfs_security_handle security;
 
@@ -636,7 +636,7 @@ static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mod
 	if (retval)
 		return retval;
 
-	if (!(inode = new_inode(dir->i_sb))) {
+	if (!(inode = new_inode(inode_sb(dir)))) {
 		return -ENOMEM;
 	}
 	retval = new_inode_init(inode, dir, mode);
@@ -652,9 +652,9 @@ static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mod
 		return retval;
 	}
 	jbegin_count += retval;
-	reiserfs_write_lock(dir->i_sb);
+	reiserfs_write_lock(inode_sb(dir));
 
-	retval = journal_begin(&th, dir->i_sb, jbegin_count);
+	retval = journal_begin(&th, inode_sb(dir), jbegin_count);
 	if (retval) {
 		drop_new_inode(inode);
 		goto out_failed;
@@ -692,7 +692,7 @@ static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mod
 	retval = journal_end(&th);
 
 out_failed:
-	reiserfs_write_unlock(dir->i_sb);
+	reiserfs_write_unlock(inode_sb(dir));
 	return retval;
 }
 
@@ -709,14 +709,14 @@ static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode
 	 */
 	int jbegin_count =
 	    JOURNAL_PER_BALANCE_CNT * 3 +
-	    2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
-		 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
+	    2 * (REISERFS_QUOTA_INIT_BLOCKS(inode_sb(dir)) +
+		 REISERFS_QUOTA_TRANS_BLOCKS(inode_sb(dir)));
 
 	retval = dquot_initialize(dir);
 	if (retval)
 		return retval;
 
-	if (!(inode = new_inode(dir->i_sb))) {
+	if (!(inode = new_inode(inode_sb(dir)))) {
 		return -ENOMEM;
 	}
 	retval = new_inode_init(inode, dir, mode);
@@ -732,9 +732,9 @@ static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode
 		return retval;
 	}
 	jbegin_count += retval;
-	reiserfs_write_lock(dir->i_sb);
+	reiserfs_write_lock(inode_sb(dir));
 
-	retval = journal_begin(&th, dir->i_sb, jbegin_count);
+	retval = journal_begin(&th, inode_sb(dir), jbegin_count);
 	if (retval) {
 		drop_new_inode(inode);
 		goto out_failed;
@@ -776,7 +776,7 @@ static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode
 	retval = journal_end(&th);
 
 out_failed:
-	reiserfs_write_unlock(dir->i_sb);
+	reiserfs_write_unlock(inode_sb(dir));
 	return retval;
 }
 
@@ -792,8 +792,8 @@ static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
 	 */
 	int jbegin_count =
 	    JOURNAL_PER_BALANCE_CNT * 3 +
-	    2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
-		 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
+	    2 * (REISERFS_QUOTA_INIT_BLOCKS(inode_sb(dir)) +
+		 REISERFS_QUOTA_TRANS_BLOCKS(inode_sb(dir)));
 
 	retval = dquot_initialize(dir);
 	if (retval)
@@ -807,7 +807,7 @@ static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
 	REISERFS_I(dir)->new_packing_locality = 1;
 #endif
 	mode = S_IFDIR | mode;
-	if (!(inode = new_inode(dir->i_sb))) {
+	if (!(inode = new_inode(inode_sb(dir)))) {
 		return -ENOMEM;
 	}
 	retval = new_inode_init(inode, dir, mode);
@@ -823,9 +823,9 @@ static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
 		return retval;
 	}
 	jbegin_count += retval;
-	reiserfs_write_lock(dir->i_sb);
+	reiserfs_write_lock(inode_sb(dir));
 
-	retval = journal_begin(&th, dir->i_sb, jbegin_count);
+	retval = journal_begin(&th, inode_sb(dir), jbegin_count);
 	if (retval) {
 		drop_new_inode(inode);
 		goto out_failed;
@@ -838,7 +838,7 @@ static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
 	INC_DIR_INODE_NLINK(dir)
 
 	    retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
-					old_format_only(dir->i_sb) ?
+					old_format_only(inode_sb(dir)) ?
 					EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
 					dentry, inode, &security);
 	if (retval) {
@@ -875,7 +875,7 @@ static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
 	d_instantiate(dentry, inode);
 	retval = journal_end(&th);
 out_failed:
-	reiserfs_write_unlock(dir->i_sb);
+	reiserfs_write_unlock(inode_sb(dir));
 	return retval;
 }
 
@@ -911,14 +911,14 @@ static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
 	 */
 	jbegin_count =
 	    JOURNAL_PER_BALANCE_CNT * 2 + 2 +
-	    4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
+	    4 * REISERFS_QUOTA_TRANS_BLOCKS(inode_sb(dir));
 
 	retval = dquot_initialize(dir);
 	if (retval)
 		return retval;
 
-	reiserfs_write_lock(dir->i_sb);
-	retval = journal_begin(&th, dir->i_sb, jbegin_count);
+	reiserfs_write_lock(inode_sb(dir));
+	retval = journal_begin(&th, inode_sb(dir), jbegin_count);
 	if (retval)
 		goto out_rmdir;
 
@@ -958,7 +958,7 @@ static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
 		goto end_rmdir;
 
 	if (inode->i_nlink != 2 && inode->i_nlink != 1)
-		reiserfs_error(inode->i_sb, "reiserfs-7040",
+		reiserfs_error(inode_sb(inode), "reiserfs-7040",
 			       "empty directory has nlink != 2 (%d)",
 			       inode->i_nlink);
 
@@ -976,7 +976,7 @@ static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
 	retval = journal_end(&th);
 	reiserfs_check_path(&path);
 out_rmdir:
-	reiserfs_write_unlock(dir->i_sb);
+	reiserfs_write_unlock(inode_sb(dir));
 	return retval;
 
 end_rmdir:
@@ -987,7 +987,7 @@ static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
 	 */
 	pathrelse(&path);
 	err = journal_end(&th);
-	reiserfs_write_unlock(dir->i_sb);
+	reiserfs_write_unlock(inode_sb(dir));
 	return err ? err : retval;
 }
 
@@ -1016,10 +1016,10 @@ static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
 	 */
 	jbegin_count =
 	    JOURNAL_PER_BALANCE_CNT * 2 + 2 +
-	    4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
+	    4 * REISERFS_QUOTA_TRANS_BLOCKS(inode_sb(dir));
 
-	reiserfs_write_lock(dir->i_sb);
-	retval = journal_begin(&th, dir->i_sb, jbegin_count);
+	reiserfs_write_lock(inode_sb(dir));
+	retval = journal_begin(&th, inode_sb(dir), jbegin_count);
 	if (retval)
 		goto out_unlink;
 
@@ -1046,7 +1046,7 @@ static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
 	}
 
 	if (!inode->i_nlink) {
-		reiserfs_warning(inode->i_sb, "reiserfs-7042",
+		reiserfs_warning(inode_sb(inode), "reiserfs-7042",
 				 "deleting nonexistent file (%lu), %d",
 				 inode->i_ino, inode->i_nlink);
 		set_nlink(inode, 1);
@@ -1080,7 +1080,7 @@ static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
 
 	retval = journal_end(&th);
 	reiserfs_check_path(&path);
-	reiserfs_write_unlock(dir->i_sb);
+	reiserfs_write_unlock(inode_sb(dir));
 	return retval;
 
 end_unlink:
@@ -1090,7 +1090,7 @@ static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
 	if (err)
 		retval = err;
 out_unlink:
-	reiserfs_write_unlock(dir->i_sb);
+	reiserfs_write_unlock(inode_sb(dir));
 	return retval;
 }
 
@@ -1110,14 +1110,14 @@ static int reiserfs_symlink(struct inode *parent_dir,
 	 */
 	int jbegin_count =
 	    JOURNAL_PER_BALANCE_CNT * 3 +
-	    2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
-		 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
+	    2 * (REISERFS_QUOTA_INIT_BLOCKS(inode_sb(parent_dir)) +
+		 REISERFS_QUOTA_TRANS_BLOCKS(inode_sb(parent_dir)));
 
 	retval = dquot_initialize(parent_dir);
 	if (retval)
 		return retval;
 
-	if (!(inode = new_inode(parent_dir->i_sb))) {
+	if (!(inode = new_inode(inode_sb(parent_dir)))) {
 		return -ENOMEM;
 	}
 	retval = new_inode_init(inode, parent_dir, mode);
@@ -1134,9 +1134,9 @@ static int reiserfs_symlink(struct inode *parent_dir,
 	}
 	jbegin_count += retval;
 
-	reiserfs_write_lock(parent_dir->i_sb);
+	reiserfs_write_lock(inode_sb(parent_dir));
 	item_len = ROUND_UP(strlen(symname));
-	if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
+	if (item_len > MAX_DIRECT_ITEM_LEN(inode_sb(parent_dir)->s_blocksize)) {
 		retval = -ENAMETOOLONG;
 		drop_new_inode(inode);
 		goto out_failed;
@@ -1151,7 +1151,7 @@ static int reiserfs_symlink(struct inode *parent_dir,
 	memcpy(name, symname, strlen(symname));
 	padd_item(name, item_len, strlen(symname));
 
-	retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
+	retval = journal_begin(&th, inode_sb(parent_dir), jbegin_count);
 	if (retval) {
 		drop_new_inode(inode);
 		kfree(name);
@@ -1191,7 +1191,7 @@ static int reiserfs_symlink(struct inode *parent_dir,
 	d_instantiate(dentry, inode);
 	retval = journal_end(&th);
 out_failed:
-	reiserfs_write_unlock(parent_dir->i_sb);
+	reiserfs_write_unlock(inode_sb(parent_dir));
 	return retval;
 }
 
@@ -1207,26 +1207,26 @@ static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
 	 */
 	int jbegin_count =
 	    JOURNAL_PER_BALANCE_CNT * 3 +
-	    2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
+	    2 * REISERFS_QUOTA_TRANS_BLOCKS(inode_sb(dir));
 
 	retval = dquot_initialize(dir);
 	if (retval)
 		return retval;
 
-	reiserfs_write_lock(dir->i_sb);
+	reiserfs_write_lock(inode_sb(dir));
 	if (inode->i_nlink >= REISERFS_LINK_MAX) {
 		/* FIXME: sd_nlink is 32 bit for new files */
-		reiserfs_write_unlock(dir->i_sb);
+		reiserfs_write_unlock(inode_sb(dir));
 		return -EMLINK;
 	}
 
 	/* inc before scheduling so reiserfs_unlink knows we are here */
 	inc_nlink(inode);
 
-	retval = journal_begin(&th, dir->i_sb, jbegin_count);
+	retval = journal_begin(&th, inode_sb(dir), jbegin_count);
 	if (retval) {
 		drop_nlink(inode);
-		reiserfs_write_unlock(dir->i_sb);
+		reiserfs_write_unlock(inode_sb(dir));
 		return retval;
 	}
 
@@ -1242,7 +1242,7 @@ static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
 		int err;
 		drop_nlink(inode);
 		err = journal_end(&th);
-		reiserfs_write_unlock(dir->i_sb);
+		reiserfs_write_unlock(inode_sb(dir));
 		return err ? err : retval;
 	}
 
@@ -1252,7 +1252,7 @@ static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
 	ihold(inode);
 	d_instantiate(dentry, inode);
 	retval = journal_end(&th);
-	reiserfs_write_unlock(dir->i_sb);
+	reiserfs_write_unlock(inode_sb(dir));
 	return retval;
 }
 
@@ -1279,7 +1279,7 @@ static int entry_points_to_object(const char *name, int len,
 
 	if (inode) {
 		if (!de_visible(de->de_deh + de->de_entry_num))
-			reiserfs_panic(inode->i_sb, "vs-7042",
+			reiserfs_panic(inode_sb(inode), "vs-7042",
 				       "entry must be visible");
 		return (de->de_objectid == inode->i_ino) ? 1 : 0;
 	}
@@ -1337,7 +1337,7 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 	 */
 	jbegin_count =
 	    JOURNAL_PER_BALANCE_CNT * 3 + 5 +
-	    4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
+	    4 * REISERFS_QUOTA_TRANS_BLOCKS(inode_sb(old_dir));
 
 	retval = dquot_initialize(old_dir);
 	if (retval)
@@ -1354,19 +1354,19 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 	 * are going to rename
 	 */
 	old_de.de_gen_number_bit_string = NULL;
-	reiserfs_write_lock(old_dir->i_sb);
+	reiserfs_write_lock(inode_sb(old_dir));
 	retval =
 	    reiserfs_find_entry(old_dir, old_dentry->d_name.name,
 				old_dentry->d_name.len, &old_entry_path,
 				&old_de);
 	pathrelse(&old_entry_path);
 	if (retval == IO_ERROR) {
-		reiserfs_write_unlock(old_dir->i_sb);
+		reiserfs_write_unlock(inode_sb(old_dir));
 		return -EIO;
 	}
 
 	if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
-		reiserfs_write_unlock(old_dir->i_sb);
+		reiserfs_write_unlock(inode_sb(old_dir));
 		return -ENOENT;
 	}
 
@@ -1379,7 +1379,7 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 		 */
 		if (new_dentry_inode) {
 			if (!reiserfs_empty_dir(new_dentry_inode)) {
-				reiserfs_write_unlock(old_dir->i_sb);
+				reiserfs_write_unlock(inode_sb(old_dir));
 				return -ENOTEMPTY;
 			}
 		}
@@ -1394,20 +1394,20 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 					&dot_dot_de);
 		pathrelse(&dot_dot_entry_path);
 		if (retval != NAME_FOUND) {
-			reiserfs_write_unlock(old_dir->i_sb);
+			reiserfs_write_unlock(inode_sb(old_dir));
 			return -EIO;
 		}
 
 		/* inode number of .. must equal old_dir->i_ino */
 		if (dot_dot_de.de_objectid != old_dir->i_ino) {
-			reiserfs_write_unlock(old_dir->i_sb);
+			reiserfs_write_unlock(inode_sb(old_dir));
 			return -EIO;
 		}
 	}
 
-	retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
+	retval = journal_begin(&th, inode_sb(old_dir), jbegin_count);
 	if (retval) {
-		reiserfs_write_unlock(old_dir->i_sb);
+		reiserfs_write_unlock(inode_sb(old_dir));
 		return retval;
 	}
 
@@ -1417,12 +1417,12 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 			       new_dentry->d_name.len, old_inode, 0);
 	if (retval == -EEXIST) {
 		if (!new_dentry_inode) {
-			reiserfs_panic(old_dir->i_sb, "vs-7050",
+			reiserfs_panic(inode_sb(old_dir), "vs-7050",
 				       "new entry is found, new inode == 0");
 		}
 	} else if (retval) {
 		int err = journal_end(&th);
-		reiserfs_write_unlock(old_dir->i_sb);
+		reiserfs_write_unlock(inode_sb(old_dir));
 		return err ? err : retval;
 	}
 
@@ -1444,18 +1444,19 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 		 * (found by reiserfs_find_entry)
 		 */
 		if ((retval =
-		     search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
+		     search_by_entry_key(inode_sb(new_dir), &old_de.de_entry_key,
 					 &old_entry_path,
 					 &old_de)) != NAME_FOUND) {
 			pathrelse(&old_entry_path);
 			journal_end(&th);
-			reiserfs_write_unlock(old_dir->i_sb);
+			reiserfs_write_unlock(inode_sb(old_dir));
 			return -EIO;
 		}
 
 		copy_item_head(&old_entry_ih, tp_item_head(&old_entry_path));
 
-		reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
+		reiserfs_prepare_for_journal(inode_sb(old_inode),
+					     old_de.de_bh, 1);
 
 		/* look for new name by reiserfs_find_entry */
 		new_de.de_gen_number_bit_string = NULL;
@@ -1473,17 +1474,18 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 			pathrelse(&new_entry_path);
 			pathrelse(&old_entry_path);
 			journal_end(&th);
-			reiserfs_write_unlock(old_dir->i_sb);
+			reiserfs_write_unlock(inode_sb(old_dir));
 			return -EIO;
 		}
 
 		copy_item_head(&new_entry_ih, tp_item_head(&new_entry_path));
 
-		reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
+		reiserfs_prepare_for_journal(inode_sb(old_inode),
+					     new_de.de_bh, 1);
 
 		if (S_ISDIR(old_inode->i_mode)) {
 			if ((retval =
-			     search_by_entry_key(new_dir->i_sb,
+			     search_by_entry_key(inode_sb(new_dir),
 						 &dot_dot_de.de_entry_key,
 						 &dot_dot_entry_path,
 						 &dot_dot_de)) != NAME_FOUND) {
@@ -1491,13 +1493,13 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 				pathrelse(&new_entry_path);
 				pathrelse(&old_entry_path);
 				journal_end(&th);
-				reiserfs_write_unlock(old_dir->i_sb);
+				reiserfs_write_unlock(inode_sb(old_dir));
 				return -EIO;
 			}
 			copy_item_head(&dot_dot_ih,
 				       tp_item_head(&dot_dot_entry_path));
 			/* node containing ".." gets into transaction */
-			reiserfs_prepare_for_journal(old_inode->i_sb,
+			reiserfs_prepare_for_journal(inode_sb(old_inode),
 						     dot_dot_de.de_bh, 1);
 		}
 		/*
@@ -1525,13 +1527,12 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 		    !entry_points_to_object(old_dentry->d_name.name,
 					    old_dentry->d_name.len,
 					    &old_de, old_inode)) {
-			reiserfs_restore_prepared_buffer(old_inode->i_sb,
+			reiserfs_restore_prepared_buffer(inode_sb(old_inode),
 							 new_de.de_bh);
-			reiserfs_restore_prepared_buffer(old_inode->i_sb,
+			reiserfs_restore_prepared_buffer(inode_sb(old_inode),
 							 old_de.de_bh);
 			if (S_ISDIR(old_inode_mode))
-				reiserfs_restore_prepared_buffer(old_inode->
-								 i_sb,
+				reiserfs_restore_prepared_buffer(inode_sb(old_inode),
 								 dot_dot_de.
 								 de_bh);
 			continue;
@@ -1540,14 +1541,11 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 			if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
 			    !entry_points_to_object("..", 2, &dot_dot_de,
 						    old_dir)) {
-				reiserfs_restore_prepared_buffer(old_inode->
-								 i_sb,
+				reiserfs_restore_prepared_buffer(inode_sb(old_inode),
 								 old_de.de_bh);
-				reiserfs_restore_prepared_buffer(old_inode->
-								 i_sb,
+				reiserfs_restore_prepared_buffer(inode_sb(old_inode),
 								 new_de.de_bh);
-				reiserfs_restore_prepared_buffer(old_inode->
-								 i_sb,
+				reiserfs_restore_prepared_buffer(inode_sb(old_inode),
 								 dot_dot_de.
 								 de_bh);
 				continue;
@@ -1621,7 +1619,7 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 	if (reiserfs_cut_from_item
 	    (&th, &old_entry_path, &old_de.de_entry_key, old_dir, NULL,
 	     0) < 0)
-		reiserfs_error(old_dir->i_sb, "vs-7060",
+		reiserfs_error(inode_sb(old_dir), "vs-7060",
 			       "couldn't not cut old name. Fsck later?");
 
 	old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
@@ -1638,7 +1636,7 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 	}
 
 	retval = journal_end(&th);
-	reiserfs_write_unlock(old_dir->i_sb);
+	reiserfs_write_unlock(inode_sb(old_dir));
 	return retval;
 }
 
diff --git a/fs/reiserfs/reiserfs.h b/fs/reiserfs/reiserfs.h
index 48835a659948..2523d838588c 100644
--- a/fs/reiserfs/reiserfs.h
+++ b/fs/reiserfs/reiserfs.h
@@ -2886,7 +2886,7 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *,
 
 static inline int reiserfs_file_data_log(struct inode *inode)
 {
-	if (reiserfs_data_log(inode->i_sb) ||
+	if (reiserfs_data_log(inode_sb(inode)) ||
 	    (REISERFS_I(inode)->i_flags & i_data_log))
 		return 1;
 	return 0;
@@ -3042,12 +3042,12 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
 			 struct inode *inode, struct page *,
 			 int update_timestamps);
 
-#define i_block_size(inode) ((inode)->i_sb->s_blocksize)
+#define i_block_size(inode) (inode_sb((inode))->s_blocksize)
 #define file_size(inode) ((inode)->i_size)
 #define tail_size(inode) (file_size (inode) & (i_block_size (inode) - 1))
 
-#define tail_has_to_be_packed(inode) (have_large_tails ((inode)->i_sb)?\
-!STORE_TAIL_IN_UNFM_S1(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):have_small_tails ((inode)->i_sb)?!STORE_TAIL_IN_UNFM_S2(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):0 )
+#define tail_has_to_be_packed(inode) (have_large_tails (inode_sb((inode)))?\
+!STORE_TAIL_IN_UNFM_S1(file_size (inode), tail_size(inode), inode_sb(inode)->s_blocksize):have_small_tails (inode_sb((inode)))?!STORE_TAIL_IN_UNFM_S2(file_size (inode), tail_size(inode), inode_sb(inode)->s_blocksize):0 )
 
 void padd_item(char *item, int total_length, int length);
 
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index 0037aea97d39..a69a974ef362 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -1029,7 +1029,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th,
 				      unsigned long long new_file_length
     )
 {
-	struct super_block *sb = inode->i_sb;
+	struct super_block *sb = inode_sb(inode);
 	struct item_head *p_le_ih = tp_item_head(path);
 	struct buffer_head *bh = PATH_PLAST_BUFFER(path);
 
@@ -1235,7 +1235,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th,
 			 struct treepath *path, const struct cpu_key *item_key,
 			 struct inode *inode, struct buffer_head *un_bh)
 {
-	struct super_block *sb = inode->i_sb;
+	struct super_block *sb = inode_sb(inode);
 	struct tree_balance s_del_balance;
 	struct item_head s_ih;
 	struct item_head *q_ih;
@@ -1358,9 +1358,9 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th,
 		       "reiserquota delete_item(): freeing %u, id=%u type=%c",
 		       quota_cut_bytes, inode->i_uid, head2type(&s_ih));
 #endif
-	depth = reiserfs_write_unlock_nested(inode->i_sb);
+	depth = reiserfs_write_unlock_nested(inode_sb(inode));
 	dquot_free_space_nodirty(inode, quota_cut_bytes);
-	reiserfs_write_lock_nested(inode->i_sb, depth);
+	reiserfs_write_lock_nested(inode_sb(inode), depth);
 
 	/* Return deleted body length */
 	return ret_value;
@@ -1544,7 +1544,7 @@ static int maybe_indirect_to_direct(struct reiserfs_transaction_handle *th,
 				    const struct cpu_key *item_key,
 				    loff_t new_file_size, char *mode)
 {
-	struct super_block *sb = inode->i_sb;
+	struct super_block *sb = inode_sb(inode);
 	int block_size = sb->s_blocksize;
 	int cut_bytes;
 	BUG_ON(!th->t_trans_id);
@@ -1589,12 +1589,12 @@ static void indirect_to_direct_roll_back(struct reiserfs_transaction_handle *th,
 	tail_key.key_length = 4;
 
 	tail_len =
-	    (cpu_key_k_offset(&tail_key) & (inode->i_sb->s_blocksize - 1)) - 1;
+	    (cpu_key_k_offset(&tail_key) & (inode_sb(inode)->s_blocksize - 1)) - 1;
 	while (tail_len) {
 		/* look for the last byte of the tail */
-		if (search_for_position_by_key(inode->i_sb, &tail_key, path) ==
+		if (search_for_position_by_key(inode_sb(inode), &tail_key, path) ==
 		    POSITION_NOT_FOUND)
-			reiserfs_panic(inode->i_sb, "vs-5615",
+			reiserfs_panic(inode_sb(inode), "vs-5615",
 				       "found invalid item");
 		RFALSE(path->pos_in_item !=
 		       ih_item_len(tp_item_head(path)) - 1,
@@ -1612,7 +1612,8 @@ static void indirect_to_direct_roll_back(struct reiserfs_transaction_handle *th,
 		set_cpu_key_k_offset(&tail_key,
 				     cpu_key_k_offset(&tail_key) - removed);
 	}
-	reiserfs_warning(inode->i_sb, "reiserfs-5091", "indirect_to_direct "
+	reiserfs_warning(inode_sb(inode), "reiserfs-5091",
+			 "indirect_to_direct "
 			 "conversion has been rolled back due to "
 			 "lack of disk space");
 	mark_inode_dirty(inode);
@@ -1625,7 +1626,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
 			   struct inode *inode,
 			   struct page *page, loff_t new_file_size)
 {
-	struct super_block *sb = inode->i_sb;
+	struct super_block *sb = inode_sb(inode);
 	/*
 	 * Every function which is going to call do_balance must first
 	 * create a tree_balance structure.  Then it must fill up this
@@ -1646,7 +1647,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
 
 	BUG_ON(!th->t_trans_id);
 
-	init_tb_struct(th, &s_cut_balance, inode->i_sb, path,
+	init_tb_struct(th, &s_cut_balance, inode_sb(inode), path,
 		       cut_size);
 
 	/*
@@ -1830,7 +1831,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
 		REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
 	}
 #ifdef REISERQUOTA_DEBUG
-	reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE,
+	reiserfs_debug(inode_sb(inode), REISERFS_DEBUG_CODE,
 		       "reiserquota cut_from_item(): freeing %u id=%u type=%c",
 		       quota_cut_bytes, inode->i_uid, '?');
 #endif
@@ -1845,7 +1846,7 @@ static void truncate_directory(struct reiserfs_transaction_handle *th,
 {
 	BUG_ON(!th->t_trans_id);
 	if (inode->i_nlink)
-		reiserfs_error(inode->i_sb, "vs-5655", "link count != 0");
+		reiserfs_error(inode_sb(inode), "vs-5655", "link count != 0");
 
 	set_le_key_k_offset(KEY_FORMAT_3_5, INODE_PKEY(inode), DOT_OFFSET);
 	set_le_key_k_type(KEY_FORMAT_3_5, INODE_PKEY(inode), TYPE_DIRENTRY);
@@ -1900,17 +1901,17 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
 		     TYPE_DIRECT, 3);
 
 	retval =
-	    search_for_position_by_key(inode->i_sb, &s_item_key,
+	    search_for_position_by_key(inode_sb(inode), &s_item_key,
 				       &s_search_path);
 	if (retval == IO_ERROR) {
-		reiserfs_error(inode->i_sb, "vs-5657",
+		reiserfs_error(inode_sb(inode), "vs-5657",
 			       "i/o failure occurred trying to truncate %K",
 			       &s_item_key);
 		err = -EIO;
 		goto out;
 	}
 	if (retval == POSITION_FOUND || retval == FILE_NOT_FOUND) {
-		reiserfs_error(inode->i_sb, "PAP-5660",
+		reiserfs_error(inode_sb(inode), "PAP-5660",
 			       "wrong result %d of search for %K", retval,
 			       &s_item_key);
 
@@ -1927,7 +1928,7 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
 	else {
 		loff_t offset = le_ih_k_offset(p_le_ih);
 		int bytes =
-		    op_bytes_number(p_le_ih, inode->i_sb->s_blocksize);
+		    op_bytes_number(p_le_ih, inode_sb(inode)->s_blocksize);
 
 		/*
 		 * this may mismatch with real file size: if last direct item
@@ -1956,7 +1957,7 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
 		    reiserfs_cut_from_item(th, &s_search_path, &s_item_key,
 					   inode, page, new_file_size);
 		if (deleted < 0) {
-			reiserfs_warning(inode->i_sb, "vs-5665",
+			reiserfs_warning(inode_sb(inode), "vs-5665",
 					 "reiserfs_cut_from_item failed");
 			reiserfs_check_path(&s_search_path);
 			return 0;
@@ -1996,14 +1997,14 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
 			err = journal_end(th);
 			if (err)
 				goto out;
-			err = journal_begin(th, inode->i_sb,
+			err = journal_begin(th, inode_sb(inode),
 					    JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD + JOURNAL_PER_BALANCE_CNT * 4) ;
 			if (err)
 				goto out;
 			reiserfs_update_inode_transaction(inode);
 		}
 	} while (file_size > ROUND_UP(new_file_size) &&
-		 search_for_position_by_key(inode->i_sb, &s_item_key,
+		 search_for_position_by_key(inode_sb(inode), &s_item_key,
 					    &s_search_path) == POSITION_FOUND);
 
 	RFALSE(file_size > ROUND_UP(new_file_size),
@@ -2074,7 +2075,7 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th,
 			     /* Size of pasted bytes. */
 			     int pasted_size)
 {
-	struct super_block *sb = inode->i_sb;
+	struct super_block *sb = inode_sb(inode);
 	struct tree_balance s_paste_balance;
 	int retval;
 	int fs_gen;
@@ -2082,10 +2083,10 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th,
 
 	BUG_ON(!th->t_trans_id);
 
-	fs_gen = get_generation(inode->i_sb);
+	fs_gen = get_generation(inode_sb(inode));
 
 #ifdef REISERQUOTA_DEBUG
-	reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE,
+	reiserfs_debug(inode_sb(inode), REISERFS_DEBUG_CODE,
 		       "reiserquota paste_into_item(): allocating %u id=%u type=%c",
 		       pasted_size, inode->i_uid,
 		       key2type(&key->on_disk_key));
@@ -2105,7 +2106,7 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th,
 #endif
 
 	/* DQUOT_* can schedule, must check before the fix_nodes */
-	if (fs_changed(fs_gen, inode->i_sb)) {
+	if (fs_changed(fs_gen, inode_sb(inode))) {
 		goto search_again;
 	}
 
@@ -2123,7 +2124,7 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th,
 			goto error_out;
 		}
 		if (retval == POSITION_FOUND) {
-			reiserfs_warning(inode->i_sb, "PAP-5710",
+			reiserfs_warning(inode_sb(inode), "PAP-5710",
 					 "entry or pasted byte (%K) exists",
 					 key);
 			retval = -EEXIST;
@@ -2147,7 +2148,7 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th,
 	/* this also releases the path */
 	unfix_nodes(&s_paste_balance);
 #ifdef REISERQUOTA_DEBUG
-	reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE,
+	reiserfs_debug(inode_sb(inode), REISERFS_DEBUG_CODE,
 		       "reiserquota paste_into_item(): freeing %u id=%u type=%c",
 		       pasted_size, inode->i_uid,
 		       key2type(&key->on_disk_key));
@@ -2179,7 +2180,7 @@ int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
 
 	if (inode) {		/* Do we count quotas for item? */
 		int depth;
-		fs_gen = get_generation(inode->i_sb);
+		fs_gen = get_generation(inode_sb(inode));
 		quota_bytes = ih_item_len(ih);
 
 		/*
@@ -2188,9 +2189,9 @@ int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
 		 * so there's no guessing needed
 		 */
 		if (!S_ISLNK(inode->i_mode) && is_direct_le_ih(ih))
-			quota_bytes = inode->i_sb->s_blocksize + UNFM_P_SIZE;
+			quota_bytes = inode_sb(inode)->s_blocksize + UNFM_P_SIZE;
 #ifdef REISERQUOTA_DEBUG
-		reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE,
+		reiserfs_debug(inode_sb(inode), REISERFS_DEBUG_CODE,
 			       "reiserquota insert_item(): allocating %u id=%u type=%c",
 			       quota_bytes, inode->i_uid, head2type(ih));
 #endif
@@ -2198,9 +2199,9 @@ int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
 		 * We can't dirty inode here. It would be immediately
 		 * written but appropriate stat item isn't inserted yet...
 		 */
-		depth = reiserfs_write_unlock_nested(inode->i_sb);
+		depth = reiserfs_write_unlock_nested(inode_sb(inode));
 		retval = dquot_alloc_space_nodirty(inode, quota_bytes);
-		reiserfs_write_lock_nested(inode->i_sb, depth);
+		reiserfs_write_lock_nested(inode_sb(inode), depth);
 		if (retval) {
 			pathrelse(path);
 			return retval;
@@ -2215,7 +2216,7 @@ int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
 	 * DQUOT_* can schedule, must check to be sure calling
 	 * fix_nodes is safe
 	 */
-	if (inode && fs_changed(fs_gen, inode->i_sb)) {
+	if (inode && fs_changed(fs_gen, inode_sb(inode))) {
 		goto search_again;
 	}
 
@@ -2255,9 +2256,9 @@ int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
 		       quota_bytes, inode->i_uid, head2type(ih));
 #endif
 	if (inode) {
-		int depth = reiserfs_write_unlock_nested(inode->i_sb);
+		int depth = reiserfs_write_unlock_nested(inode_sb(inode));
 		dquot_free_space_nodirty(inode, quota_bytes);
-		reiserfs_write_lock_nested(inode->i_sb, depth);
+		reiserfs_write_lock_nested(inode_sb(inode), depth);
 	}
 	return retval;
 }
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 1fc934d24459..031010fe79f9 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -340,9 +340,9 @@ static int finish_unfinished(struct super_block *s)
 			retval = remove_save_link_only(s, &save_link_key, 0);
 			continue;
 		}
-		depth = reiserfs_write_unlock_nested(inode->i_sb);
+		depth = reiserfs_write_unlock_nested(inode_sb(inode));
 		dquot_initialize(inode);
-		reiserfs_write_lock_nested(inode->i_sb, depth);
+		reiserfs_write_lock_nested(inode_sb(inode), depth);
 
 		if (truncate && S_ISDIR(inode->i_mode)) {
 			/*
@@ -453,17 +453,18 @@ void add_save_link(struct reiserfs_transaction_handle *th,
 	key.on_disk_key.k_objectid = inode->i_ino;
 	if (!truncate) {
 		/* unlink, rmdir, rename */
-		set_cpu_key_k_offset(&key, 1 + inode->i_sb->s_blocksize);
+		set_cpu_key_k_offset(&key, 1 + inode_sb(inode)->s_blocksize);
 		set_cpu_key_k_type(&key, TYPE_DIRECT);
 
 		/* item head of "safe" link */
 		make_le_item_head(&ih, &key, key.version,
-				  1 + inode->i_sb->s_blocksize, TYPE_DIRECT,
+				  1 + inode_sb(inode)->s_blocksize,
+				  TYPE_DIRECT,
 				  4 /*length */ , 0xffff /*free space */ );
 	} else {
 		/* truncate */
 		if (S_ISDIR(inode->i_mode))
-			reiserfs_warning(inode->i_sb, "green-2102",
+			reiserfs_warning(inode_sb(inode), "green-2102",
 					 "Adding a truncate savelink for "
 					 "a directory %k! Please report",
 					 INODE_PKEY(inode));
@@ -477,10 +478,10 @@ void add_save_link(struct reiserfs_transaction_handle *th,
 	key.key_length = 3;
 
 	/* look for its place in the tree */
-	retval = search_item(inode->i_sb, &key, &path);
+	retval = search_item(inode_sb(inode), &key, &path);
 	if (retval != ITEM_NOT_FOUND) {
 		if (retval != -ENOSPC)
-			reiserfs_error(inode->i_sb, "vs-2100",
+			reiserfs_error(inode_sb(inode), "vs-2100",
 				       "search_by_key (%K) returned %d", &key,
 				       retval);
 		pathrelse(&path);
@@ -495,7 +496,7 @@ void add_save_link(struct reiserfs_transaction_handle *th,
 	    reiserfs_insert_item(th, &path, &key, &ih, NULL, (char *)&link);
 	if (retval) {
 		if (retval != -ENOSPC)
-			reiserfs_error(inode->i_sb, "vs-2120",
+			reiserfs_error(inode_sb(inode), "vs-2120",
 				       "insert_item returned %d", retval);
 	} else {
 		if (truncate)
@@ -514,7 +515,7 @@ int remove_save_link(struct inode *inode, int truncate)
 	int err;
 
 	/* we are going to do one balancing only */
-	err = journal_begin(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
+	err = journal_begin(&th, inode_sb(inode), JOURNAL_PER_BALANCE_CNT);
 	if (err)
 		return err;
 
@@ -524,7 +525,7 @@ int remove_save_link(struct inode *inode, int truncate)
 	if (!truncate) {
 		/* unlink, rmdir, rename */
 		set_le_key_k_offset(KEY_FORMAT_3_5, &key,
-				    1 + inode->i_sb->s_blocksize);
+				    1 + inode_sb(inode)->s_blocksize);
 		set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_DIRECT);
 	} else {
 		/* truncate */
@@ -700,19 +701,19 @@ static void reiserfs_dirty_inode(struct inode *inode, int flags)
 
 	int err = 0;
 
-	if (sb_rdonly(inode->i_sb)) {
-		reiserfs_warning(inode->i_sb, "clm-6006",
+	if (sb_rdonly(inode_sb(inode))) {
+		reiserfs_warning(inode_sb(inode), "clm-6006",
 				 "writing inode %lu on readonly FS",
 				 inode->i_ino);
 		return;
 	}
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 
 	/*
 	 * this is really only used for atime updates, so they don't have
 	 * to be included in O_SYNC or fsync
 	 */
-	err = journal_begin(&th, inode->i_sb, 1);
+	err = journal_begin(&th, inode_sb(inode), 1);
 	if (err)
 		goto out;
 
@@ -720,7 +721,7 @@ static void reiserfs_dirty_inode(struct inode *inode, int flags)
 	journal_end(&th);
 
 out:
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 }
 
 static int reiserfs_show_options(struct seq_file *seq, struct dentry *root)
diff --git a/fs/reiserfs/tail_conversion.c b/fs/reiserfs/tail_conversion.c
index b0ae088dffc7..a6635188890a 100644
--- a/fs/reiserfs/tail_conversion.c
+++ b/fs/reiserfs/tail_conversion.c
@@ -26,7 +26,7 @@ int direct2indirect(struct reiserfs_transaction_handle *th, struct inode *inode,
 		    struct treepath *path, struct buffer_head *unbh,
 		    loff_t tail_offset)
 {
-	struct super_block *sb = inode->i_sb;
+	struct super_block *sb = inode_sb(inode);
 	struct buffer_head *up_to_date_bh;
 	struct item_head *p_le_ih = tp_item_head(path);
 	unsigned long total_tail = 0;
@@ -178,7 +178,7 @@ void reiserfs_unmap_buffer(struct buffer_head *bh)
 	 */
 	if ((!list_empty(&bh->b_assoc_buffers) || bh->b_private) && bh->b_page) {
 		struct inode *inode = bh->b_page->mapping->host;
-		struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
+		struct reiserfs_journal *j = SB_JOURNAL(inode_sb(inode));
 		spin_lock(&j->j_dirty_buffers_lock);
 		list_del_init(&bh->b_assoc_buffers);
 		reiserfs_free_jh(bh);
@@ -208,7 +208,7 @@ int indirect2direct(struct reiserfs_transaction_handle *th,
 		    loff_t n_new_file_size,	/* New file size. */
 		    char *mode)
 {
-	struct super_block *sb = inode->i_sb;
+	struct super_block *sb = inode_sb(inode);
 	struct item_head s_ih;
 	unsigned long block_size = sb->s_blocksize;
 	char *tail;
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 5dbf5324bdda..e73afd1703ef 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -149,7 +149,7 @@ static struct dentry *open_xa_dir(const struct inode *inode, int flags)
 	struct dentry *xaroot, *xadir;
 	char namebuf[17];
 
-	xaroot = open_xa_root(inode->i_sb, flags);
+	xaroot = open_xa_root(inode_sb(inode), flags);
 	if (IS_ERR(xaroot))
 		return xaroot;
 
@@ -290,21 +290,21 @@ static int reiserfs_for_each_xattr(struct inode *inode,
 		 * outer transaction.
 		 */
 		int blocks = JOURNAL_PER_BALANCE_CNT * 2 + 2 +
-			     4 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
+			     4 * REISERFS_QUOTA_TRANS_BLOCKS(inode_sb(inode));
 		struct reiserfs_transaction_handle th;
 
-		reiserfs_write_lock(inode->i_sb);
-		err = journal_begin(&th, inode->i_sb, blocks);
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_lock(inode_sb(inode));
+		err = journal_begin(&th, inode_sb(inode), blocks);
+		reiserfs_write_unlock(inode_sb(inode));
 		if (!err) {
 			int jerror;
 
 			inode_lock_nested(d_inode(dir->d_parent),
 					  I_MUTEX_XATTR);
 			err = action(dir, data);
-			reiserfs_write_lock(inode->i_sb);
+			reiserfs_write_lock(inode_sb(inode));
 			jerror = journal_end(&th);
-			reiserfs_write_unlock(inode->i_sb);
+			reiserfs_write_unlock(inode_sb(inode));
 			inode_unlock(d_inode(dir->d_parent));
 			err = jerror ?: err;
 		}
@@ -353,7 +353,7 @@ int reiserfs_delete_xattrs(struct inode *inode)
 	int err = reiserfs_for_each_xattr(inode, delete_one_xattr, NULL);
 
 	if (err)
-		reiserfs_warning(inode->i_sb, "jdm-20004",
+		reiserfs_warning(inode_sb(inode), "jdm-20004",
 				 "Couldn't delete all xattrs (%d)\n", err);
 	return err;
 }
@@ -364,7 +364,7 @@ int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
 	int err = reiserfs_for_each_xattr(inode, chown_one_xattr, attrs);
 
 	if (err)
-		reiserfs_warning(inode->i_sb, "jdm-20007",
+		reiserfs_warning(inode_sb(inode), "jdm-20007",
 				 "Couldn't chown all xattrs (%d)\n", err);
 	return err;
 }
@@ -554,7 +554,7 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
 			rxh->h_hash = cpu_to_le32(xahash);
 		}
 
-		reiserfs_write_lock(inode->i_sb);
+		reiserfs_write_lock(inode_sb(inode));
 		err = __reiserfs_write_begin(page, page_offset, chunk + skip);
 		if (!err) {
 			if (buffer)
@@ -563,7 +563,7 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
 						    page_offset + chunk +
 						    skip);
 		}
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 		unlock_page(page);
 		reiserfs_put_page(page);
 		buffer_pos += chunk;
@@ -606,9 +606,9 @@ int reiserfs_xattr_set(struct inode *inode, const char *name,
 	if (!(flags & XATTR_REPLACE))
 		jbegin_count += reiserfs_xattr_jcreate_nblocks(inode);
 
-	reiserfs_write_lock(inode->i_sb);
-	error = journal_begin(&th, inode->i_sb, jbegin_count);
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
+	error = journal_begin(&th, inode_sb(inode), jbegin_count);
+	reiserfs_write_unlock(inode_sb(inode));
 	if (error) {
 		return error;
 	}
@@ -616,9 +616,9 @@ int reiserfs_xattr_set(struct inode *inode, const char *name,
 	error = reiserfs_xattr_set_handle(&th, inode, name,
 					  buffer, buffer_size, flags);
 
-	reiserfs_write_lock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
 	error2 = journal_end(&th);
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_unlock(inode_sb(inode));
 	if (error == 0)
 		error = error2;
 
@@ -698,7 +698,7 @@ reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
 			if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) {
 				unlock_page(page);
 				reiserfs_put_page(page);
-				reiserfs_warning(inode->i_sb, "jdm-20001",
+				reiserfs_warning(inode_sb(inode), "jdm-20001",
 						 "Invalid magic for xattr (%s) "
 						 "associated with %k", name,
 						 INODE_PKEY(inode));
@@ -718,7 +718,7 @@ reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
 
 	if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) !=
 	    hash) {
-		reiserfs_warning(inode->i_sb, "jdm-20002",
+		reiserfs_warning(inode_sb(inode), "jdm-20002",
 				 "Invalid hash for xattr (%s) associated "
 				 "with %k", name, INODE_PKEY(inode));
 		err = -EIO;
diff --git a/fs/reiserfs/xattr.h b/fs/reiserfs/xattr.h
index c764352447ba..7b7c55d603a6 100644
--- a/fs/reiserfs/xattr.h
+++ b/fs/reiserfs/xattr.h
@@ -51,8 +51,9 @@ static inline loff_t reiserfs_xattr_nblocks(struct inode *inode, loff_t size)
 {
 	loff_t ret = 0;
 	if (reiserfs_file_data_log(inode)) {
-		ret = _ROUND_UP(xattr_size(size), inode->i_sb->s_blocksize);
-		ret >>= inode->i_sb->s_blocksize_bits;
+		ret = _ROUND_UP(xattr_size(size),
+				inode_sb(inode)->s_blocksize);
+		ret >>= inode_sb(inode)->s_blocksize_bits;
 	}
 	return ret;
 }
@@ -71,12 +72,12 @@ static inline loff_t reiserfs_xattr_nblocks(struct inode *inode, loff_t size)
  */
 static inline size_t reiserfs_xattr_jcreate_nblocks(struct inode *inode)
 {
-	size_t nblocks = JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
+	size_t nblocks = JOURNAL_BLOCKS_PER_OBJECT(inode_sb(inode));
 
 	if ((REISERFS_I(inode)->i_flags & i_has_xattr_dir) == 0) {
-		nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
-		if (d_really_is_negative(REISERFS_SB(inode->i_sb)->xattr_root))
-			nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
+		nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode_sb(inode));
+		if (d_really_is_negative(REISERFS_SB(inode_sb(inode))->xattr_root))
+			nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode_sb(inode));
 	}
 
 	return nblocks;
diff --git a/fs/reiserfs/xattr_acl.c b/fs/reiserfs/xattr_acl.c
index aa9380bac196..3bebe8b2064b 100644
--- a/fs/reiserfs/xattr_acl.c
+++ b/fs/reiserfs/xattr_acl.c
@@ -35,9 +35,9 @@ reiserfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
 	jcreate_blocks = reiserfs_xattr_jcreate_nblocks(inode) +
 			 reiserfs_xattr_nblocks(inode, size) * 2;
 
-	reiserfs_write_lock(inode->i_sb);
-	error = journal_begin(&th, inode->i_sb, jcreate_blocks);
-	reiserfs_write_unlock(inode->i_sb);
+	reiserfs_write_lock(inode_sb(inode));
+	error = journal_begin(&th, inode_sb(inode), jcreate_blocks);
+	reiserfs_write_unlock(inode_sb(inode));
 	if (error == 0) {
 		if (type == ACL_TYPE_ACCESS && acl) {
 			error = posix_acl_update_mode(inode, &mode, &acl);
@@ -49,9 +49,9 @@ reiserfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
 		if (!error && update_mode)
 			inode->i_mode = mode;
 unlock:
-		reiserfs_write_lock(inode->i_sb);
+		reiserfs_write_lock(inode_sb(inode));
 		error2 = journal_end(&th);
-		reiserfs_write_unlock(inode->i_sb);
+		reiserfs_write_unlock(inode_sb(inode));
 		if (error2)
 			error = error2;
 	}
@@ -378,7 +378,7 @@ int reiserfs_cache_default_acl(struct inode *inode)
 		 * we need to create the tree to the xattrs, and then we
 		 * just want two files. */
 		nblocks = reiserfs_xattr_jcreate_nblocks(inode);
-		nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
+		nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode_sb(inode));
 
 		REISERFS_I(inode)->i_flags |= i_has_xattr_dir;
 
@@ -398,7 +398,7 @@ int reiserfs_acl_chmod(struct inode *inode)
 	if (IS_PRIVATE(inode))
 		return 0;
 	if (get_inode_sd_version(inode) == STAT_DATA_V1 ||
-	    !reiserfs_posixacl(inode->i_sb))
+	    !reiserfs_posixacl(inode_sb(inode)))
 		return 0;
 
 	return posix_acl_chmod(inode, inode->i_mode);
diff --git a/fs/reiserfs/xattr_security.c b/fs/reiserfs/xattr_security.c
index 20be9a0e5870..c0a096637536 100644
--- a/fs/reiserfs/xattr_security.c
+++ b/fs/reiserfs/xattr_security.c
@@ -66,7 +66,7 @@ int reiserfs_security_init(struct inode *dir, struct inode *inode,
 		return error;
 	}
 
-	if (sec->length && reiserfs_xattrs_initialized(inode->i_sb)) {
+	if (sec->length && reiserfs_xattrs_initialized(inode_sb(inode))) {
 		blocks = reiserfs_xattr_jcreate_nblocks(inode) +
 			 reiserfs_xattr_nblocks(inode, sec->length);
 		/* We don't want to count the directories twice if we have
diff --git a/fs/reiserfs/xattr_user.c b/fs/reiserfs/xattr_user.c
index a573ca45bacc..baf8f21dd844 100644
--- a/fs/reiserfs/xattr_user.c
+++ b/fs/reiserfs/xattr_user.c
@@ -11,7 +11,7 @@ static int
 user_get(const struct xattr_handler *handler, struct dentry *unused,
 	 struct inode *inode, const char *name, void *buffer, size_t size)
 {
-	if (!reiserfs_xattrs_user(inode->i_sb))
+	if (!reiserfs_xattrs_user(inode_sb(inode)))
 		return -EOPNOTSUPP;
 	return reiserfs_xattr_get(inode, xattr_full_name(handler, name),
 				  buffer, size);
@@ -22,7 +22,7 @@ user_set(const struct xattr_handler *handler, struct dentry *unused,
 	 struct inode *inode, const char *name, const void *buffer,
 	 size_t size, int flags)
 {
-	if (!reiserfs_xattrs_user(inode->i_sb))
+	if (!reiserfs_xattrs_user(inode_sb(inode)))
 		return -EOPNOTSUPP;
 	return reiserfs_xattr_set(inode,
 				  xattr_full_name(handler, name),
-- 
2.15.1