[ipfire-2.x.git] / src / patches / suse-2.6.27.39 / patches.suse / ocfs2-Make-high-level-btree-extend-co.patch

From: Tao Ma <tao.ma@oracle.com>
Subject: [PATCH 04/16] ocfs2: Make high level btree extend code generic
Patch-mainline: 2.6.28?
References: FATE302067 

Factor out the non-inode specifics of ocfs2_do_extend_allocation() into a more generic
function, ocfs2_do_cluster_allocation(). ocfs2_do_extend_allocation calls
ocfs2_do_cluster_allocation() now, but the latter can be used for other
btree types as well.

Signed-off-by: Tao Ma <tao.ma@oracle.com>
Signed-off-by: Mark Fasheh <mfasheh@suse.com>
---
 fs/ocfs2/alloc.c |  110 ++++++++++++++++++++++++++++++++++++++++++++
 fs/ocfs2/alloc.h |   17 ++++++
 fs/ocfs2/aops.c  |    8 +--
 fs/ocfs2/dir.c   |    6 +-
 fs/ocfs2/file.c  |  136 ++++++++++---------------------------------------------
 fs/ocfs2/file.h  |   26 ++++------
 fs/ocfs2/namei.c |    8 +--
 7 files changed, 176 insertions(+), 135 deletions(-)

--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -4302,6 +4302,116 @@ bail:
 	return status;
 }
 
