diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index 3bc40ff5fdf9..d1954e2bb908 100644
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -98,10 +98,13 @@ struct gfs2_rgrpd {
 
 enum gfs2_state_bits {
 	BH_Pinned = BH_PrivateStart,
+	BH_Escaped = BH_PrivateStart + 1,
 };
 
 BUFFER_FNS(Pinned, pinned)
 TAS_BUFFER_FNS(Pinned, pinned)
+BUFFER_FNS(Escaped, escaped)
+TAS_BUFFER_FNS(Escaped, escaped)
 
 struct gfs2_bufdata {
 	struct buffer_head *bd_bh;
@@ -254,7 +257,7 @@ struct gfs2_inode {
 	struct inode *i_vnode;
 
 	struct gfs2_holder i_iopen_gh;
-
+	struct gfs2_holder i_gh; /* for prepare/commit_write only */
 	struct gfs2_alloc i_alloc;
 	uint64_t i_last_rg_alloc;
 
@@ -511,17 +514,17 @@ struct gfs2_sbd {
 
 	/* Inode Stuff */
 
-	struct gfs2_inode *sd_master_dir;
-	struct gfs2_inode *sd_jindex;
-	struct gfs2_inode *sd_inum_inode;
-	struct gfs2_inode *sd_statfs_inode;
-	struct gfs2_inode *sd_ir_inode;
-	struct gfs2_inode *sd_sc_inode;
-	struct gfs2_inode *sd_ut_inode;
-	struct gfs2_inode *sd_qc_inode;
-	struct gfs2_inode *sd_rindex;
-	struct gfs2_inode *sd_quota_inode;
-	struct gfs2_inode *sd_root_dir;
+	struct inode *sd_master_dir;
+	struct inode *sd_jindex;
+	struct inode *sd_inum_inode;
+	struct inode *sd_statfs_inode;
+	struct inode *sd_ir_inode;
+	struct inode *sd_sc_inode;
+	struct inode *sd_ut_inode;
+	struct inode *sd_qc_inode;
+	struct inode *sd_rindex;
+	struct inode *sd_quota_inode;
+	struct inode *sd_root_dir;
 
 	/* Inum stuff */
 
@@ -615,6 +618,8 @@ struct gfs2_sbd {
 	unsigned int sd_log_num_revoke;
 	unsigned int sd_log_num_rg;
 	unsigned int sd_log_num_databuf;
+	unsigned int sd_log_num_jdata;
+
 	struct list_head sd_log_le_gl;
 	struct list_head sd_log_le_buf;
 	struct list_head sd_log_le_revoke;
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index e4ba380b286a..4c193e38f8e4 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -725,7 +725,7 @@ int gfs2_lookupi(struct gfs2_inode *dip, struct qstr *name, int is_root,
 		return -ENAMETOOLONG;
 
 	if (gfs2_filecmp(name, ".", 1) ||
-	    (gfs2_filecmp(name, "..", 2) && dip == sdp->sd_root_dir)) {
+	    (gfs2_filecmp(name, "..", 2) && dip == get_v2ip(sdp->sd_root_dir))) {
 		gfs2_inode_hold(dip);
 		*ipp = dip;
 		return 0;
@@ -764,7 +764,7 @@ int gfs2_lookupi(struct gfs2_inode *dip, struct qstr *name, int is_root,
 
 static int pick_formal_ino_1(struct gfs2_sbd *sdp, uint64_t *formal_ino)
 {
-	struct gfs2_inode *ip = sdp->sd_ir_inode;
+	struct gfs2_inode *ip = get_v2ip(sdp->sd_ir_inode);
 	struct buffer_head *bh;
 	struct gfs2_inum_range ir;
 	int error;
@@ -805,8 +805,8 @@ static int pick_formal_ino_1(struct gfs2_sbd *sdp, uint64_t *formal_ino)
 
 static int pick_formal_ino_2(struct gfs2_sbd *sdp, uint64_t *formal_ino)
 {
-	struct gfs2_inode *ip = sdp->sd_ir_inode;
-	struct gfs2_inode *m_ip = sdp->sd_inum_inode;
+	struct gfs2_inode *ip = get_v2ip(sdp->sd_ir_inode);
+	struct gfs2_inode *m_ip = get_v2ip(sdp->sd_inum_inode);
 	struct gfs2_holder gh;
 	struct buffer_head *bh;
 	struct gfs2_inum_range ir;
@@ -1460,7 +1460,7 @@ int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
 			error = -EINVAL;
 			break;
 		}
-		if (to == sdp->sd_root_dir) {
+		if (to == get_v2ip(sdp->sd_root_dir)) {
 			error = 0;
 			break;
 		}
diff --git a/fs/gfs2/inode.h b/fs/gfs2/inode.h
index 4df7da51f715..e42ae38d6778 100644
--- a/fs/gfs2/inode.h
+++ b/fs/gfs2/inode.h
@@ -60,14 +60,23 @@ int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr);
 
 int gfs2_repermission(struct inode *inode, int mask, struct nameidata *nd);
 
-static inline int gfs2_lookup_simple(struct gfs2_inode *dip, char *name,
-				     struct gfs2_inode **ipp)
+static inline int gfs2_lookup_simple(struct inode *dip, char *name,
+				     struct inode **ipp)
 {
+	struct gfs2_inode *ip;
 	struct qstr qstr;
+	int err;
 	memset(&qstr, 0, sizeof(struct qstr));
 	qstr.name = name;
 	qstr.len = strlen(name);
-	return gfs2_lookupi(dip, &qstr, 1, ipp);
+	err = gfs2_lookupi(get_v2ip(dip), &qstr, 1, &ip);
+	if (err == 0) {
+		*ipp = gfs2_ip2v(ip);
+		if (*ipp == NULL)
+			err = -ENOMEM;
+		gfs2_inode_put(ip);
+	}
+	return err;
 }
 
 #endif /* __INODE_DOT_H__ */
diff --git a/fs/gfs2/jdata.c b/fs/gfs2/jdata.c
index 6caa93e46ce0..e43eaf133f10 100644
--- a/fs/gfs2/jdata.c
+++ b/fs/gfs2/jdata.c
@@ -22,6 +22,13 @@
 #include "meta_io.h"
 #include "trans.h"
 
+int gfs2_internal_read(struct gfs2_inode *ip,
+                       struct file_ra_state *ra_state,
+                       char *buf, loff_t *pos, unsigned size)
+{
+	return gfs2_jdata_read_mem(ip, buf, *pos, size);
+}
+
 int gfs2_jdata_get_buffer(struct gfs2_inode *ip, uint64_t block, int new,
 			  struct buffer_head **bhp)
 {
diff --git a/fs/gfs2/ops_export.c b/fs/gfs2/ops_export.c
index 0ae3a0af192d..335448d3be21 100644
--- a/fs/gfs2/ops_export.c
+++ b/fs/gfs2/ops_export.c
@@ -81,7 +81,7 @@ static int gfs2_encode_fh(struct dentry *dentry, __u32 *fh, int *len,
 	fh[3] = cpu_to_be32(fh[3]);
 	*len = 4;
 
-	if (!connectable || ip == sdp->sd_root_dir)
+	if (!connectable || ip == get_v2ip(sdp->sd_root_dir))
 		return *len;
 
 	spin_lock(&dentry->d_lock);
diff --git a/fs/gfs2/ops_file.h b/fs/gfs2/ops_file.h
index 95123d7bbcdf..3c237bfc143d 100644
--- a/fs/gfs2/ops_file.h
+++ b/fs/gfs2/ops_file.h
@@ -10,6 +10,10 @@
 #ifndef __OPS_FILE_DOT_H__
 #define __OPS_FILE_DOT_H__
 
+extern int gfs2_internal_read(struct gfs2_inode *ip,
+			      struct file_ra_state *ra_state,
+			      char *buf, loff_t *pos, unsigned size);
+
 extern struct file_operations gfs2_file_fops;
 extern struct file_operations gfs2_dir_fops;
 
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index c61a80c439a6..139cef8fff3a 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -275,14 +275,38 @@ static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
 	return error;
 }
 
+int gfs2_lookup_root(struct gfs2_sbd *sdp)
+{
+        int error;
+	struct gfs2_glock *gl;
+	struct gfs2_inode *ip;
+
+	error = gfs2_glock_get(sdp, sdp->sd_sb.sb_root_dir.no_addr,
+                               &gfs2_inode_glops, CREATE, &gl);
+        if (!error) {
+               	error = gfs2_inode_get(gl, &sdp->sd_sb.sb_root_dir,
+				       CREATE, &ip);
+		if (!error) {
+			if (!error) 
+				gfs2_inode_min_init(ip, DT_DIR);
+			sdp->sd_root_dir = gfs2_ip2v(ip);
+			gfs2_inode_put(ip);
+		}
+                gfs2_glock_put(gl);
+        }
+
+        return error;
+}
+
 static int init_sb(struct gfs2_sbd *sdp, int silent, int undo)
 {
 	struct super_block *sb = sdp->sd_vfs;
 	struct gfs2_holder sb_gh;
+	struct inode *inode;
 	int error = 0;
 
 	if (undo) {
-		gfs2_inode_put(sdp->sd_master_dir);
+		iput(sdp->sd_master_dir);
 		return 0;
 	}
 	
@@ -321,14 +345,35 @@ static int init_sb(struct gfs2_sbd *sdp, int silent, int undo)
 
 	sb_set_blocksize(sb, sdp->sd_sb.sb_bsize);
 
-	error = gfs2_lookup_master_dir(sdp);
-	if (error)
-		fs_err(sdp, "can't read in master directory: %d\n", error);
+	/* Get the root inode */
+	error = gfs2_lookup_root(sdp);
+	if (error) {
+		fs_err(sdp, "can't read in root inode: %d\n", error);
+		goto out;
+	}
 
- out:
+	/* Get the root inode/dentry */
+	inode = sdp->sd_root_dir;
+	if (!inode) {
+		fs_err(sdp, "can't get root inode\n");
+		error = -ENOMEM;
+		goto out_rooti;
+	}
+
+	sb->s_root = d_alloc_root(inode);
+	if (!sb->s_root) {
+		fs_err(sdp, "can't get root dentry\n");
+		error = -ENOMEM;
+		goto out_rooti;
+	}
+
+out:
 	gfs2_glock_dq_uninit(&sb_gh);
 
 	return error;
+out_rooti:
+	iput(sdp->sd_root_dir);
+	goto out;
 }
 
 static int init_journal(struct gfs2_sbd *sdp, int undo)
@@ -349,7 +394,7 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
 		fs_err(sdp, "can't lookup journal index: %d\n", error);
 		return error;
 	}
-	set_bit(GLF_STICKY, &sdp->sd_jindex->i_gl->gl_flags);
+	set_bit(GLF_STICKY, &get_v2ip(sdp->sd_jindex)->i_gl->gl_flags);
 
 	/* Load in the journal index special file */
 
@@ -465,53 +510,44 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
 		gfs2_glock_dq_uninit(&ji_gh);
 
  fail:
-	gfs2_inode_put(sdp->sd_jindex);
+	iput(sdp->sd_jindex);
 
 	return error;
 }
 
-int gfs2_lookup_root(struct gfs2_sbd *sdp)
-{
-        int error;
-	struct gfs2_glock *gl;
-
-	error = gfs2_glock_get(sdp, sdp->sd_sb.sb_root_dir.no_addr,
-                               &gfs2_inode_glops, CREATE, &gl);
-        if (!error) {
-               	error = gfs2_inode_get(gl, &sdp->sd_sb.sb_root_dir,
-						CREATE, &sdp->sd_root_dir);
-		if (!error)
-			gfs2_inode_min_init(sdp->sd_root_dir, DT_DIR);
-                gfs2_glock_put(gl);
-        }
-
-        return error;
-}
-
 
 static int init_inodes(struct gfs2_sbd *sdp, int undo)
 {
-	struct inode *inode;
-	struct dentry **dentry = &sdp->sd_vfs->s_root;
 	int error = 0;
 
 	if (undo)
-		goto fail_dput;
+		goto fail_qinode;
+
+	error = gfs2_lookup_master_dir(sdp);
+	if (error) {
+		fs_err(sdp, "can't read in master directory: %d\n", error);
+		goto fail;
+	}
+
+	error = init_journal(sdp, undo);
+	if (error)
+		goto fail_master;
 
 	/* Read in the master inode number inode */
 	error = gfs2_lookup_simple(sdp->sd_master_dir, "inum",
 				   &sdp->sd_inum_inode);
 	if (error) {
 		fs_err(sdp, "can't read in inum inode: %d\n", error);
-		return error;
+		goto fail_journal;
 	}
 
+
 	/* Read in the master statfs inode */
 	error = gfs2_lookup_simple(sdp->sd_master_dir, "statfs",
 				   &sdp->sd_statfs_inode);
 	if (error) {
 		fs_err(sdp, "can't read in statfs inode: %d\n", error);
-		goto fail;
+		goto fail_inum;
 	}
 
 	/* Read in the resource index inode */
@@ -521,8 +557,8 @@ static int init_inodes(struct gfs2_sbd *sdp, int undo)
 		fs_err(sdp, "can't get resource index inode: %d\n", error);
 		goto fail_statfs;
 	}
-	set_bit(GLF_STICKY, &sdp->sd_rindex->i_gl->gl_flags);
-	sdp->sd_rindex_vn = sdp->sd_rindex->i_gl->gl_vn - 1;
+	set_bit(GLF_STICKY, &get_v2ip(sdp->sd_rindex)->i_gl->gl_flags);
+	sdp->sd_rindex_vn = get_v2ip(sdp->sd_rindex)->i_gl->gl_vn - 1;
 
 	/* Read in the quota inode */
 	error = gfs2_lookup_simple(sdp->sd_master_dir, "quota",
@@ -531,58 +567,31 @@ static int init_inodes(struct gfs2_sbd *sdp, int undo)
 		fs_err(sdp, "can't get quota file inode: %d\n", error);
 		goto fail_rindex;
 	}
-
-	/* Get the root inode */
-	error = gfs2_lookup_root(sdp);
-	if (error) {
-		fs_err(sdp, "can't read in root inode: %d\n", error);
-		goto fail_qinode;
-	}
-
-	/* Get the root inode/dentry */
-	inode = gfs2_ip2v(sdp->sd_root_dir);
-	if (!inode) {
-		fs_err(sdp, "can't get root inode\n");
-		error = -ENOMEM;
-		goto fail_rooti;
-	}
-
-	*dentry = d_alloc_root(inode);
-	if (!*dentry) {
-		iput(inode);
-		fs_err(sdp, "can't get root dentry\n");
-		error = -ENOMEM;
-		goto fail_rooti;
-	}
-
 	return 0;
 
- fail_dput:
-	dput(*dentry);
-	*dentry = NULL;
+fail_qinode:
+	iput(sdp->sd_quota_inode);
 
- fail_rooti:
-	gfs2_inode_put(sdp->sd_root_dir);
-
- fail_qinode:
-	gfs2_inode_put(sdp->sd_quota_inode);
-
- fail_rindex:
+fail_rindex:
 	gfs2_clear_rgrpd(sdp);
-	gfs2_inode_put(sdp->sd_rindex);
+	iput(sdp->sd_rindex);
 
- fail_statfs:
-	gfs2_inode_put(sdp->sd_statfs_inode);
-
- fail:
-	gfs2_inode_put(sdp->sd_inum_inode);
+fail_statfs:
+	iput(sdp->sd_statfs_inode);
 
+fail_inum:
+	iput(sdp->sd_inum_inode);
+fail_journal:
+	init_journal(sdp, UNDO);
+fail_master:
+	iput(sdp->sd_master_dir);
+fail:
 	return error;
 }
 
 static int init_per_node(struct gfs2_sbd *sdp, int undo)
 {
-	struct gfs2_inode *pn = NULL;
+	struct inode *pn = NULL;
 	char buf[30];
 	int error = 0;
 
@@ -626,10 +635,10 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
 		goto fail_ut_i;
 	}
 
-	gfs2_inode_put(pn);
+	iput(pn);
 	pn = NULL;
 
-	error = gfs2_glock_nq_init(sdp->sd_ir_inode->i_gl,
+	error = gfs2_glock_nq_init(get_v2ip(sdp->sd_ir_inode)->i_gl,
 				   LM_ST_EXCLUSIVE, GL_NEVER_RECURSE,
 				   &sdp->sd_ir_gh);
 	if (error) {
@@ -637,7 +646,7 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
 		goto fail_qc_i;
 	}
 
-	error = gfs2_glock_nq_init(sdp->sd_sc_inode->i_gl,
+	error = gfs2_glock_nq_init(get_v2ip(sdp->sd_sc_inode)->i_gl,
 				   LM_ST_EXCLUSIVE, GL_NEVER_RECURSE,
 				   &sdp->sd_sc_gh);
 	if (error) {
@@ -645,7 +654,7 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
 		goto fail_ir_gh;
 	}
 
-	error = gfs2_glock_nq_init(sdp->sd_ut_inode->i_gl,
+	error = gfs2_glock_nq_init(get_v2ip(sdp->sd_ut_inode)->i_gl,
 				   LM_ST_EXCLUSIVE, GL_NEVER_RECURSE,
 				   &sdp->sd_ut_gh);
 	if (error) {
@@ -653,7 +662,7 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
 		goto fail_sc_gh;
 	}
 
-	error = gfs2_glock_nq_init(sdp->sd_qc_inode->i_gl,
+	error = gfs2_glock_nq_init(get_v2ip(sdp->sd_qc_inode)->i_gl,
 				   LM_ST_EXCLUSIVE, GL_NEVER_RECURSE,
 				   &sdp->sd_qc_gh);
 	if (error) {
@@ -676,20 +685,20 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
 	gfs2_glock_dq_uninit(&sdp->sd_ir_gh);
 
  fail_qc_i:
-	gfs2_inode_put(sdp->sd_qc_inode);
+	iput(sdp->sd_qc_inode);
 
  fail_ut_i:
-	gfs2_inode_put(sdp->sd_ut_inode);
+	iput(sdp->sd_ut_inode);
 
  fail_sc_i:
-	gfs2_inode_put(sdp->sd_sc_inode);
+	iput(sdp->sd_sc_inode);
 
  fail_ir_i:
-	gfs2_inode_put(sdp->sd_ir_inode);
+	iput(sdp->sd_ir_inode);
 
  fail:
 	if (pn)
-		gfs2_inode_put(pn);
+		iput(pn);
 	return error;
 }
 
@@ -793,14 +802,10 @@ static int fill_super(struct super_block *sb, void *data, int silent)
 	error = init_sb(sdp, silent, DO);
 	if (error)
 		goto fail_locking;
-	
-	error = init_journal(sdp, DO);
-	if (error)
-		goto fail_sb;
 
 	error = init_inodes(sdp, DO);
 	if (error)
-		goto fail_journals;
+		goto fail_sb;
 
 	error = init_per_node(sdp, DO);
 	if (error)
@@ -837,9 +842,6 @@ static int fill_super(struct super_block *sb, void *data, int silent)
  fail_inodes:
 	init_inodes(sdp, UNDO);
 
- fail_journals:
-	init_journal(sdp, UNDO);
-
  fail_sb:
 	init_sb(sdp, 0, UNDO);
 
diff --git a/fs/gfs2/ops_super.c b/fs/gfs2/ops_super.c
index ca6a4d81bc26..e06ef8dbd4d3 100644
--- a/fs/gfs2/ops_super.c
+++ b/fs/gfs2/ops_super.c
@@ -97,13 +97,13 @@ static void gfs2_put_super(struct super_block *sb)
 
 	/*  Release stuff  */
 
-	gfs2_inode_put(sdp->sd_master_dir);
-	gfs2_inode_put(sdp->sd_jindex);
-	gfs2_inode_put(sdp->sd_inum_inode);
-	gfs2_inode_put(sdp->sd_statfs_inode);
-	gfs2_inode_put(sdp->sd_rindex);
-	gfs2_inode_put(sdp->sd_quota_inode);
-	gfs2_inode_put(sdp->sd_root_dir);
+	iput(sdp->sd_master_dir);
+	iput(sdp->sd_jindex);
+	iput(sdp->sd_inum_inode);
+	iput(sdp->sd_statfs_inode);
+	iput(sdp->sd_rindex);
+	iput(sdp->sd_quota_inode);
+	iput(sdp->sd_root_dir);
 
 	gfs2_glock_put(sdp->sd_rename_gl);
 	gfs2_glock_put(sdp->sd_trans_gl);
@@ -115,10 +115,10 @@ static void gfs2_put_super(struct super_block *sb)
 		gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
 		gfs2_glock_dq_uninit(&sdp->sd_ut_gh);
 		gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
-		gfs2_inode_put(sdp->sd_ir_inode);
-		gfs2_inode_put(sdp->sd_sc_inode);
-		gfs2_inode_put(sdp->sd_ut_inode);
-		gfs2_inode_put(sdp->sd_qc_inode);
+		iput(sdp->sd_ir_inode);
+		iput(sdp->sd_sc_inode);
+		iput(sdp->sd_ut_inode);
+		iput(sdp->sd_qc_inode);
 	}
 
 	gfs2_glock_dq_uninit(&sdp->sd_live_gh);
diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index 5fb5a5305e0e..69e8f4e92e57 100644
--- a/fs/gfs2/quota.c
+++ b/fs/gfs2/quota.c
@@ -56,6 +56,7 @@
 #include "rgrp.h"
 #include "super.h"
 #include "trans.h"
+#include "ops_file.h"
 
 #define QUOTA_USER 1
 #define QUOTA_GROUP 0
@@ -241,7 +242,7 @@ static void slot_put(struct gfs2_quota_data *qd)
 static int bh_get(struct gfs2_quota_data *qd)
 {
 	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
-	struct gfs2_inode *ip = sdp->sd_qc_inode;
+	struct gfs2_inode *ip = get_v2ip(sdp->sd_qc_inode);
 	unsigned int block, offset;
 	uint64_t dblock;
 	int new = 0;
@@ -522,7 +523,7 @@ static int sort_qd(const void *a, const void *b)
 static void do_qc(struct gfs2_quota_data *qd, int64_t change)
 {
 	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
-	struct gfs2_inode *ip = sdp->sd_qc_inode;
+	struct gfs2_inode *ip = get_v2ip(sdp->sd_qc_inode);
 	struct gfs2_quota_change *qc = qd->qd_bh_qc;
 	int64_t x;
 
@@ -563,12 +564,13 @@ static void do_qc(struct gfs2_quota_data *qd, int64_t change)
 static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
 {
 	struct gfs2_sbd *sdp = (*qda)->qd_gl->gl_sbd;
-	struct gfs2_inode *ip = sdp->sd_quota_inode;
+	struct gfs2_inode *ip = get_v2ip(sdp->sd_quota_inode);
 	unsigned int data_blocks, ind_blocks;
+	struct file_ra_state ra_state;
 	struct gfs2_holder *ghs, i_gh;
 	unsigned int qx, x;
 	struct gfs2_quota_data *qd;
-	uint64_t offset;
+	loff_t offset;
 	unsigned int nalloc = 0;
 	struct gfs2_alloc *al = NULL;
 	int error;
@@ -631,6 +633,7 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
 			goto out_gunlock;
 	}
 
+	file_ra_state_init(&ra_state, ip->i_vnode->i_mapping);
 	for (x = 0; x < num_qd; x++) {
 		char buf[sizeof(struct gfs2_quota)];
 		struct gfs2_quota q;
@@ -642,7 +645,7 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
 		   sizeof(struct gfs2_quota) bytes. */
 		memset(buf, 0, sizeof(struct gfs2_quota));
 
-		error = gfs2_jdata_read_mem(ip, buf, offset,
+		error = gfs2_internal_read(ip, &ra_state, buf, &offset,
 					    sizeof(struct gfs2_quota));
 		if (error < 0)
 			goto out_end_trans;
@@ -703,8 +706,10 @@ static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
 	struct gfs2_holder i_gh;
 	struct gfs2_quota q;
 	char buf[sizeof(struct gfs2_quota)];
+	struct file_ra_state ra_state;
 	int error;
 
+	file_ra_state_init(&ra_state, sdp->sd_quota_inode->i_mapping);
  restart:
 	error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_SHARED, 0, q_gh);
 	if (error)
@@ -713,6 +718,7 @@ static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
 	gfs2_quota_lvb_in(&qd->qd_qb, qd->qd_gl->gl_lvb);
 
 	if (force_refresh || qd->qd_qb.qb_magic != GFS2_MAGIC) {
+		loff_t pos;
 		gfs2_glock_dq_uninit(q_gh);
 		error = gfs2_glock_nq_init(qd->qd_gl,
 					  LM_ST_EXCLUSIVE, GL_NOCACHE,
@@ -720,16 +726,17 @@ static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
 		if (error)
 			return error;
 
-		error = gfs2_glock_nq_init(sdp->sd_quota_inode->i_gl,
+		error = gfs2_glock_nq_init(get_v2ip(sdp->sd_quota_inode)->i_gl,
 					  LM_ST_SHARED, 0,
 					  &i_gh);
 		if (error)
 			goto fail;
 
 		memset(buf, 0, sizeof(struct gfs2_quota));
-
-		error = gfs2_jdata_read_mem(sdp->sd_quota_inode, buf,
-					    qd2offset(qd),
+		pos = qd2offset(qd);
+		error = gfs2_internal_read(get_v2ip(sdp->sd_quota_inode),
+					    &ra_state, buf,
+					    &pos,
 					    sizeof(struct gfs2_quota));
 		if (error < 0)
 			goto fail_gunlock;
@@ -1059,7 +1066,7 @@ int gfs2_quota_read(struct gfs2_sbd *sdp, int user, uint32_t id,
 
 int gfs2_quota_init(struct gfs2_sbd *sdp)
 {
-	struct gfs2_inode *ip = sdp->sd_qc_inode;
+	struct gfs2_inode *ip = get_v2ip(sdp->sd_qc_inode);
 	unsigned int blocks = ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift;
 	unsigned int x, slot = 0;
 	unsigned int found = 0;
diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index 87c80bbce1cf..758cc565813a 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -12,19 +12,20 @@
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
+#include <linux/fs.h>
 #include <asm/semaphore.h>
 
 #include "gfs2.h"
 #include "bits.h"
 #include "glock.h"
 #include "glops.h"
-#include "jdata.h"
 #include "lops.h"
 #include "meta_io.h"
 #include "quota.h"
 #include "rgrp.h"
 #include "super.h"
 #include "trans.h"
+#include "ops_file.h"
 
 /**
  * gfs2_rgrp_verify - Verify that a resource group is consistent
@@ -268,8 +269,10 @@ static int compute_bitstructs(struct gfs2_rgrpd *rgd)
 static int gfs2_ri_update(struct gfs2_inode *ip)
 {
 	struct gfs2_sbd *sdp = ip->i_sbd;
+	struct inode *inode = ip->i_vnode;
 	struct gfs2_rgrpd *rgd;
 	char buf[sizeof(struct gfs2_rindex)];
+	struct file_ra_state ra_state;
 	uint64_t junk = ip->i_di.di_size;
 	int error;
 
@@ -280,10 +283,10 @@ static int gfs2_ri_update(struct gfs2_inode *ip)
 
 	clear_rgrpdi(sdp);
 
+	file_ra_state_init(&ra_state, inode->i_mapping);
 	for (sdp->sd_rgrps = 0;; sdp->sd_rgrps++) {
-		error = gfs2_jdata_read_mem(ip, buf,
-					    sdp->sd_rgrps *
-					    sizeof(struct gfs2_rindex),
+		loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
+		error = gfs2_internal_read(ip, &ra_state, buf, &pos,
 					    sizeof(struct gfs2_rindex));
 		if (!error)
 			break;
@@ -350,7 +353,7 @@ static int gfs2_ri_update(struct gfs2_inode *ip)
 
 int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh)
 {
-	struct gfs2_inode *ip = sdp->sd_rindex;
+	struct gfs2_inode *ip = get_v2ip(sdp->sd_rindex);
 	struct gfs2_glock *gl = ip->i_gl;
 	int error;
 
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index cab7ab5fb506..bae32ba0c481 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -271,7 +271,7 @@ int gfs2_do_upgrade(struct gfs2_sbd *sdp, struct gfs2_glock *sb_gl)
 
 int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
 {
-	struct gfs2_inode *dip = sdp->sd_jindex;
+	struct gfs2_inode *dip = get_v2ip(sdp->sd_jindex);
 	struct qstr name;
 	char buf[20];
 	struct gfs2_jdesc *jd;
@@ -289,7 +289,7 @@ int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
 
 		name.len = sprintf(buf, "journal%u", sdp->sd_journals);
 
-		error = gfs2_dir_search(sdp->sd_jindex, &name, NULL, NULL);
+		error = gfs2_dir_search(get_v2ip(sdp->sd_jindex), &name, NULL, NULL);
 		if (error == -ENOENT) {
 			error = 0;
 			break;
@@ -437,6 +437,7 @@ int gfs2_jdesc_check(struct gfs2_jdesc *jd)
 
 int gfs2_lookup_master_dir(struct gfs2_sbd *sdp)
 {
+	struct inode *inode = NULL;
 	struct gfs2_glock *gl;
 	int error;
 
@@ -444,8 +445,8 @@ int gfs2_lookup_master_dir(struct gfs2_sbd *sdp)
 			       sdp->sd_sb.sb_master_dir.no_addr,
 			       &gfs2_inode_glops, CREATE, &gl);
 	if (!error) {
-		error = gfs2_inode_get(gl, &sdp->sd_sb.sb_master_dir, CREATE,
-				       &sdp->sd_master_dir);
+		error = gfs2_lookup_simple(sdp->sd_root_dir, ".gfs2_admin", &inode);
+		sdp->sd_master_dir = inode;
 		gfs2_glock_put(gl);
 	}
 
@@ -549,9 +550,9 @@ int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
 
 int gfs2_statfs_init(struct gfs2_sbd *sdp)
 {
-	struct gfs2_inode *m_ip = sdp->sd_statfs_inode;
+	struct gfs2_inode *m_ip = get_v2ip(sdp->sd_statfs_inode);
 	struct gfs2_statfs_change *m_sc = &sdp->sd_statfs_master;
-	struct gfs2_inode *l_ip = sdp->sd_sc_inode;
+	struct gfs2_inode *l_ip = get_v2ip(sdp->sd_sc_inode);
 	struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
 	struct buffer_head *m_bh, *l_bh;
 	struct gfs2_holder gh;
@@ -598,7 +599,7 @@ int gfs2_statfs_init(struct gfs2_sbd *sdp)
 void gfs2_statfs_change(struct gfs2_sbd *sdp, int64_t total, int64_t free,
 			int64_t dinodes)
 {
-	struct gfs2_inode *l_ip = sdp->sd_sc_inode;
+	struct gfs2_inode *l_ip = get_v2ip(sdp->sd_sc_inode);
 	struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
 	struct buffer_head *l_bh;
 	int error;
@@ -624,8 +625,8 @@ void gfs2_statfs_change(struct gfs2_sbd *sdp, int64_t total, int64_t free,
 
 int gfs2_statfs_sync(struct gfs2_sbd *sdp)
 {
-	struct gfs2_inode *m_ip = sdp->sd_statfs_inode;
-	struct gfs2_inode *l_ip = sdp->sd_sc_inode;
+	struct gfs2_inode *m_ip = get_v2ip(sdp->sd_statfs_inode);
+	struct gfs2_inode *l_ip = get_v2ip(sdp->sd_sc_inode);
 	struct gfs2_statfs_change *m_sc = &sdp->sd_statfs_master;
 	struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
 	struct gfs2_holder gh;
diff --git a/fs/gfs2/unlinked.c b/fs/gfs2/unlinked.c
index b8d836e3a5c0..405b91b0295d 100644
--- a/fs/gfs2/unlinked.c
+++ b/fs/gfs2/unlinked.c
@@ -25,7 +25,7 @@
 static int munge_ondisk(struct gfs2_sbd *sdp, unsigned int slot,
 			struct gfs2_unlinked_tag *ut)
 {
-	struct gfs2_inode *ip = sdp->sd_ut_inode;
+	struct gfs2_inode *ip = get_v2ip(sdp->sd_ut_inode);
 	unsigned int block, offset;
 	uint64_t dblock;
 	int new = 0;
@@ -312,7 +312,7 @@ int gfs2_unlinked_dealloc(struct gfs2_sbd *sdp)
 
 int gfs2_unlinked_init(struct gfs2_sbd *sdp)
 {
-	struct gfs2_inode *ip = sdp->sd_ut_inode;
+	struct gfs2_inode *ip = get_v2ip(sdp->sd_ut_inode);
 	unsigned int blocks = ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift;
 	unsigned int x, slot = 0;
 	unsigned int found = 0;