+/*
+ * Allcate and add clusters into the extent b-tree.
+ * The new clusters(clusters_to_add) will be inserted at logical_offset.
+ * The extent b-tree's root is root_el and it should be in root_bh, and
+ * it is not limited to the file storage. Any extent tree can use this
+ * function if it implements the proper ocfs2_extent_tree.
+ */
+int ocfs2_add_clusters_in_btree(struct ocfs2_super *osb,
+				struct inode *inode,
+				u32 *logical_offset,
+				u32 clusters_to_add,
+				int mark_unwritten,
+				struct buffer_head *root_bh,
+				struct ocfs2_extent_list *root_el,
+				handle_t *handle,
+				struct ocfs2_alloc_context *data_ac,
+				struct ocfs2_alloc_context *meta_ac,
+				enum ocfs2_alloc_restarted *reason_ret,
+				enum ocfs2_extent_tree_type type)
+{
+	int status = 0;
+	int free_extents;
+	enum ocfs2_alloc_restarted reason = RESTART_NONE;
+	u32 bit_off, num_bits;
+	u64 block;
+	u8 flags = 0;
+
+	BUG_ON(!clusters_to_add);
+
+	if (mark_unwritten)
+		flags = OCFS2_EXT_UNWRITTEN;
+
+	free_extents = ocfs2_num_free_extents(osb, inode, root_bh, type);
+	if (free_extents < 0) {
+		status = free_extents;
+		mlog_errno(status);
+		goto leave;
+	}
+
+	/* there are two cases which could cause us to EAGAIN in the
+	 * we-need-more-metadata case:
+	 * 1) we haven't reserved *any*
+	 * 2) we are so fragmented, we've needed to add metadata too
+	 *    many times. */
+	if (!free_extents && !meta_ac) {
+		mlog(0, "we haven't reserved any metadata!\n");
+		status = -EAGAIN;
+		reason = RESTART_META;
+		goto leave;
+	} else if ((!free_extents)
+		   && (ocfs2_alloc_context_bits_left(meta_ac)
+		       < ocfs2_extend_meta_needed(root_el))) {
+		mlog(0, "filesystem is really fragmented...\n");
+		status = -EAGAIN;
+		reason = RESTART_META;
+		goto leave;
+	}
+
+	status = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
+					clusters_to_add, &bit_off, &num_bits);
+	if (status < 0) {
+		if (status != -ENOSPC)
+			mlog_errno(status);
+		goto leave;
+	}
+
+	BUG_ON(num_bits > clusters_to_add);
+
+	/* reserve our write early -- insert_extent may update the inode */
+	status = ocfs2_journal_access(handle, inode, root_bh,
+				      OCFS2_JOURNAL_ACCESS_WRITE);
+	if (status < 0) {
+		mlog_errno(status);
+		goto leave;
+	}
+
+	block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
+	mlog(0, "Allocating %u clusters at block %u for inode %llu\n",
+	     num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
+	status = ocfs2_insert_extent(osb, handle, inode, root_bh,
+				     *logical_offset, block, num_bits,
+				     flags, meta_ac, type);
+	if (status < 0) {
+		mlog_errno(status);
+		goto leave;
+	}
+
+	status = ocfs2_journal_dirty(handle, root_bh);
+	if (status < 0) {
+		mlog_errno(status);
+		goto leave;
+	}
+
+	clusters_to_add -= num_bits;
+	*logical_offset += num_bits;
+
+	if (clusters_to_add) {
+		mlog(0, "need to alloc once more, wanted = %u\n",
+		     clusters_to_add);
+		status = -EAGAIN;
+		reason = RESTART_TRANS;
+	}
+
+leave:
+	mlog_exit(status);
+	if (reason_ret)
+		*reason_ret = reason;
+	return status;
+}
+
 static void ocfs2_make_right_split_rec(struct super_block *sb,
 				       struct ocfs2_extent_rec *split_rec,
 				       u32 cpos,
--- a/fs/ocfs2/alloc.h
+++ b/fs/ocfs2/alloc.h
@@ -41,6 +41,23 @@ int ocfs2_insert_extent(struct ocfs2_sup
 			u8 flags,
 			struct ocfs2_alloc_context *meta_ac,
 			enum ocfs2_extent_tree_type et_type);
+enum ocfs2_alloc_restarted {
+	RESTART_NONE = 0,
+	RESTART_TRANS,
+	RESTART_META
+};
+int ocfs2_add_clusters_in_btree(struct ocfs2_super *osb,
+				struct inode *inode,
+				u32 *logical_offset,
+				u32 clusters_to_add,
+				int mark_unwritten,
+				struct buffer_head *root_bh,
+				struct ocfs2_extent_list *root_el,
+				handle_t *handle,
+				struct ocfs2_alloc_context *data_ac,
+				struct ocfs2_alloc_context *meta_ac,
+				enum ocfs2_alloc_restarted *reason_ret,
+				enum ocfs2_extent_tree_type type);
 struct ocfs2_cached_dealloc_ctxt;
 int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *root_bh,
 			      handle_t *handle, u32 cpos, u32 len, u32 phys,
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -1255,10 +1255,10 @@ static int ocfs2_write_cluster(struct ad
 		 * any additional semaphores or cluster locks.
 		 */
 		tmp_pos = cpos;
-		ret = ocfs2_do_extend_allocation(OCFS2_SB(inode->i_sb), inode,
-						 &tmp_pos, 1, 0, wc->w_di_bh,
-						 wc->w_handle, data_ac,
-						 meta_ac, NULL);
+		ret = ocfs2_add_inode_data(OCFS2_SB(inode->i_sb), inode,
+					   &tmp_pos, 1, 0, wc->w_di_bh,
+					   wc->w_handle, data_ac,
+					   meta_ac, NULL);
 		/*
 		 * This shouldn't happen because we must have already
 		 * calculated the correct meta data allocation required. The
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -1383,9 +1383,9 @@ static int ocfs2_do_extend_dir(struct su
 	if (extend) {
 		u32 offset = OCFS2_I(dir)->ip_clusters;
 
-		status = ocfs2_do_extend_allocation(OCFS2_SB(sb), dir, &offset,
-						    1, 0, parent_fe_bh, handle,
-						    data_ac, meta_ac, NULL);
+		status = ocfs2_add_inode_data(OCFS2_SB(sb), dir, &offset,
+					      1, 0, parent_fe_bh, handle,
+					      data_ac, meta_ac, NULL);
 		BUG_ON(status == -EAGAIN);
 		if (status < 0) {
 			mlog_errno(status);
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -488,7 +488,7 @@ bail:
 }
 
 /*
- * extend allocation only here.
+ * extend file allocation only here.
  * we'll update all the disk stuff, and oip->alloc_size
  *
  * expect stuff to be locked, a transaction started and enough data /
@@ -497,107 +497,25 @@ bail:
  * Will return -EAGAIN, and a reason if a restart is needed.
  * If passed in, *reason will always be set, even in error.
  */
-int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
-			       struct inode *inode,
-			       u32 *logical_offset,
-			       u32 clusters_to_add,
-			       int mark_unwritten,
-			       struct buffer_head *fe_bh,
-			       handle_t *handle,
-			       struct ocfs2_alloc_context *data_ac,
-			       struct ocfs2_alloc_context *meta_ac,
-			       enum ocfs2_alloc_restarted *reason_ret)
+int ocfs2_add_inode_data(struct ocfs2_super *osb,
+			 struct inode *inode,
+			 u32 *logical_offset,
+			 u32 clusters_to_add,
+			 int mark_unwritten,
+			 struct buffer_head *fe_bh,
+			 handle_t *handle,
+			 struct ocfs2_alloc_context *data_ac,
+			 struct ocfs2_alloc_context *meta_ac,
+			 enum ocfs2_alloc_restarted *reason_ret)
 {
-	int status = 0;
-	int free_extents;
 	struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
-	enum ocfs2_alloc_restarted reason = RESTART_NONE;
-	u32 bit_off, num_bits;
-	u64 block;
-	u8 flags = 0;
-
-	BUG_ON(!clusters_to_add);
-
-	if (mark_unwritten)
-		flags = OCFS2_EXT_UNWRITTEN;
-
-	free_extents = ocfs2_num_free_extents(osb, inode, fe_bh,
-					      OCFS2_DINODE_EXTENT);
-	if (free_extents < 0) {
-		status = free_extents;
-		mlog_errno(status);
-		goto leave;
-	}
-
-	/* there are two cases which could cause us to EAGAIN in the
-	 * we-need-more-metadata case:
-	 * 1) we haven't reserved *any*
-	 * 2) we are so fragmented, we've needed to add metadata too
-	 *    many times. */
-	if (!free_extents && !meta_ac) {
-		mlog(0, "we haven't reserved any metadata!\n");
-		status = -EAGAIN;
-		reason = RESTART_META;
-		goto leave;
-	} else if ((!free_extents)
-		   && (ocfs2_alloc_context_bits_left(meta_ac)
-		       < ocfs2_extend_meta_needed(&fe->id2.i_list))) {
-		mlog(0, "filesystem is really fragmented...\n");
-		status = -EAGAIN;
-		reason = RESTART_META;
-		goto leave;
-	}
-
-	status = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
-					clusters_to_add, &bit_off, &num_bits);
-	if (status < 0) {
-		if (status != -ENOSPC)
-			mlog_errno(status);
-		goto leave;
-	}
-
-	BUG_ON(num_bits > clusters_to_add);
-
-	/* reserve our write early -- insert_extent may update the inode */
-	status = ocfs2_journal_access(handle, inode, fe_bh,
-				      OCFS2_JOURNAL_ACCESS_WRITE);
-	if (status < 0) {
-		mlog_errno(status);
-		goto leave;
-	}
-
-	block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
-	mlog(0, "Allocating %u clusters at block %u for inode %llu\n",
-	     num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
-	status = ocfs2_insert_extent(osb, handle, inode, fe_bh,
-				     *logical_offset, block, num_bits,
-				     flags, meta_ac, OCFS2_DINODE_EXTENT);
-	if (status < 0) {
-		mlog_errno(status);
-		goto leave;
-	}
+	struct ocfs2_extent_list *el = &fe->id2.i_list;
 
-	status = ocfs2_journal_dirty(handle, fe_bh);
-	if (status < 0) {
-		mlog_errno(status);
-		goto leave;
-	}
-
-	clusters_to_add -= num_bits;
-	*logical_offset += num_bits;
-
-	if (clusters_to_add) {
-		mlog(0, "need to alloc once more, clusters = %u, wanted = "
-		     "%u\n", fe->i_clusters, clusters_to_add);
-		status = -EAGAIN;
-		reason = RESTART_TRANS;
-	}
-
-leave:
-	mlog_exit(status);
-	if (reason_ret)
-		*reason_ret = reason;
-	return status;
+	return ocfs2_add_clusters_in_btree(osb, inode, logical_offset,
+					   clusters_to_add, mark_unwritten,
+					   fe_bh, el, handle,
+					   data_ac, meta_ac, reason_ret,
+					   OCFS2_DINODE_EXTENT);
 }
 
 static int __ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
@@ -676,16 +594,16 @@ restarted_transaction:
 
 	prev_clusters = OCFS2_I(inode)->ip_clusters;
 
-	status = ocfs2_do_extend_allocation(osb,
-					    inode,
-					    &logical_start,
-					    clusters_to_add,
-					    mark_unwritten,
-					    bh,
-					    handle,
-					    data_ac,
-					    meta_ac,
-					    &why);
+	status = ocfs2_add_inode_data(osb,
+				      inode,
+				      &logical_start,
+				      clusters_to_add,
+				      mark_unwritten,
+				      bh,
+				      handle,
+				      data_ac,
+				      meta_ac,
+				      &why);
 	if ((status < 0) && (status != -EAGAIN)) {
 		if (status != -ENOSPC)
 			mlog_errno(status);
--- a/fs/ocfs2/file.h
+++ b/fs/ocfs2/file.h
@@ -31,6 +31,7 @@ extern const struct file_operations ocfs
 extern const struct inode_operations ocfs2_file_iops;
 extern const struct inode_operations ocfs2_special_file_iops;
 struct ocfs2_alloc_context;
+enum ocfs2_alloc_restarted;
 
 struct ocfs2_file_private {
 	struct file		*fp_file;
@@ -38,21 +39,16 @@ struct ocfs2_file_private {
 	struct ocfs2_lock_res	fp_flock;
 };
 
-enum ocfs2_alloc_restarted {
-	RESTART_NONE = 0,
-	RESTART_TRANS,
-	RESTART_META
-};
-int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
-			       struct inode *inode,
-			       u32 *logical_offset,
-			       u32 clusters_to_add,
-			       int mark_unwritten,
-			       struct buffer_head *fe_bh,
-			       handle_t *handle,
-			       struct ocfs2_alloc_context *data_ac,
-			       struct ocfs2_alloc_context *meta_ac,
-			       enum ocfs2_alloc_restarted *reason_ret);
+int ocfs2_add_inode_data(struct ocfs2_super *osb,
+			 struct inode *inode,
+			 u32 *logical_offset,
+			 u32 clusters_to_add,
+			 int mark_unwritten,
+			 struct buffer_head *fe_bh,
+			 handle_t *handle,
+			 struct ocfs2_alloc_context *data_ac,
+			 struct ocfs2_alloc_context *meta_ac,
+			 enum ocfs2_alloc_restarted *reason_ret);
 int ocfs2_extend_no_holes(struct inode *inode, u64 new_i_size,
 			  u64 zero_to);
 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr);
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -1598,10 +1598,10 @@ static int ocfs2_symlink(struct inode *d
 		u32 offset = 0;
 
 		inode->i_op = &ocfs2_symlink_inode_operations;
-		status = ocfs2_do_extend_allocation(osb, inode, &offset, 1, 0,
-						    new_fe_bh,
-						    handle, data_ac, NULL,
-						    NULL);
+		status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
+					      new_fe_bh,
+					      handle, data_ac, NULL,
+					      NULL);
 		if (status < 0) {
 			if (status != -ENOSPC && status != -EINTR) {
 				mlog(ML_ERROR,
Commit	Line	Data
2cb7cef9 BS	1	From: Tao Ma <tao.ma@oracle.com>
	2	Subject: [PATCH 04/16] ocfs2: Make high level btree extend code generic
	3	Patch-mainline: 2.6.28?
	4	References: FATE302067
	5
	6	Factor out the non-inode specifics of ocfs2_do_extend_allocation() into a more generic
	7	function, ocfs2_do_cluster_allocation(). ocfs2_do_extend_allocation calls
	8	ocfs2_do_cluster_allocation() now, but the latter can be used for other
	9	btree types as well.
	10
	11	Signed-off-by: Tao Ma <tao.ma@oracle.com>
	12	Signed-off-by: Mark Fasheh <mfasheh@suse.com>
	13	---
	14	fs/ocfs2/alloc.c \| 110 ++++++++++++++++++++++++++++++++++++++++++++
	15	fs/ocfs2/alloc.h \| 17 ++++++
	16	fs/ocfs2/aops.c \| 8 +--
	17	fs/ocfs2/dir.c \| 6 +-
	18	fs/ocfs2/file.c \| 136 ++++++++++---------------------------------------------
	19	fs/ocfs2/file.h \| 26 ++++------
	20	fs/ocfs2/namei.c \| 8 +--
	21	7 files changed, 176 insertions(+), 135 deletions(-)
	22
	23	--- a/fs/ocfs2/alloc.c
	24	+++ b/fs/ocfs2/alloc.c
	25	@@ -4302,6 +4302,116 @@ bail:
	26	return status;
	27	}
	28
	29	+/*
	30	+ * Allcate and add clusters into the extent b-tree.
	31	+ * The new clusters(clusters_to_add) will be inserted at logical_offset.
	32	+ * The extent b-tree's root is root_el and it should be in root_bh, and
	33	+ * it is not limited to the file storage. Any extent tree can use this
	34	+ * function if it implements the proper ocfs2_extent_tree.
	35	+ */
	36	+int ocfs2_add_clusters_in_btree(struct ocfs2_super *osb,
	37	+ struct inode *inode,
	38	+ u32 *logical_offset,
	39	+ u32 clusters_to_add,
	40	+ int mark_unwritten,
	41	+ struct buffer_head *root_bh,
	42	+ struct ocfs2_extent_list *root_el,
	43	+ handle_t *handle,
	44	+ struct ocfs2_alloc_context *data_ac,
	45	+ struct ocfs2_alloc_context *meta_ac,
	46	+ enum ocfs2_alloc_restarted *reason_ret,
	47	+ enum ocfs2_extent_tree_type type)
	48	+{
	49	+ int status = 0;
	50	+ int free_extents;
	51	+ enum ocfs2_alloc_restarted reason = RESTART_NONE;
	52	+ u32 bit_off, num_bits;
	53	+ u64 block;
	54	+ u8 flags = 0;
	55	+
	56	+ BUG_ON(!clusters_to_add);
	57	+
	58	+ if (mark_unwritten)
	59	+ flags = OCFS2_EXT_UNWRITTEN;
	60	+
	61	+ free_extents = ocfs2_num_free_extents(osb, inode, root_bh, type);
	62	+ if (free_extents < 0) {
	63	+ status = free_extents;
	64	+ mlog_errno(status);
65	+ goto leave;
66	+ }
67	+
68	+ /* there are two cases which could cause us to EAGAIN in the
69	+ * we-need-more-metadata case:
70	+ * 1) we haven't reserved any
71	+ * 2) we are so fragmented, we've needed to add metadata too
72	+ * many times. */
73	+ if (!free_extents && !meta_ac) {
74	+ mlog(0, "we haven't reserved any metadata!\n");
75	+ status = -EAGAIN;
76	+ reason = RESTART_META;
77	+ goto leave;
78	+ } else if ((!free_extents)
79	+ && (ocfs2_alloc_context_bits_left(meta_ac)
80	+ < ocfs2_extend_meta_needed(root_el))) {
81	+ mlog(0, "filesystem is really fragmented...\n");
82	+ status = -EAGAIN;
83	+ reason = RESTART_META;
84	+ goto leave;
85	+ }
86	+
87	+ status = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
88	+ clusters_to_add, &bit_off, &num_bits);
89	+ if (status < 0) {
90	+ if (status != -ENOSPC)
91	+ mlog_errno(status);
92	+ goto leave;
93	+ }
94	+
95	+ BUG_ON(num_bits > clusters_to_add);
96	+
97	+ /* reserve our write early -- insert_extent may update the inode */
98	+ status = ocfs2_journal_access(handle, inode, root_bh,
99	+ OCFS2_JOURNAL_ACCESS_WRITE);
100	+ if (status < 0) {
101	+ mlog_errno(status);
102	+ goto leave;
103	+ }
104	+
105	+ block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
106	+ mlog(0, "Allocating %u clusters at block %u for inode %llu\n",
107	+ num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
108	+ status = ocfs2_insert_extent(osb, handle, inode, root_bh,
109	+ *logical_offset, block, num_bits,
110	+ flags, meta_ac, type);
111	+ if (status < 0) {
112	+ mlog_errno(status);
113	+ goto leave;
114	+ }
115	+
116	+ status = ocfs2_journal_dirty(handle, root_bh);
117	+ if (status < 0) {
118	+ mlog_errno(status);
119	+ goto leave;
120	+ }
121	+
122	+ clusters_to_add -= num_bits;
123	+ *logical_offset += num_bits;
124	+
125	+ if (clusters_to_add) {
126	+ mlog(0, "need to alloc once more, wanted = %u\n",
127	+ clusters_to_add);
128	+ status = -EAGAIN;
129	+ reason = RESTART_TRANS;
130	+ }
131	+
132	+leave:
133	+ mlog_exit(status);
134	+ if (reason_ret)
135	+ *reason_ret = reason;
136	+ return status;
137	+}
138	+
139	static void ocfs2_make_right_split_rec(struct super_block *sb,
140	struct ocfs2_extent_rec *split_rec,
141	u32 cpos,
142	--- a/fs/ocfs2/alloc.h
143	+++ b/fs/ocfs2/alloc.h
144	@@ -41,6 +41,23 @@ int ocfs2_insert_extent(struct ocfs2_sup
145	u8 flags,
146	struct ocfs2_alloc_context *meta_ac,
147	enum ocfs2_extent_tree_type et_type);
148	+enum ocfs2_alloc_restarted {
149	+ RESTART_NONE = 0,
150	+ RESTART_TRANS,
151	+ RESTART_META
152	+};
153	+int ocfs2_add_clusters_in_btree(struct ocfs2_super *osb,
154	+ struct inode *inode,
155	+ u32 *logical_offset,
156	+ u32 clusters_to_add,
157	+ int mark_unwritten,
158	+ struct buffer_head *root_bh,
159	+ struct ocfs2_extent_list *root_el,
160	+ handle_t *handle,
161	+ struct ocfs2_alloc_context *data_ac,
162	+ struct ocfs2_alloc_context *meta_ac,
163	+ enum ocfs2_alloc_restarted *reason_ret,
164	+ enum ocfs2_extent_tree_type type);
165	struct ocfs2_cached_dealloc_ctxt;
166	int ocfs2_mark_extent_written(struct inode inode, struct buffer_head root_bh,
167	handle_t *handle, u32 cpos, u32 len, u32 phys,
168	--- a/fs/ocfs2/aops.c
169	+++ b/fs/ocfs2/aops.c
170	@@ -1255,10 +1255,10 @@ static int ocfs2_write_cluster(struct ad
171	* any additional semaphores or cluster locks.
172	*/
173	tmp_pos = cpos;
174	- ret = ocfs2_do_extend_allocation(OCFS2_SB(inode->i_sb), inode,
175	- &tmp_pos, 1, 0, wc->w_di_bh,
176	- wc->w_handle, data_ac,
177	- meta_ac, NULL);
178	+ ret = ocfs2_add_inode_data(OCFS2_SB(inode->i_sb), inode,
179	+ &tmp_pos, 1, 0, wc->w_di_bh,
180	+ wc->w_handle, data_ac,
181	+ meta_ac, NULL);
182	/*
183	* This shouldn't happen because we must have already
184	* calculated the correct meta data allocation required. The
185	--- a/fs/ocfs2/dir.c
186	+++ b/fs/ocfs2/dir.c
187	@@ -1383,9 +1383,9 @@ static int ocfs2_do_extend_dir(struct su
188	if (extend) {
189	u32 offset = OCFS2_I(dir)->ip_clusters;
190
191	- status = ocfs2_do_extend_allocation(OCFS2_SB(sb), dir, &offset,
192	- 1, 0, parent_fe_bh, handle,
193	- data_ac, meta_ac, NULL);
194	+ status = ocfs2_add_inode_data(OCFS2_SB(sb), dir, &offset,
195	+ 1, 0, parent_fe_bh, handle,
196	+ data_ac, meta_ac, NULL);
197	BUG_ON(status == -EAGAIN);
198	if (status < 0) {
199	mlog_errno(status);
200	--- a/fs/ocfs2/file.c
201	+++ b/fs/ocfs2/file.c
202	@@ -488,7 +488,7 @@ bail:
203	}
204
205	/*
206	- * extend allocation only here.
207	+ * extend file allocation only here.
208	* we'll update all the disk stuff, and oip->alloc_size
209	*
210	* expect stuff to be locked, a transaction started and enough data /
211	@@ -497,107 +497,25 @@ bail:
212	* Will return -EAGAIN, and a reason if a restart is needed.
213	* If passed in, *reason will always be set, even in error.
214	*/
215	-int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
216	- struct inode *inode,
217	- u32 *logical_offset,
218	- u32 clusters_to_add,
219	- int mark_unwritten,
220	- struct buffer_head *fe_bh,
221	- handle_t *handle,
222	- struct ocfs2_alloc_context *data_ac,
223	- struct ocfs2_alloc_context *meta_ac,
224	- enum ocfs2_alloc_restarted *reason_ret)
225	+int ocfs2_add_inode_data(struct ocfs2_super *osb,
226	+ struct inode *inode,
227	+ u32 *logical_offset,
228	+ u32 clusters_to_add,
229	+ int mark_unwritten,
230	+ struct buffer_head *fe_bh,
231	+ handle_t *handle,
232	+ struct ocfs2_alloc_context *data_ac,
233	+ struct ocfs2_alloc_context *meta_ac,
234	+ enum ocfs2_alloc_restarted *reason_ret)
235	{
236	- int status = 0;
237	- int free_extents;
238	struct ocfs2_dinode fe = (struct ocfs2_dinode ) fe_bh->b_data;
239	- enum ocfs2_alloc_restarted reason = RESTART_NONE;
240	- u32 bit_off, num_bits;
241	- u64 block;
242	- u8 flags = 0;
243	-
244	- BUG_ON(!clusters_to_add);
245	-
246	- if (mark_unwritten)
247	- flags = OCFS2_EXT_UNWRITTEN;
248	-
249	- free_extents = ocfs2_num_free_extents(osb, inode, fe_bh,
250	- OCFS2_DINODE_EXTENT);
251	- if (free_extents < 0) {
252	- status = free_extents;
253	- mlog_errno(status);
254	- goto leave;
255	- }
256	-
257	- /* there are two cases which could cause us to EAGAIN in the
258	- * we-need-more-metadata case:
259	- * 1) we haven't reserved any
260	- * 2) we are so fragmented, we've needed to add metadata too
261	- * many times. */
262	- if (!free_extents && !meta_ac) {
263	- mlog(0, "we haven't reserved any metadata!\n");
264	- status = -EAGAIN;
265	- reason = RESTART_META;
266	- goto leave;
267	- } else if ((!free_extents)
268	- && (ocfs2_alloc_context_bits_left(meta_ac)
269	- < ocfs2_extend_meta_needed(&fe->id2.i_list))) {
270	- mlog(0, "filesystem is really fragmented...\n");
271	- status = -EAGAIN;
272	- reason = RESTART_META;
273	- goto leave;
274	- }
275	-
276	- status = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
277	- clusters_to_add, &bit_off, &num_bits);
278	- if (status < 0) {
279	- if (status != -ENOSPC)
280	- mlog_errno(status);
281	- goto leave;
282	- }
283	-
284	- BUG_ON(num_bits > clusters_to_add);
285	-
286	- /* reserve our write early -- insert_extent may update the inode */
287	- status = ocfs2_journal_access(handle, inode, fe_bh,
288	- OCFS2_JOURNAL_ACCESS_WRITE);
289	- if (status < 0) {
290	- mlog_errno(status);
291	- goto leave;
292	- }
293	-
294	- block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
295	- mlog(0, "Allocating %u clusters at block %u for inode %llu\n",
296	- num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
297	- status = ocfs2_insert_extent(osb, handle, inode, fe_bh,
298	- *logical_offset, block, num_bits,
299	- flags, meta_ac, OCFS2_DINODE_EXTENT);
300	- if (status < 0) {
301	- mlog_errno(status);
302	- goto leave;
303	- }
304	+ struct ocfs2_extent_list *el = &fe->id2.i_list;
305
306	- status = ocfs2_journal_dirty(handle, fe_bh);
307	- if (status < 0) {
308	- mlog_errno(status);
309	- goto leave;
310	- }
311	-
312	- clusters_to_add -= num_bits;
313	- *logical_offset += num_bits;
314	-
315	- if (clusters_to_add) {
316	- mlog(0, "need to alloc once more, clusters = %u, wanted = "
317	- "%u\n", fe->i_clusters, clusters_to_add);
318	- status = -EAGAIN;
319	- reason = RESTART_TRANS;
320	- }
321	-
322	-leave:
323	- mlog_exit(status);
324	- if (reason_ret)
325	- *reason_ret = reason;
326	- return status;
327	+ return ocfs2_add_clusters_in_btree(osb, inode, logical_offset,
328	+ clusters_to_add, mark_unwritten,
329	+ fe_bh, el, handle,
330	+ data_ac, meta_ac, reason_ret,
331	+ OCFS2_DINODE_EXTENT);
332	}
333
334	static int __ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
335	@@ -676,16 +594,16 @@ restarted_transaction:
336
337	prev_clusters = OCFS2_I(inode)->ip_clusters;
338
339	- status = ocfs2_do_extend_allocation(osb,
340	- inode,
341	- &logical_start,
342	- clusters_to_add,
343	- mark_unwritten,
344	- bh,
345	- handle,
346	- data_ac,
347	- meta_ac,
348	- &why);
349	+ status = ocfs2_add_inode_data(osb,
350	+ inode,
351	+ &logical_start,
352	+ clusters_to_add,
353	+ mark_unwritten,
354	+ bh,
355	+ handle,
356	+ data_ac,
357	+ meta_ac,
358	+ &why);
359	if ((status < 0) && (status != -EAGAIN)) {
360	if (status != -ENOSPC)
361	mlog_errno(status);
362	--- a/fs/ocfs2/file.h
363	+++ b/fs/ocfs2/file.h
364	@@ -31,6 +31,7 @@ extern const struct file_operations ocfs
365	extern const struct inode_operations ocfs2_file_iops;
366	extern const struct inode_operations ocfs2_special_file_iops;
367	struct ocfs2_alloc_context;
368	+enum ocfs2_alloc_restarted;
369
370	struct ocfs2_file_private {
371	struct file *fp_file;
372	@@ -38,21 +39,16 @@ struct ocfs2_file_private {
373	struct ocfs2_lock_res fp_flock;
374	};
375
376	-enum ocfs2_alloc_restarted {
377	- RESTART_NONE = 0,
378	- RESTART_TRANS,
379	- RESTART_META
380	-};
381	-int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
382	- struct inode *inode,
383	- u32 *logical_offset,
384	- u32 clusters_to_add,
385	- int mark_unwritten,
386	- struct buffer_head *fe_bh,
387	- handle_t *handle,
388	- struct ocfs2_alloc_context *data_ac,
389	- struct ocfs2_alloc_context *meta_ac,
390	- enum ocfs2_alloc_restarted *reason_ret);
391	+int ocfs2_add_inode_data(struct ocfs2_super *osb,
392	+ struct inode *inode,
393	+ u32 *logical_offset,
394	+ u32 clusters_to_add,
395	+ int mark_unwritten,
396	+ struct buffer_head *fe_bh,
397	+ handle_t *handle,
398	+ struct ocfs2_alloc_context *data_ac,
399	+ struct ocfs2_alloc_context *meta_ac,
400	+ enum ocfs2_alloc_restarted *reason_ret);
401	int ocfs2_extend_no_holes(struct inode *inode, u64 new_i_size,
402	u64 zero_to);
403	int ocfs2_setattr(struct dentry dentry, struct iattr attr);
404	--- a/fs/ocfs2/namei.c
405	+++ b/fs/ocfs2/namei.c
406	@@ -1598,10 +1598,10 @@ static int ocfs2_symlink(struct inode *d
407	u32 offset = 0;
408
409	inode->i_op = &ocfs2_symlink_inode_operations;
410	- status = ocfs2_do_extend_allocation(osb, inode, &offset, 1, 0,
411	- new_fe_bh,
412	- handle, data_ac, NULL,
413	- NULL);
414	+ status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
415	+ new_fe_bh,
416	+ handle, data_ac, NULL,
417	+ NULL);
418	if (status < 0) {
419	if (status != -ENOSPC && status != -EINTR) {
420	mlog(ML_ERROR,