xref: /openbmc/linux/fs/ocfs2/alloc.c (revision 1c25d93a4a27c90c3ae33f9e724f7b67783d68d1)
1ccd979bdSMark Fasheh /* -*- mode: c; c-basic-offset: 8; -*-
2ccd979bdSMark Fasheh  * vim: noexpandtab sw=8 ts=8 sts=0:
3ccd979bdSMark Fasheh  *
4ccd979bdSMark Fasheh  * alloc.c
5ccd979bdSMark Fasheh  *
6ccd979bdSMark Fasheh  * Extent allocs and frees
7ccd979bdSMark Fasheh  *
8ccd979bdSMark Fasheh  * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
9ccd979bdSMark Fasheh  *
10ccd979bdSMark Fasheh  * This program is free software; you can redistribute it and/or
11ccd979bdSMark Fasheh  * modify it under the terms of the GNU General Public
12ccd979bdSMark Fasheh  * License as published by the Free Software Foundation; either
13ccd979bdSMark Fasheh  * version 2 of the License, or (at your option) any later version.
14ccd979bdSMark Fasheh  *
15ccd979bdSMark Fasheh  * This program is distributed in the hope that it will be useful,
16ccd979bdSMark Fasheh  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17ccd979bdSMark Fasheh  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18ccd979bdSMark Fasheh  * General Public License for more details.
19ccd979bdSMark Fasheh  *
20ccd979bdSMark Fasheh  * You should have received a copy of the GNU General Public
21ccd979bdSMark Fasheh  * License along with this program; if not, write to the
22ccd979bdSMark Fasheh  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23ccd979bdSMark Fasheh  * Boston, MA 021110-1307, USA.
24ccd979bdSMark Fasheh  */
25ccd979bdSMark Fasheh 
26ccd979bdSMark Fasheh #include <linux/fs.h>
27ccd979bdSMark Fasheh #include <linux/types.h>
28ccd979bdSMark Fasheh #include <linux/slab.h>
29ccd979bdSMark Fasheh #include <linux/highmem.h>
3060b11392SMark Fasheh #include <linux/swap.h>
31ccd979bdSMark Fasheh 
32ccd979bdSMark Fasheh #define MLOG_MASK_PREFIX ML_DISK_ALLOC
33ccd979bdSMark Fasheh #include <cluster/masklog.h>
34ccd979bdSMark Fasheh 
35ccd979bdSMark Fasheh #include "ocfs2.h"
36ccd979bdSMark Fasheh 
37ccd979bdSMark Fasheh #include "alloc.h"
3860b11392SMark Fasheh #include "aops.h"
39ccd979bdSMark Fasheh #include "dlmglue.h"
40ccd979bdSMark Fasheh #include "extent_map.h"
41ccd979bdSMark Fasheh #include "inode.h"
42ccd979bdSMark Fasheh #include "journal.h"
43ccd979bdSMark Fasheh #include "localalloc.h"
44ccd979bdSMark Fasheh #include "suballoc.h"
45ccd979bdSMark Fasheh #include "sysfile.h"
46ccd979bdSMark Fasheh #include "file.h"
47ccd979bdSMark Fasheh #include "super.h"
48ccd979bdSMark Fasheh #include "uptodate.h"
49ccd979bdSMark Fasheh 
50ccd979bdSMark Fasheh #include "buffer_head_io.h"
51ccd979bdSMark Fasheh 
52e7d4cb6bSTao Ma /*
53e7d4cb6bSTao Ma  * ocfs2_extent_tree and ocfs2_extent_tree_operations are used to abstract
54e7d4cb6bSTao Ma  * the b-tree operations in ocfs2. Now all the b-tree operations are not
55e7d4cb6bSTao Ma  * limited to ocfs2_dinode only. Any data which need to allocate clusters
56e7d4cb6bSTao Ma  * to store can use b-tree. And it only needs to implement its ocfs2_extent_tree
57e7d4cb6bSTao Ma  * and operation.
58e7d4cb6bSTao Ma  *
59e7d4cb6bSTao Ma  * ocfs2_extent_tree contains info for the root of the b-tree, it must have a
60e7d4cb6bSTao Ma  * root ocfs2_extent_list and a root_bh so that they can be used in the b-tree
61e7d4cb6bSTao Ma  * functions.
62e7d4cb6bSTao Ma  * ocfs2_extent_tree_operations abstract the normal operations we do for
63e7d4cb6bSTao Ma  * the root of extent b-tree.
64e7d4cb6bSTao Ma  */
65e7d4cb6bSTao Ma struct ocfs2_extent_tree;
66e7d4cb6bSTao Ma 
67e7d4cb6bSTao Ma struct ocfs2_extent_tree_operations {
6835dc0aa3SJoel Becker 	void (*eo_set_last_eb_blk)(struct ocfs2_extent_tree *et,
6935dc0aa3SJoel Becker 				   u64 blkno);
7035dc0aa3SJoel Becker 	u64 (*eo_get_last_eb_blk)(struct ocfs2_extent_tree *et);
7135dc0aa3SJoel Becker 	void (*eo_update_clusters)(struct inode *inode,
72e7d4cb6bSTao Ma 				   struct ocfs2_extent_tree *et,
73e7d4cb6bSTao Ma 				   u32 new_clusters);
7435dc0aa3SJoel Becker 	int (*eo_sanity_check)(struct inode *inode, struct ocfs2_extent_tree *et);
750ce1010fSJoel Becker 
760ce1010fSJoel Becker 	/* These are internal to ocfs2_extent_tree and don't have
770ce1010fSJoel Becker 	 * accessor functions */
780ce1010fSJoel Becker 	void (*eo_fill_root_el)(struct ocfs2_extent_tree *et);
79e7d4cb6bSTao Ma };
80e7d4cb6bSTao Ma 
81e7d4cb6bSTao Ma struct ocfs2_extent_tree {
82ce1d9ea6SJoel Becker 	enum ocfs2_extent_tree_type		et_type;
83ce1d9ea6SJoel Becker 	struct ocfs2_extent_tree_operations	*et_ops;
84ce1d9ea6SJoel Becker 	struct buffer_head			*et_root_bh;
85ce1d9ea6SJoel Becker 	struct ocfs2_extent_list		*et_root_el;
86ea5efa15SJoel Becker 	void					*et_object;
87ce1d9ea6SJoel Becker 	unsigned int				et_max_leaf_clusters;
88e7d4cb6bSTao Ma };
89e7d4cb6bSTao Ma 
900ce1010fSJoel Becker static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et)
910ce1010fSJoel Becker {
920ce1010fSJoel Becker 	struct ocfs2_dinode *di = et->et_object;
930ce1010fSJoel Becker 
940ce1010fSJoel Becker 	et->et_root_el = &di->id2.i_list;
950ce1010fSJoel Becker }
960ce1010fSJoel Becker 
97e7d4cb6bSTao Ma static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
98e7d4cb6bSTao Ma 					 u64 blkno)
99e7d4cb6bSTao Ma {
100ea5efa15SJoel Becker 	struct ocfs2_dinode *di = et->et_object;
101e7d4cb6bSTao Ma 
102ce1d9ea6SJoel Becker 	BUG_ON(et->et_type != OCFS2_DINODE_EXTENT);
103e7d4cb6bSTao Ma 	di->i_last_eb_blk = cpu_to_le64(blkno);
104e7d4cb6bSTao Ma }
105e7d4cb6bSTao Ma 
106e7d4cb6bSTao Ma static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et)
107e7d4cb6bSTao Ma {
108ea5efa15SJoel Becker 	struct ocfs2_dinode *di = et->et_object;
109e7d4cb6bSTao Ma 
110ce1d9ea6SJoel Becker 	BUG_ON(et->et_type != OCFS2_DINODE_EXTENT);
111e7d4cb6bSTao Ma 	return le64_to_cpu(di->i_last_eb_blk);
112e7d4cb6bSTao Ma }
113e7d4cb6bSTao Ma 
114e7d4cb6bSTao Ma static void ocfs2_dinode_update_clusters(struct inode *inode,
115e7d4cb6bSTao Ma 					 struct ocfs2_extent_tree *et,
116e7d4cb6bSTao Ma 					 u32 clusters)
117e7d4cb6bSTao Ma {
118ea5efa15SJoel Becker 	struct ocfs2_dinode *di = et->et_object;
119e7d4cb6bSTao Ma 
120e7d4cb6bSTao Ma 	le32_add_cpu(&di->i_clusters, clusters);
121e7d4cb6bSTao Ma 	spin_lock(&OCFS2_I(inode)->ip_lock);
122e7d4cb6bSTao Ma 	OCFS2_I(inode)->ip_clusters = le32_to_cpu(di->i_clusters);
123e7d4cb6bSTao Ma 	spin_unlock(&OCFS2_I(inode)->ip_lock);
124e7d4cb6bSTao Ma }
125e7d4cb6bSTao Ma 
126e7d4cb6bSTao Ma static int ocfs2_dinode_sanity_check(struct inode *inode,
127e7d4cb6bSTao Ma 				     struct ocfs2_extent_tree *et)
128e7d4cb6bSTao Ma {
129e7d4cb6bSTao Ma 	int ret = 0;
130e7d4cb6bSTao Ma 	struct ocfs2_dinode *di;
131e7d4cb6bSTao Ma 
132ce1d9ea6SJoel Becker 	BUG_ON(et->et_type != OCFS2_DINODE_EXTENT);
133e7d4cb6bSTao Ma 
134ea5efa15SJoel Becker 	di = et->et_object;
135e7d4cb6bSTao Ma 	if (!OCFS2_IS_VALID_DINODE(di)) {
136e7d4cb6bSTao Ma 		ret = -EIO;
137e7d4cb6bSTao Ma 		ocfs2_error(inode->i_sb,
138e7d4cb6bSTao Ma 			"Inode %llu has invalid path root",
139e7d4cb6bSTao Ma 			(unsigned long long)OCFS2_I(inode)->ip_blkno);
140e7d4cb6bSTao Ma 	}
141e7d4cb6bSTao Ma 
142e7d4cb6bSTao Ma 	return ret;
143e7d4cb6bSTao Ma }
144e7d4cb6bSTao Ma 
145e7d4cb6bSTao Ma static struct ocfs2_extent_tree_operations ocfs2_dinode_et_ops = {
14635dc0aa3SJoel Becker 	.eo_set_last_eb_blk	= ocfs2_dinode_set_last_eb_blk,
14735dc0aa3SJoel Becker 	.eo_get_last_eb_blk	= ocfs2_dinode_get_last_eb_blk,
14835dc0aa3SJoel Becker 	.eo_update_clusters	= ocfs2_dinode_update_clusters,
14935dc0aa3SJoel Becker 	.eo_sanity_check	= ocfs2_dinode_sanity_check,
1500ce1010fSJoel Becker 	.eo_fill_root_el	= ocfs2_dinode_fill_root_el,
151e7d4cb6bSTao Ma };
152e7d4cb6bSTao Ma 
1530ce1010fSJoel Becker static void ocfs2_xattr_value_fill_root_el(struct ocfs2_extent_tree *et)
1540ce1010fSJoel Becker {
1550ce1010fSJoel Becker 	struct ocfs2_xattr_value_root *xv = et->et_object;
1560ce1010fSJoel Becker 
1570ce1010fSJoel Becker 	et->et_root_el = &xv->xr_list;
1580ce1010fSJoel Becker }
1590ce1010fSJoel Becker 
160f56654c4STao Ma static void ocfs2_xattr_value_set_last_eb_blk(struct ocfs2_extent_tree *et,
161f56654c4STao Ma 					      u64 blkno)
162f56654c4STao Ma {
163f56654c4STao Ma 	struct ocfs2_xattr_value_root *xv =
164ea5efa15SJoel Becker 		(struct ocfs2_xattr_value_root *)et->et_object;
165f56654c4STao Ma 
166f56654c4STao Ma 	xv->xr_last_eb_blk = cpu_to_le64(blkno);
167f56654c4STao Ma }
168f56654c4STao Ma 
169f56654c4STao Ma static u64 ocfs2_xattr_value_get_last_eb_blk(struct ocfs2_extent_tree *et)
170f56654c4STao Ma {
171f56654c4STao Ma 	struct ocfs2_xattr_value_root *xv =
172ea5efa15SJoel Becker 		(struct ocfs2_xattr_value_root *) et->et_object;
173f56654c4STao Ma 
174f56654c4STao Ma 	return le64_to_cpu(xv->xr_last_eb_blk);
175f56654c4STao Ma }
176f56654c4STao Ma 
177f56654c4STao Ma static void ocfs2_xattr_value_update_clusters(struct inode *inode,
178f56654c4STao Ma 					      struct ocfs2_extent_tree *et,
179f56654c4STao Ma 					      u32 clusters)
180f56654c4STao Ma {
181f56654c4STao Ma 	struct ocfs2_xattr_value_root *xv =
182ea5efa15SJoel Becker 		(struct ocfs2_xattr_value_root *)et->et_object;
183f56654c4STao Ma 
184f56654c4STao Ma 	le32_add_cpu(&xv->xr_clusters, clusters);
185f56654c4STao Ma }
186f56654c4STao Ma 
187f56654c4STao Ma static int ocfs2_xattr_value_sanity_check(struct inode *inode,
188f56654c4STao Ma 					  struct ocfs2_extent_tree *et)
189f56654c4STao Ma {
190f56654c4STao Ma 	return 0;
191f56654c4STao Ma }
192f56654c4STao Ma 
193f56654c4STao Ma static struct ocfs2_extent_tree_operations ocfs2_xattr_et_ops = {
19435dc0aa3SJoel Becker 	.eo_set_last_eb_blk	= ocfs2_xattr_value_set_last_eb_blk,
19535dc0aa3SJoel Becker 	.eo_get_last_eb_blk	= ocfs2_xattr_value_get_last_eb_blk,
19635dc0aa3SJoel Becker 	.eo_update_clusters	= ocfs2_xattr_value_update_clusters,
19735dc0aa3SJoel Becker 	.eo_sanity_check	= ocfs2_xattr_value_sanity_check,
1980ce1010fSJoel Becker 	.eo_fill_root_el	= ocfs2_xattr_value_fill_root_el,
199f56654c4STao Ma };
200f56654c4STao Ma 
2010ce1010fSJoel Becker static void ocfs2_xattr_tree_fill_root_el(struct ocfs2_extent_tree *et)
2020ce1010fSJoel Becker {
2030ce1010fSJoel Becker 	struct ocfs2_xattr_block *xb = et->et_object;
2040ce1010fSJoel Becker 
2050ce1010fSJoel Becker 	et->et_root_el = &xb->xb_attrs.xb_root.xt_list;
2060ce1010fSJoel Becker }
2070ce1010fSJoel Becker 
208ba492615STao Ma static void ocfs2_xattr_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
209ba492615STao Ma 					     u64 blkno)
210ba492615STao Ma {
211ea5efa15SJoel Becker 	struct ocfs2_xattr_block *xb = et->et_object;
212ba492615STao Ma 	struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
213ba492615STao Ma 
214ba492615STao Ma 	xt->xt_last_eb_blk = cpu_to_le64(blkno);
215ba492615STao Ma }
216ba492615STao Ma 
217ba492615STao Ma static u64 ocfs2_xattr_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
218ba492615STao Ma {
219ea5efa15SJoel Becker 	struct ocfs2_xattr_block *xb = et->et_object;
220ba492615STao Ma 	struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
221ba492615STao Ma 
222ba492615STao Ma 	return le64_to_cpu(xt->xt_last_eb_blk);
223ba492615STao Ma }
224ba492615STao Ma 
225ba492615STao Ma static void ocfs2_xattr_tree_update_clusters(struct inode *inode,
226ba492615STao Ma 					     struct ocfs2_extent_tree *et,
227ba492615STao Ma 					     u32 clusters)
228ba492615STao Ma {
229ea5efa15SJoel Becker 	struct ocfs2_xattr_block *xb = et->et_object;
230ba492615STao Ma 
231ba492615STao Ma 	le32_add_cpu(&xb->xb_attrs.xb_root.xt_clusters, clusters);
232ba492615STao Ma }
233ba492615STao Ma 
234ba492615STao Ma static int ocfs2_xattr_tree_sanity_check(struct inode *inode,
235ba492615STao Ma 					 struct ocfs2_extent_tree *et)
236ba492615STao Ma {
237ba492615STao Ma 	return 0;
238ba492615STao Ma }
239ba492615STao Ma 
240ba492615STao Ma static struct ocfs2_extent_tree_operations ocfs2_xattr_tree_et_ops = {
24135dc0aa3SJoel Becker 	.eo_set_last_eb_blk	= ocfs2_xattr_tree_set_last_eb_blk,
24235dc0aa3SJoel Becker 	.eo_get_last_eb_blk	= ocfs2_xattr_tree_get_last_eb_blk,
24335dc0aa3SJoel Becker 	.eo_update_clusters	= ocfs2_xattr_tree_update_clusters,
24435dc0aa3SJoel Becker 	.eo_sanity_check	= ocfs2_xattr_tree_sanity_check,
2450ce1010fSJoel Becker 	.eo_fill_root_el	= ocfs2_xattr_tree_fill_root_el,
246ba492615STao Ma };
247ba492615STao Ma 
248dc0ce61aSJoel Becker static void ocfs2_get_extent_tree(struct ocfs2_extent_tree *et,
249dc0ce61aSJoel Becker 				  struct inode *inode,
250ca12b7c4STao Ma 				  struct buffer_head *bh,
251f56654c4STao Ma 				  enum ocfs2_extent_tree_type et_type,
252ea5efa15SJoel Becker 				  void *obj)
253e7d4cb6bSTao Ma {
254ce1d9ea6SJoel Becker 	et->et_type = et_type;
255e7d4cb6bSTao Ma 	get_bh(bh);
256ce1d9ea6SJoel Becker 	et->et_root_bh = bh;
257dc0ce61aSJoel Becker 	et->et_max_leaf_clusters = 0;
258ea5efa15SJoel Becker 	if (!obj)
259ea5efa15SJoel Becker 		obj = (void *)bh->b_data;
260ea5efa15SJoel Becker 	et->et_object = obj;
261e7d4cb6bSTao Ma 
262e7d4cb6bSTao Ma 	if (et_type == OCFS2_DINODE_EXTENT) {
263ce1d9ea6SJoel Becker 		et->et_ops = &ocfs2_dinode_et_ops;
264f56654c4STao Ma 	} else if (et_type == OCFS2_XATTR_VALUE_EXTENT) {
265ce1d9ea6SJoel Becker 		et->et_ops = &ocfs2_xattr_et_ops;
266ba492615STao Ma 	} else if (et_type == OCFS2_XATTR_TREE_EXTENT) {
267ce1d9ea6SJoel Becker 		et->et_ops = &ocfs2_xattr_tree_et_ops;
268ce1d9ea6SJoel Becker 		et->et_max_leaf_clusters = ocfs2_clusters_for_bytes(inode->i_sb,
269ca12b7c4STao Ma 						OCFS2_MAX_XATTR_TREE_LEAF_SIZE);
270e7d4cb6bSTao Ma 	}
2710ce1010fSJoel Becker 
2720ce1010fSJoel Becker 	et->et_ops->eo_fill_root_el(et);
273e7d4cb6bSTao Ma }
274e7d4cb6bSTao Ma 
275dc0ce61aSJoel Becker static void ocfs2_put_extent_tree(struct ocfs2_extent_tree *et)
276e7d4cb6bSTao Ma {
277ce1d9ea6SJoel Becker 	brelse(et->et_root_bh);
278e7d4cb6bSTao Ma }
279e7d4cb6bSTao Ma 
28035dc0aa3SJoel Becker static inline void ocfs2_et_set_last_eb_blk(struct ocfs2_extent_tree *et,
281e7d4cb6bSTao Ma 					    u64 new_last_eb_blk)
282e7d4cb6bSTao Ma {
283ce1d9ea6SJoel Becker 	et->et_ops->eo_set_last_eb_blk(et, new_last_eb_blk);
284e7d4cb6bSTao Ma }
285e7d4cb6bSTao Ma 
28635dc0aa3SJoel Becker static inline u64 ocfs2_et_get_last_eb_blk(struct ocfs2_extent_tree *et)
287e7d4cb6bSTao Ma {
288ce1d9ea6SJoel Becker 	return et->et_ops->eo_get_last_eb_blk(et);
289e7d4cb6bSTao Ma }
290e7d4cb6bSTao Ma 
29135dc0aa3SJoel Becker static inline void ocfs2_et_update_clusters(struct inode *inode,
292e7d4cb6bSTao Ma 					    struct ocfs2_extent_tree *et,
293e7d4cb6bSTao Ma 					    u32 clusters)
294e7d4cb6bSTao Ma {
295ce1d9ea6SJoel Becker 	et->et_ops->eo_update_clusters(inode, et, clusters);
29635dc0aa3SJoel Becker }
29735dc0aa3SJoel Becker 
29835dc0aa3SJoel Becker static inline int ocfs2_et_sanity_check(struct inode *inode,
29935dc0aa3SJoel Becker 					struct ocfs2_extent_tree *et)
30035dc0aa3SJoel Becker {
301ce1d9ea6SJoel Becker 	return et->et_ops->eo_sanity_check(inode, et);
302e7d4cb6bSTao Ma }
303e7d4cb6bSTao Ma 
304ccd979bdSMark Fasheh static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc);
30559a5e416SMark Fasheh static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
30659a5e416SMark Fasheh 					 struct ocfs2_extent_block *eb);
307ccd979bdSMark Fasheh 
308dcd0538fSMark Fasheh /*
309dcd0538fSMark Fasheh  * Structures which describe a path through a btree, and functions to
310dcd0538fSMark Fasheh  * manipulate them.
311dcd0538fSMark Fasheh  *
312dcd0538fSMark Fasheh  * The idea here is to be as generic as possible with the tree
313dcd0538fSMark Fasheh  * manipulation code.
314dcd0538fSMark Fasheh  */
315dcd0538fSMark Fasheh struct ocfs2_path_item {
316dcd0538fSMark Fasheh 	struct buffer_head		*bh;
317dcd0538fSMark Fasheh 	struct ocfs2_extent_list	*el;
318dcd0538fSMark Fasheh };
319dcd0538fSMark Fasheh 
320dcd0538fSMark Fasheh #define OCFS2_MAX_PATH_DEPTH	5
321dcd0538fSMark Fasheh 
322dcd0538fSMark Fasheh struct ocfs2_path {
323dcd0538fSMark Fasheh 	int			p_tree_depth;
324dcd0538fSMark Fasheh 	struct ocfs2_path_item	p_node[OCFS2_MAX_PATH_DEPTH];
325dcd0538fSMark Fasheh };
326dcd0538fSMark Fasheh 
327dcd0538fSMark Fasheh #define path_root_bh(_path) ((_path)->p_node[0].bh)
328dcd0538fSMark Fasheh #define path_root_el(_path) ((_path)->p_node[0].el)
329dcd0538fSMark Fasheh #define path_leaf_bh(_path) ((_path)->p_node[(_path)->p_tree_depth].bh)
330dcd0538fSMark Fasheh #define path_leaf_el(_path) ((_path)->p_node[(_path)->p_tree_depth].el)
331dcd0538fSMark Fasheh #define path_num_items(_path) ((_path)->p_tree_depth + 1)
332dcd0538fSMark Fasheh 
333dcd0538fSMark Fasheh /*
334dcd0538fSMark Fasheh  * Reset the actual path elements so that we can re-use the structure
335dcd0538fSMark Fasheh  * to build another path. Generally, this involves freeing the buffer
336dcd0538fSMark Fasheh  * heads.
337dcd0538fSMark Fasheh  */
338dcd0538fSMark Fasheh static void ocfs2_reinit_path(struct ocfs2_path *path, int keep_root)
339dcd0538fSMark Fasheh {
340dcd0538fSMark Fasheh 	int i, start = 0, depth = 0;
341dcd0538fSMark Fasheh 	struct ocfs2_path_item *node;
342dcd0538fSMark Fasheh 
343dcd0538fSMark Fasheh 	if (keep_root)
344dcd0538fSMark Fasheh 		start = 1;
345dcd0538fSMark Fasheh 
346dcd0538fSMark Fasheh 	for(i = start; i < path_num_items(path); i++) {
347dcd0538fSMark Fasheh 		node = &path->p_node[i];
348dcd0538fSMark Fasheh 
349dcd0538fSMark Fasheh 		brelse(node->bh);
350dcd0538fSMark Fasheh 		node->bh = NULL;
351dcd0538fSMark Fasheh 		node->el = NULL;
352dcd0538fSMark Fasheh 	}
353dcd0538fSMark Fasheh 
354dcd0538fSMark Fasheh 	/*
355dcd0538fSMark Fasheh 	 * Tree depth may change during truncate, or insert. If we're
356dcd0538fSMark Fasheh 	 * keeping the root extent list, then make sure that our path
357dcd0538fSMark Fasheh 	 * structure reflects the proper depth.
358dcd0538fSMark Fasheh 	 */
359dcd0538fSMark Fasheh 	if (keep_root)
360dcd0538fSMark Fasheh 		depth = le16_to_cpu(path_root_el(path)->l_tree_depth);
361dcd0538fSMark Fasheh 
362dcd0538fSMark Fasheh 	path->p_tree_depth = depth;
363dcd0538fSMark Fasheh }
364dcd0538fSMark Fasheh 
365dcd0538fSMark Fasheh static void ocfs2_free_path(struct ocfs2_path *path)
366dcd0538fSMark Fasheh {
367dcd0538fSMark Fasheh 	if (path) {
368dcd0538fSMark Fasheh 		ocfs2_reinit_path(path, 0);
369dcd0538fSMark Fasheh 		kfree(path);
370dcd0538fSMark Fasheh 	}
371dcd0538fSMark Fasheh }
372dcd0538fSMark Fasheh 
373dcd0538fSMark Fasheh /*
374328d5752SMark Fasheh  * All the elements of src into dest. After this call, src could be freed
375328d5752SMark Fasheh  * without affecting dest.
376328d5752SMark Fasheh  *
377328d5752SMark Fasheh  * Both paths should have the same root. Any non-root elements of dest
378328d5752SMark Fasheh  * will be freed.
379328d5752SMark Fasheh  */
380328d5752SMark Fasheh static void ocfs2_cp_path(struct ocfs2_path *dest, struct ocfs2_path *src)
381328d5752SMark Fasheh {
382328d5752SMark Fasheh 	int i;
383328d5752SMark Fasheh 
384328d5752SMark Fasheh 	BUG_ON(path_root_bh(dest) != path_root_bh(src));
385328d5752SMark Fasheh 	BUG_ON(path_root_el(dest) != path_root_el(src));
386328d5752SMark Fasheh 
387328d5752SMark Fasheh 	ocfs2_reinit_path(dest, 1);
388328d5752SMark Fasheh 
389328d5752SMark Fasheh 	for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
390328d5752SMark Fasheh 		dest->p_node[i].bh = src->p_node[i].bh;
391328d5752SMark Fasheh 		dest->p_node[i].el = src->p_node[i].el;
392328d5752SMark Fasheh 
393328d5752SMark Fasheh 		if (dest->p_node[i].bh)
394328d5752SMark Fasheh 			get_bh(dest->p_node[i].bh);
395328d5752SMark Fasheh 	}
396328d5752SMark Fasheh }
397328d5752SMark Fasheh 
398328d5752SMark Fasheh /*
399dcd0538fSMark Fasheh  * Make the *dest path the same as src and re-initialize src path to
400dcd0538fSMark Fasheh  * have a root only.
401dcd0538fSMark Fasheh  */
402dcd0538fSMark Fasheh static void ocfs2_mv_path(struct ocfs2_path *dest, struct ocfs2_path *src)
403dcd0538fSMark Fasheh {
404dcd0538fSMark Fasheh 	int i;
405dcd0538fSMark Fasheh 
406dcd0538fSMark Fasheh 	BUG_ON(path_root_bh(dest) != path_root_bh(src));
407dcd0538fSMark Fasheh 
408dcd0538fSMark Fasheh 	for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
409dcd0538fSMark Fasheh 		brelse(dest->p_node[i].bh);
410dcd0538fSMark Fasheh 
411dcd0538fSMark Fasheh 		dest->p_node[i].bh = src->p_node[i].bh;
412dcd0538fSMark Fasheh 		dest->p_node[i].el = src->p_node[i].el;
413dcd0538fSMark Fasheh 
414dcd0538fSMark Fasheh 		src->p_node[i].bh = NULL;
415dcd0538fSMark Fasheh 		src->p_node[i].el = NULL;
416dcd0538fSMark Fasheh 	}
417dcd0538fSMark Fasheh }
418dcd0538fSMark Fasheh 
419dcd0538fSMark Fasheh /*
420dcd0538fSMark Fasheh  * Insert an extent block at given index.
421dcd0538fSMark Fasheh  *
422dcd0538fSMark Fasheh  * This will not take an additional reference on eb_bh.
423dcd0538fSMark Fasheh  */
424dcd0538fSMark Fasheh static inline void ocfs2_path_insert_eb(struct ocfs2_path *path, int index,
425dcd0538fSMark Fasheh 					struct buffer_head *eb_bh)
426dcd0538fSMark Fasheh {
427dcd0538fSMark Fasheh 	struct ocfs2_extent_block *eb = (struct ocfs2_extent_block *)eb_bh->b_data;
428dcd0538fSMark Fasheh 
429dcd0538fSMark Fasheh 	/*
430dcd0538fSMark Fasheh 	 * Right now, no root bh is an extent block, so this helps
431dcd0538fSMark Fasheh 	 * catch code errors with dinode trees. The assertion can be
432dcd0538fSMark Fasheh 	 * safely removed if we ever need to insert extent block
433dcd0538fSMark Fasheh 	 * structures at the root.
434dcd0538fSMark Fasheh 	 */
435dcd0538fSMark Fasheh 	BUG_ON(index == 0);
436dcd0538fSMark Fasheh 
437dcd0538fSMark Fasheh 	path->p_node[index].bh = eb_bh;
438dcd0538fSMark Fasheh 	path->p_node[index].el = &eb->h_list;
439dcd0538fSMark Fasheh }
440dcd0538fSMark Fasheh 
441dcd0538fSMark Fasheh static struct ocfs2_path *ocfs2_new_path(struct buffer_head *root_bh,
442dcd0538fSMark Fasheh 					 struct ocfs2_extent_list *root_el)
443dcd0538fSMark Fasheh {
444dcd0538fSMark Fasheh 	struct ocfs2_path *path;
445dcd0538fSMark Fasheh 
446dcd0538fSMark Fasheh 	BUG_ON(le16_to_cpu(root_el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH);
447dcd0538fSMark Fasheh 
448dcd0538fSMark Fasheh 	path = kzalloc(sizeof(*path), GFP_NOFS);
449dcd0538fSMark Fasheh 	if (path) {
450dcd0538fSMark Fasheh 		path->p_tree_depth = le16_to_cpu(root_el->l_tree_depth);
451dcd0538fSMark Fasheh 		get_bh(root_bh);
452dcd0538fSMark Fasheh 		path_root_bh(path) = root_bh;
453dcd0538fSMark Fasheh 		path_root_el(path) = root_el;
454dcd0538fSMark Fasheh 	}
455dcd0538fSMark Fasheh 
456dcd0538fSMark Fasheh 	return path;
457dcd0538fSMark Fasheh }
458dcd0538fSMark Fasheh 
459dcd0538fSMark Fasheh /*
460dcd0538fSMark Fasheh  * Convenience function to journal all components in a path.
461dcd0538fSMark Fasheh  */
462dcd0538fSMark Fasheh static int ocfs2_journal_access_path(struct inode *inode, handle_t *handle,
463dcd0538fSMark Fasheh 				     struct ocfs2_path *path)
464dcd0538fSMark Fasheh {
465dcd0538fSMark Fasheh 	int i, ret = 0;
466dcd0538fSMark Fasheh 
467dcd0538fSMark Fasheh 	if (!path)
468dcd0538fSMark Fasheh 		goto out;
469dcd0538fSMark Fasheh 
470dcd0538fSMark Fasheh 	for(i = 0; i < path_num_items(path); i++) {
471dcd0538fSMark Fasheh 		ret = ocfs2_journal_access(handle, inode, path->p_node[i].bh,
472dcd0538fSMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
473dcd0538fSMark Fasheh 		if (ret < 0) {
474dcd0538fSMark Fasheh 			mlog_errno(ret);
475dcd0538fSMark Fasheh 			goto out;
476dcd0538fSMark Fasheh 		}
477dcd0538fSMark Fasheh 	}
478dcd0538fSMark Fasheh 
479dcd0538fSMark Fasheh out:
480dcd0538fSMark Fasheh 	return ret;
481dcd0538fSMark Fasheh }
482dcd0538fSMark Fasheh 
483328d5752SMark Fasheh /*
484328d5752SMark Fasheh  * Return the index of the extent record which contains cluster #v_cluster.
485328d5752SMark Fasheh  * -1 is returned if it was not found.
486328d5752SMark Fasheh  *
487328d5752SMark Fasheh  * Should work fine on interior and exterior nodes.
488328d5752SMark Fasheh  */
489328d5752SMark Fasheh int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster)
490328d5752SMark Fasheh {
491328d5752SMark Fasheh 	int ret = -1;
492328d5752SMark Fasheh 	int i;
493328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec;
494328d5752SMark Fasheh 	u32 rec_end, rec_start, clusters;
495328d5752SMark Fasheh 
496328d5752SMark Fasheh 	for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
497328d5752SMark Fasheh 		rec = &el->l_recs[i];
498328d5752SMark Fasheh 
499328d5752SMark Fasheh 		rec_start = le32_to_cpu(rec->e_cpos);
500328d5752SMark Fasheh 		clusters = ocfs2_rec_clusters(el, rec);
501328d5752SMark Fasheh 
502328d5752SMark Fasheh 		rec_end = rec_start + clusters;
503328d5752SMark Fasheh 
504328d5752SMark Fasheh 		if (v_cluster >= rec_start && v_cluster < rec_end) {
505328d5752SMark Fasheh 			ret = i;
506328d5752SMark Fasheh 			break;
507328d5752SMark Fasheh 		}
508328d5752SMark Fasheh 	}
509328d5752SMark Fasheh 
510328d5752SMark Fasheh 	return ret;
511328d5752SMark Fasheh }
512328d5752SMark Fasheh 
513dcd0538fSMark Fasheh enum ocfs2_contig_type {
514dcd0538fSMark Fasheh 	CONTIG_NONE = 0,
515dcd0538fSMark Fasheh 	CONTIG_LEFT,
516328d5752SMark Fasheh 	CONTIG_RIGHT,
517328d5752SMark Fasheh 	CONTIG_LEFTRIGHT,
518dcd0538fSMark Fasheh };
519dcd0538fSMark Fasheh 
520e48edee2SMark Fasheh 
521e48edee2SMark Fasheh /*
522e48edee2SMark Fasheh  * NOTE: ocfs2_block_extent_contig(), ocfs2_extents_adjacent() and
523e48edee2SMark Fasheh  * ocfs2_extent_contig only work properly against leaf nodes!
524e48edee2SMark Fasheh  */
525dcd0538fSMark Fasheh static int ocfs2_block_extent_contig(struct super_block *sb,
526ccd979bdSMark Fasheh 				     struct ocfs2_extent_rec *ext,
527ccd979bdSMark Fasheh 				     u64 blkno)
528ccd979bdSMark Fasheh {
529e48edee2SMark Fasheh 	u64 blk_end = le64_to_cpu(ext->e_blkno);
530e48edee2SMark Fasheh 
531e48edee2SMark Fasheh 	blk_end += ocfs2_clusters_to_blocks(sb,
532e48edee2SMark Fasheh 				    le16_to_cpu(ext->e_leaf_clusters));
533e48edee2SMark Fasheh 
534e48edee2SMark Fasheh 	return blkno == blk_end;
535ccd979bdSMark Fasheh }
536ccd979bdSMark Fasheh 
537dcd0538fSMark Fasheh static int ocfs2_extents_adjacent(struct ocfs2_extent_rec *left,
538dcd0538fSMark Fasheh 				  struct ocfs2_extent_rec *right)
539dcd0538fSMark Fasheh {
540e48edee2SMark Fasheh 	u32 left_range;
541e48edee2SMark Fasheh 
542e48edee2SMark Fasheh 	left_range = le32_to_cpu(left->e_cpos) +
543e48edee2SMark Fasheh 		le16_to_cpu(left->e_leaf_clusters);
544e48edee2SMark Fasheh 
545e48edee2SMark Fasheh 	return (left_range == le32_to_cpu(right->e_cpos));
546dcd0538fSMark Fasheh }
547dcd0538fSMark Fasheh 
548dcd0538fSMark Fasheh static enum ocfs2_contig_type
549dcd0538fSMark Fasheh 	ocfs2_extent_contig(struct inode *inode,
550dcd0538fSMark Fasheh 			    struct ocfs2_extent_rec *ext,
551dcd0538fSMark Fasheh 			    struct ocfs2_extent_rec *insert_rec)
552dcd0538fSMark Fasheh {
553dcd0538fSMark Fasheh 	u64 blkno = le64_to_cpu(insert_rec->e_blkno);
554dcd0538fSMark Fasheh 
555328d5752SMark Fasheh 	/*
556328d5752SMark Fasheh 	 * Refuse to coalesce extent records with different flag
557328d5752SMark Fasheh 	 * fields - we don't want to mix unwritten extents with user
558328d5752SMark Fasheh 	 * data.
559328d5752SMark Fasheh 	 */
560328d5752SMark Fasheh 	if (ext->e_flags != insert_rec->e_flags)
561328d5752SMark Fasheh 		return CONTIG_NONE;
562328d5752SMark Fasheh 
563dcd0538fSMark Fasheh 	if (ocfs2_extents_adjacent(ext, insert_rec) &&
564dcd0538fSMark Fasheh 	    ocfs2_block_extent_contig(inode->i_sb, ext, blkno))
565dcd0538fSMark Fasheh 			return CONTIG_RIGHT;
566dcd0538fSMark Fasheh 
567dcd0538fSMark Fasheh 	blkno = le64_to_cpu(ext->e_blkno);
568dcd0538fSMark Fasheh 	if (ocfs2_extents_adjacent(insert_rec, ext) &&
569dcd0538fSMark Fasheh 	    ocfs2_block_extent_contig(inode->i_sb, insert_rec, blkno))
570dcd0538fSMark Fasheh 		return CONTIG_LEFT;
571dcd0538fSMark Fasheh 
572dcd0538fSMark Fasheh 	return CONTIG_NONE;
573dcd0538fSMark Fasheh }
574dcd0538fSMark Fasheh 
575dcd0538fSMark Fasheh /*
576dcd0538fSMark Fasheh  * NOTE: We can have pretty much any combination of contiguousness and
577dcd0538fSMark Fasheh  * appending.
578dcd0538fSMark Fasheh  *
579dcd0538fSMark Fasheh  * The usefulness of APPEND_TAIL is more in that it lets us know that
580dcd0538fSMark Fasheh  * we'll have to update the path to that leaf.
581dcd0538fSMark Fasheh  */
582dcd0538fSMark Fasheh enum ocfs2_append_type {
583dcd0538fSMark Fasheh 	APPEND_NONE = 0,
584dcd0538fSMark Fasheh 	APPEND_TAIL,
585dcd0538fSMark Fasheh };
586dcd0538fSMark Fasheh 
587328d5752SMark Fasheh enum ocfs2_split_type {
588328d5752SMark Fasheh 	SPLIT_NONE = 0,
589328d5752SMark Fasheh 	SPLIT_LEFT,
590328d5752SMark Fasheh 	SPLIT_RIGHT,
591328d5752SMark Fasheh };
592328d5752SMark Fasheh 
593dcd0538fSMark Fasheh struct ocfs2_insert_type {
594328d5752SMark Fasheh 	enum ocfs2_split_type	ins_split;
595dcd0538fSMark Fasheh 	enum ocfs2_append_type	ins_appending;
596dcd0538fSMark Fasheh 	enum ocfs2_contig_type	ins_contig;
597dcd0538fSMark Fasheh 	int			ins_contig_index;
598dcd0538fSMark Fasheh 	int			ins_tree_depth;
599dcd0538fSMark Fasheh };
600dcd0538fSMark Fasheh 
601328d5752SMark Fasheh struct ocfs2_merge_ctxt {
602328d5752SMark Fasheh 	enum ocfs2_contig_type	c_contig_type;
603328d5752SMark Fasheh 	int			c_has_empty_extent;
604328d5752SMark Fasheh 	int			c_split_covers_rec;
605328d5752SMark Fasheh };
606328d5752SMark Fasheh 
607ccd979bdSMark Fasheh /*
608ccd979bdSMark Fasheh  * How many free extents have we got before we need more meta data?
609ccd979bdSMark Fasheh  */
610ccd979bdSMark Fasheh int ocfs2_num_free_extents(struct ocfs2_super *osb,
611ccd979bdSMark Fasheh 			   struct inode *inode,
612e7d4cb6bSTao Ma 			   struct buffer_head *root_bh,
613f56654c4STao Ma 			   enum ocfs2_extent_tree_type type,
614ea5efa15SJoel Becker 			   void *obj)
615ccd979bdSMark Fasheh {
616ccd979bdSMark Fasheh 	int retval;
617e7d4cb6bSTao Ma 	struct ocfs2_extent_list *el = NULL;
618ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
619ccd979bdSMark Fasheh 	struct buffer_head *eb_bh = NULL;
620e7d4cb6bSTao Ma 	u64 last_eb_blk = 0;
621*1c25d93aSJoel Becker 	struct ocfs2_extent_tree et;
622ccd979bdSMark Fasheh 
623ccd979bdSMark Fasheh 	mlog_entry_void();
624ccd979bdSMark Fasheh 
625*1c25d93aSJoel Becker 	ocfs2_get_extent_tree(&et, inode, root_bh, type, obj);
626*1c25d93aSJoel Becker 	el = et.et_root_el;
627*1c25d93aSJoel Becker 	last_eb_blk = ocfs2_et_get_last_eb_blk(&et);
628e7d4cb6bSTao Ma 
629e7d4cb6bSTao Ma 	if (last_eb_blk) {
630e7d4cb6bSTao Ma 		retval = ocfs2_read_block(osb, last_eb_blk,
631ccd979bdSMark Fasheh 					  &eb_bh, OCFS2_BH_CACHED, inode);
632ccd979bdSMark Fasheh 		if (retval < 0) {
633ccd979bdSMark Fasheh 			mlog_errno(retval);
634ccd979bdSMark Fasheh 			goto bail;
635ccd979bdSMark Fasheh 		}
636ccd979bdSMark Fasheh 		eb = (struct ocfs2_extent_block *) eb_bh->b_data;
637ccd979bdSMark Fasheh 		el = &eb->h_list;
638e7d4cb6bSTao Ma 	}
639ccd979bdSMark Fasheh 
640ccd979bdSMark Fasheh 	BUG_ON(el->l_tree_depth != 0);
641ccd979bdSMark Fasheh 
642ccd979bdSMark Fasheh 	retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec);
643ccd979bdSMark Fasheh bail:
644ccd979bdSMark Fasheh 	if (eb_bh)
645ccd979bdSMark Fasheh 		brelse(eb_bh);
646ccd979bdSMark Fasheh 
647*1c25d93aSJoel Becker 	ocfs2_put_extent_tree(&et);
648ccd979bdSMark Fasheh 	mlog_exit(retval);
649ccd979bdSMark Fasheh 	return retval;
650ccd979bdSMark Fasheh }
651ccd979bdSMark Fasheh 
652ccd979bdSMark Fasheh /* expects array to already be allocated
653ccd979bdSMark Fasheh  *
654ccd979bdSMark Fasheh  * sets h_signature, h_blkno, h_suballoc_bit, h_suballoc_slot, and
655ccd979bdSMark Fasheh  * l_count for you
656ccd979bdSMark Fasheh  */
657ccd979bdSMark Fasheh static int ocfs2_create_new_meta_bhs(struct ocfs2_super *osb,
6581fabe148SMark Fasheh 				     handle_t *handle,
659ccd979bdSMark Fasheh 				     struct inode *inode,
660ccd979bdSMark Fasheh 				     int wanted,
661ccd979bdSMark Fasheh 				     struct ocfs2_alloc_context *meta_ac,
662ccd979bdSMark Fasheh 				     struct buffer_head *bhs[])
663ccd979bdSMark Fasheh {
664ccd979bdSMark Fasheh 	int count, status, i;
665ccd979bdSMark Fasheh 	u16 suballoc_bit_start;
666ccd979bdSMark Fasheh 	u32 num_got;
667ccd979bdSMark Fasheh 	u64 first_blkno;
668ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
669ccd979bdSMark Fasheh 
670ccd979bdSMark Fasheh 	mlog_entry_void();
671ccd979bdSMark Fasheh 
672ccd979bdSMark Fasheh 	count = 0;
673ccd979bdSMark Fasheh 	while (count < wanted) {
674ccd979bdSMark Fasheh 		status = ocfs2_claim_metadata(osb,
675ccd979bdSMark Fasheh 					      handle,
676ccd979bdSMark Fasheh 					      meta_ac,
677ccd979bdSMark Fasheh 					      wanted - count,
678ccd979bdSMark Fasheh 					      &suballoc_bit_start,
679ccd979bdSMark Fasheh 					      &num_got,
680ccd979bdSMark Fasheh 					      &first_blkno);
681ccd979bdSMark Fasheh 		if (status < 0) {
682ccd979bdSMark Fasheh 			mlog_errno(status);
683ccd979bdSMark Fasheh 			goto bail;
684ccd979bdSMark Fasheh 		}
685ccd979bdSMark Fasheh 
686ccd979bdSMark Fasheh 		for(i = count;  i < (num_got + count); i++) {
687ccd979bdSMark Fasheh 			bhs[i] = sb_getblk(osb->sb, first_blkno);
688ccd979bdSMark Fasheh 			if (bhs[i] == NULL) {
689ccd979bdSMark Fasheh 				status = -EIO;
690ccd979bdSMark Fasheh 				mlog_errno(status);
691ccd979bdSMark Fasheh 				goto bail;
692ccd979bdSMark Fasheh 			}
693ccd979bdSMark Fasheh 			ocfs2_set_new_buffer_uptodate(inode, bhs[i]);
694ccd979bdSMark Fasheh 
695ccd979bdSMark Fasheh 			status = ocfs2_journal_access(handle, inode, bhs[i],
696ccd979bdSMark Fasheh 						      OCFS2_JOURNAL_ACCESS_CREATE);
697ccd979bdSMark Fasheh 			if (status < 0) {
698ccd979bdSMark Fasheh 				mlog_errno(status);
699ccd979bdSMark Fasheh 				goto bail;
700ccd979bdSMark Fasheh 			}
701ccd979bdSMark Fasheh 
702ccd979bdSMark Fasheh 			memset(bhs[i]->b_data, 0, osb->sb->s_blocksize);
703ccd979bdSMark Fasheh 			eb = (struct ocfs2_extent_block *) bhs[i]->b_data;
704ccd979bdSMark Fasheh 			/* Ok, setup the minimal stuff here. */
705ccd979bdSMark Fasheh 			strcpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
706ccd979bdSMark Fasheh 			eb->h_blkno = cpu_to_le64(first_blkno);
707ccd979bdSMark Fasheh 			eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
708ccd979bdSMark Fasheh 			eb->h_suballoc_slot = cpu_to_le16(osb->slot_num);
709ccd979bdSMark Fasheh 			eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start);
710ccd979bdSMark Fasheh 			eb->h_list.l_count =
711ccd979bdSMark Fasheh 				cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
712ccd979bdSMark Fasheh 
713ccd979bdSMark Fasheh 			suballoc_bit_start++;
714ccd979bdSMark Fasheh 			first_blkno++;
715ccd979bdSMark Fasheh 
716ccd979bdSMark Fasheh 			/* We'll also be dirtied by the caller, so
717ccd979bdSMark Fasheh 			 * this isn't absolutely necessary. */
718ccd979bdSMark Fasheh 			status = ocfs2_journal_dirty(handle, bhs[i]);
719ccd979bdSMark Fasheh 			if (status < 0) {
720ccd979bdSMark Fasheh 				mlog_errno(status);
721ccd979bdSMark Fasheh 				goto bail;
722ccd979bdSMark Fasheh 			}
723ccd979bdSMark Fasheh 		}
724ccd979bdSMark Fasheh 
725ccd979bdSMark Fasheh 		count += num_got;
726ccd979bdSMark Fasheh 	}
727ccd979bdSMark Fasheh 
728ccd979bdSMark Fasheh 	status = 0;
729ccd979bdSMark Fasheh bail:
730ccd979bdSMark Fasheh 	if (status < 0) {
731ccd979bdSMark Fasheh 		for(i = 0; i < wanted; i++) {
732ccd979bdSMark Fasheh 			if (bhs[i])
733ccd979bdSMark Fasheh 				brelse(bhs[i]);
734ccd979bdSMark Fasheh 			bhs[i] = NULL;
735ccd979bdSMark Fasheh 		}
736ccd979bdSMark Fasheh 	}
737ccd979bdSMark Fasheh 	mlog_exit(status);
738ccd979bdSMark Fasheh 	return status;
739ccd979bdSMark Fasheh }
740ccd979bdSMark Fasheh 
741ccd979bdSMark Fasheh /*
742dcd0538fSMark Fasheh  * Helper function for ocfs2_add_branch() and ocfs2_shift_tree_depth().
743dcd0538fSMark Fasheh  *
744dcd0538fSMark Fasheh  * Returns the sum of the rightmost extent rec logical offset and
745dcd0538fSMark Fasheh  * cluster count.
746dcd0538fSMark Fasheh  *
747dcd0538fSMark Fasheh  * ocfs2_add_branch() uses this to determine what logical cluster
748dcd0538fSMark Fasheh  * value should be populated into the leftmost new branch records.
749dcd0538fSMark Fasheh  *
750dcd0538fSMark Fasheh  * ocfs2_shift_tree_depth() uses this to determine the # clusters
751dcd0538fSMark Fasheh  * value for the new topmost tree record.
752dcd0538fSMark Fasheh  */
753dcd0538fSMark Fasheh static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list  *el)
754dcd0538fSMark Fasheh {
755dcd0538fSMark Fasheh 	int i;
756dcd0538fSMark Fasheh 
757dcd0538fSMark Fasheh 	i = le16_to_cpu(el->l_next_free_rec) - 1;
758dcd0538fSMark Fasheh 
759dcd0538fSMark Fasheh 	return le32_to_cpu(el->l_recs[i].e_cpos) +
760e48edee2SMark Fasheh 		ocfs2_rec_clusters(el, &el->l_recs[i]);
761dcd0538fSMark Fasheh }
762dcd0538fSMark Fasheh 
763dcd0538fSMark Fasheh /*
764ccd979bdSMark Fasheh  * Add an entire tree branch to our inode. eb_bh is the extent block
765ccd979bdSMark Fasheh  * to start at, if we don't want to start the branch at the dinode
766ccd979bdSMark Fasheh  * structure.
767ccd979bdSMark Fasheh  *
768ccd979bdSMark Fasheh  * last_eb_bh is required as we have to update it's next_leaf pointer
769ccd979bdSMark Fasheh  * for the new last extent block.
770ccd979bdSMark Fasheh  *
771ccd979bdSMark Fasheh  * the new branch will be 'empty' in the sense that every block will
772e48edee2SMark Fasheh  * contain a single record with cluster count == 0.
773ccd979bdSMark Fasheh  */
774ccd979bdSMark Fasheh static int ocfs2_add_branch(struct ocfs2_super *osb,
7751fabe148SMark Fasheh 			    handle_t *handle,
776ccd979bdSMark Fasheh 			    struct inode *inode,
777e7d4cb6bSTao Ma 			    struct ocfs2_extent_tree *et,
778ccd979bdSMark Fasheh 			    struct buffer_head *eb_bh,
779328d5752SMark Fasheh 			    struct buffer_head **last_eb_bh,
780ccd979bdSMark Fasheh 			    struct ocfs2_alloc_context *meta_ac)
781ccd979bdSMark Fasheh {
782ccd979bdSMark Fasheh 	int status, new_blocks, i;
783ccd979bdSMark Fasheh 	u64 next_blkno, new_last_eb_blk;
784ccd979bdSMark Fasheh 	struct buffer_head *bh;
785ccd979bdSMark Fasheh 	struct buffer_head **new_eb_bhs = NULL;
786ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
787ccd979bdSMark Fasheh 	struct ocfs2_extent_list  *eb_el;
788ccd979bdSMark Fasheh 	struct ocfs2_extent_list  *el;
789dcd0538fSMark Fasheh 	u32 new_cpos;
790ccd979bdSMark Fasheh 
791ccd979bdSMark Fasheh 	mlog_entry_void();
792ccd979bdSMark Fasheh 
793328d5752SMark Fasheh 	BUG_ON(!last_eb_bh || !*last_eb_bh);
794ccd979bdSMark Fasheh 
795ccd979bdSMark Fasheh 	if (eb_bh) {
796ccd979bdSMark Fasheh 		eb = (struct ocfs2_extent_block *) eb_bh->b_data;
797ccd979bdSMark Fasheh 		el = &eb->h_list;
798ccd979bdSMark Fasheh 	} else
799ce1d9ea6SJoel Becker 		el = et->et_root_el;
800ccd979bdSMark Fasheh 
801ccd979bdSMark Fasheh 	/* we never add a branch to a leaf. */
802ccd979bdSMark Fasheh 	BUG_ON(!el->l_tree_depth);
803ccd979bdSMark Fasheh 
804ccd979bdSMark Fasheh 	new_blocks = le16_to_cpu(el->l_tree_depth);
805ccd979bdSMark Fasheh 
806ccd979bdSMark Fasheh 	/* allocate the number of new eb blocks we need */
807ccd979bdSMark Fasheh 	new_eb_bhs = kcalloc(new_blocks, sizeof(struct buffer_head *),
808ccd979bdSMark Fasheh 			     GFP_KERNEL);
809ccd979bdSMark Fasheh 	if (!new_eb_bhs) {
810ccd979bdSMark Fasheh 		status = -ENOMEM;
811ccd979bdSMark Fasheh 		mlog_errno(status);
812ccd979bdSMark Fasheh 		goto bail;
813ccd979bdSMark Fasheh 	}
814ccd979bdSMark Fasheh 
815ccd979bdSMark Fasheh 	status = ocfs2_create_new_meta_bhs(osb, handle, inode, new_blocks,
816ccd979bdSMark Fasheh 					   meta_ac, new_eb_bhs);
817ccd979bdSMark Fasheh 	if (status < 0) {
818ccd979bdSMark Fasheh 		mlog_errno(status);
819ccd979bdSMark Fasheh 		goto bail;
820ccd979bdSMark Fasheh 	}
821ccd979bdSMark Fasheh 
822328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data;
823dcd0538fSMark Fasheh 	new_cpos = ocfs2_sum_rightmost_rec(&eb->h_list);
824dcd0538fSMark Fasheh 
825ccd979bdSMark Fasheh 	/* Note: new_eb_bhs[new_blocks - 1] is the guy which will be
826ccd979bdSMark Fasheh 	 * linked with the rest of the tree.
827ccd979bdSMark Fasheh 	 * conversly, new_eb_bhs[0] is the new bottommost leaf.
828ccd979bdSMark Fasheh 	 *
829ccd979bdSMark Fasheh 	 * when we leave the loop, new_last_eb_blk will point to the
830ccd979bdSMark Fasheh 	 * newest leaf, and next_blkno will point to the topmost extent
831ccd979bdSMark Fasheh 	 * block. */
832ccd979bdSMark Fasheh 	next_blkno = new_last_eb_blk = 0;
833ccd979bdSMark Fasheh 	for(i = 0; i < new_blocks; i++) {
834ccd979bdSMark Fasheh 		bh = new_eb_bhs[i];
835ccd979bdSMark Fasheh 		eb = (struct ocfs2_extent_block *) bh->b_data;
836ccd979bdSMark Fasheh 		if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
837ccd979bdSMark Fasheh 			OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
838ccd979bdSMark Fasheh 			status = -EIO;
839ccd979bdSMark Fasheh 			goto bail;
840ccd979bdSMark Fasheh 		}
841ccd979bdSMark Fasheh 		eb_el = &eb->h_list;
842ccd979bdSMark Fasheh 
843ccd979bdSMark Fasheh 		status = ocfs2_journal_access(handle, inode, bh,
844ccd979bdSMark Fasheh 					      OCFS2_JOURNAL_ACCESS_CREATE);
845ccd979bdSMark Fasheh 		if (status < 0) {
846ccd979bdSMark Fasheh 			mlog_errno(status);
847ccd979bdSMark Fasheh 			goto bail;
848ccd979bdSMark Fasheh 		}
849ccd979bdSMark Fasheh 
850ccd979bdSMark Fasheh 		eb->h_next_leaf_blk = 0;
851ccd979bdSMark Fasheh 		eb_el->l_tree_depth = cpu_to_le16(i);
852ccd979bdSMark Fasheh 		eb_el->l_next_free_rec = cpu_to_le16(1);
853dcd0538fSMark Fasheh 		/*
854dcd0538fSMark Fasheh 		 * This actually counts as an empty extent as
855dcd0538fSMark Fasheh 		 * c_clusters == 0
856dcd0538fSMark Fasheh 		 */
857dcd0538fSMark Fasheh 		eb_el->l_recs[0].e_cpos = cpu_to_le32(new_cpos);
858ccd979bdSMark Fasheh 		eb_el->l_recs[0].e_blkno = cpu_to_le64(next_blkno);
859e48edee2SMark Fasheh 		/*
860e48edee2SMark Fasheh 		 * eb_el isn't always an interior node, but even leaf
861e48edee2SMark Fasheh 		 * nodes want a zero'd flags and reserved field so
862e48edee2SMark Fasheh 		 * this gets the whole 32 bits regardless of use.
863e48edee2SMark Fasheh 		 */
864e48edee2SMark Fasheh 		eb_el->l_recs[0].e_int_clusters = cpu_to_le32(0);
865ccd979bdSMark Fasheh 		if (!eb_el->l_tree_depth)
866ccd979bdSMark Fasheh 			new_last_eb_blk = le64_to_cpu(eb->h_blkno);
867ccd979bdSMark Fasheh 
868ccd979bdSMark Fasheh 		status = ocfs2_journal_dirty(handle, bh);
869ccd979bdSMark Fasheh 		if (status < 0) {
870ccd979bdSMark Fasheh 			mlog_errno(status);
871ccd979bdSMark Fasheh 			goto bail;
872ccd979bdSMark Fasheh 		}
873ccd979bdSMark Fasheh 
874ccd979bdSMark Fasheh 		next_blkno = le64_to_cpu(eb->h_blkno);
875ccd979bdSMark Fasheh 	}
876ccd979bdSMark Fasheh 
877ccd979bdSMark Fasheh 	/* This is a bit hairy. We want to update up to three blocks
878ccd979bdSMark Fasheh 	 * here without leaving any of them in an inconsistent state
879ccd979bdSMark Fasheh 	 * in case of error. We don't have to worry about
880ccd979bdSMark Fasheh 	 * journal_dirty erroring as it won't unless we've aborted the
881ccd979bdSMark Fasheh 	 * handle (in which case we would never be here) so reserving
882ccd979bdSMark Fasheh 	 * the write with journal_access is all we need to do. */
883328d5752SMark Fasheh 	status = ocfs2_journal_access(handle, inode, *last_eb_bh,
884ccd979bdSMark Fasheh 				      OCFS2_JOURNAL_ACCESS_WRITE);
885ccd979bdSMark Fasheh 	if (status < 0) {
886ccd979bdSMark Fasheh 		mlog_errno(status);
887ccd979bdSMark Fasheh 		goto bail;
888ccd979bdSMark Fasheh 	}
889ce1d9ea6SJoel Becker 	status = ocfs2_journal_access(handle, inode, et->et_root_bh,
890ccd979bdSMark Fasheh 				      OCFS2_JOURNAL_ACCESS_WRITE);
891ccd979bdSMark Fasheh 	if (status < 0) {
892ccd979bdSMark Fasheh 		mlog_errno(status);
893ccd979bdSMark Fasheh 		goto bail;
894ccd979bdSMark Fasheh 	}
895ccd979bdSMark Fasheh 	if (eb_bh) {
896ccd979bdSMark Fasheh 		status = ocfs2_journal_access(handle, inode, eb_bh,
897ccd979bdSMark Fasheh 					      OCFS2_JOURNAL_ACCESS_WRITE);
898ccd979bdSMark Fasheh 		if (status < 0) {
899ccd979bdSMark Fasheh 			mlog_errno(status);
900ccd979bdSMark Fasheh 			goto bail;
901ccd979bdSMark Fasheh 		}
902ccd979bdSMark Fasheh 	}
903ccd979bdSMark Fasheh 
904ccd979bdSMark Fasheh 	/* Link the new branch into the rest of the tree (el will
905e7d4cb6bSTao Ma 	 * either be on the root_bh, or the extent block passed in. */
906ccd979bdSMark Fasheh 	i = le16_to_cpu(el->l_next_free_rec);
907ccd979bdSMark Fasheh 	el->l_recs[i].e_blkno = cpu_to_le64(next_blkno);
908dcd0538fSMark Fasheh 	el->l_recs[i].e_cpos = cpu_to_le32(new_cpos);
909e48edee2SMark Fasheh 	el->l_recs[i].e_int_clusters = 0;
910ccd979bdSMark Fasheh 	le16_add_cpu(&el->l_next_free_rec, 1);
911ccd979bdSMark Fasheh 
912ccd979bdSMark Fasheh 	/* fe needs a new last extent block pointer, as does the
913ccd979bdSMark Fasheh 	 * next_leaf on the previously last-extent-block. */
91435dc0aa3SJoel Becker 	ocfs2_et_set_last_eb_blk(et, new_last_eb_blk);
915ccd979bdSMark Fasheh 
916328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
917ccd979bdSMark Fasheh 	eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk);
918ccd979bdSMark Fasheh 
919328d5752SMark Fasheh 	status = ocfs2_journal_dirty(handle, *last_eb_bh);
920ccd979bdSMark Fasheh 	if (status < 0)
921ccd979bdSMark Fasheh 		mlog_errno(status);
922ce1d9ea6SJoel Becker 	status = ocfs2_journal_dirty(handle, et->et_root_bh);
923ccd979bdSMark Fasheh 	if (status < 0)
924ccd979bdSMark Fasheh 		mlog_errno(status);
925ccd979bdSMark Fasheh 	if (eb_bh) {
926ccd979bdSMark Fasheh 		status = ocfs2_journal_dirty(handle, eb_bh);
927ccd979bdSMark Fasheh 		if (status < 0)
928ccd979bdSMark Fasheh 			mlog_errno(status);
929ccd979bdSMark Fasheh 	}
930ccd979bdSMark Fasheh 
931328d5752SMark Fasheh 	/*
932328d5752SMark Fasheh 	 * Some callers want to track the rightmost leaf so pass it
933328d5752SMark Fasheh 	 * back here.
934328d5752SMark Fasheh 	 */
935328d5752SMark Fasheh 	brelse(*last_eb_bh);
936328d5752SMark Fasheh 	get_bh(new_eb_bhs[0]);
937328d5752SMark Fasheh 	*last_eb_bh = new_eb_bhs[0];
938328d5752SMark Fasheh 
939ccd979bdSMark Fasheh 	status = 0;
940ccd979bdSMark Fasheh bail:
941ccd979bdSMark Fasheh 	if (new_eb_bhs) {
942ccd979bdSMark Fasheh 		for (i = 0; i < new_blocks; i++)
943ccd979bdSMark Fasheh 			if (new_eb_bhs[i])
944ccd979bdSMark Fasheh 				brelse(new_eb_bhs[i]);
945ccd979bdSMark Fasheh 		kfree(new_eb_bhs);
946ccd979bdSMark Fasheh 	}
947ccd979bdSMark Fasheh 
948ccd979bdSMark Fasheh 	mlog_exit(status);
949ccd979bdSMark Fasheh 	return status;
950ccd979bdSMark Fasheh }
951ccd979bdSMark Fasheh 
952ccd979bdSMark Fasheh /*
953ccd979bdSMark Fasheh  * adds another level to the allocation tree.
954ccd979bdSMark Fasheh  * returns back the new extent block so you can add a branch to it
955ccd979bdSMark Fasheh  * after this call.
956ccd979bdSMark Fasheh  */
957ccd979bdSMark Fasheh static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
9581fabe148SMark Fasheh 				  handle_t *handle,
959ccd979bdSMark Fasheh 				  struct inode *inode,
960e7d4cb6bSTao Ma 				  struct ocfs2_extent_tree *et,
961ccd979bdSMark Fasheh 				  struct ocfs2_alloc_context *meta_ac,
962ccd979bdSMark Fasheh 				  struct buffer_head **ret_new_eb_bh)
963ccd979bdSMark Fasheh {
964ccd979bdSMark Fasheh 	int status, i;
965dcd0538fSMark Fasheh 	u32 new_clusters;
966ccd979bdSMark Fasheh 	struct buffer_head *new_eb_bh = NULL;
967ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
968e7d4cb6bSTao Ma 	struct ocfs2_extent_list  *root_el;
969ccd979bdSMark Fasheh 	struct ocfs2_extent_list  *eb_el;
970ccd979bdSMark Fasheh 
971ccd979bdSMark Fasheh 	mlog_entry_void();
972ccd979bdSMark Fasheh 
973ccd979bdSMark Fasheh 	status = ocfs2_create_new_meta_bhs(osb, handle, inode, 1, meta_ac,
974ccd979bdSMark Fasheh 					   &new_eb_bh);
975ccd979bdSMark Fasheh 	if (status < 0) {
976ccd979bdSMark Fasheh 		mlog_errno(status);
977ccd979bdSMark Fasheh 		goto bail;
978ccd979bdSMark Fasheh 	}
979ccd979bdSMark Fasheh 
980ccd979bdSMark Fasheh 	eb = (struct ocfs2_extent_block *) new_eb_bh->b_data;
981ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
982ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
983ccd979bdSMark Fasheh 		status = -EIO;
984ccd979bdSMark Fasheh 		goto bail;
985ccd979bdSMark Fasheh 	}
986ccd979bdSMark Fasheh 
987ccd979bdSMark Fasheh 	eb_el = &eb->h_list;
988ce1d9ea6SJoel Becker 	root_el = et->et_root_el;
989ccd979bdSMark Fasheh 
990ccd979bdSMark Fasheh 	status = ocfs2_journal_access(handle, inode, new_eb_bh,
991ccd979bdSMark Fasheh 				      OCFS2_JOURNAL_ACCESS_CREATE);
992ccd979bdSMark Fasheh 	if (status < 0) {
993ccd979bdSMark Fasheh 		mlog_errno(status);
994ccd979bdSMark Fasheh 		goto bail;
995ccd979bdSMark Fasheh 	}
996ccd979bdSMark Fasheh 
997e7d4cb6bSTao Ma 	/* copy the root extent list data into the new extent block */
998e7d4cb6bSTao Ma 	eb_el->l_tree_depth = root_el->l_tree_depth;
999e7d4cb6bSTao Ma 	eb_el->l_next_free_rec = root_el->l_next_free_rec;
1000e7d4cb6bSTao Ma 	for (i = 0; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1001e7d4cb6bSTao Ma 		eb_el->l_recs[i] = root_el->l_recs[i];
1002ccd979bdSMark Fasheh 
1003ccd979bdSMark Fasheh 	status = ocfs2_journal_dirty(handle, new_eb_bh);
1004ccd979bdSMark Fasheh 	if (status < 0) {
1005ccd979bdSMark Fasheh 		mlog_errno(status);
1006ccd979bdSMark Fasheh 		goto bail;
1007ccd979bdSMark Fasheh 	}
1008ccd979bdSMark Fasheh 
1009ce1d9ea6SJoel Becker 	status = ocfs2_journal_access(handle, inode, et->et_root_bh,
1010ccd979bdSMark Fasheh 				      OCFS2_JOURNAL_ACCESS_WRITE);
1011ccd979bdSMark Fasheh 	if (status < 0) {
1012ccd979bdSMark Fasheh 		mlog_errno(status);
1013ccd979bdSMark Fasheh 		goto bail;
1014ccd979bdSMark Fasheh 	}
1015ccd979bdSMark Fasheh 
1016dcd0538fSMark Fasheh 	new_clusters = ocfs2_sum_rightmost_rec(eb_el);
1017dcd0538fSMark Fasheh 
1018e7d4cb6bSTao Ma 	/* update root_bh now */
1019e7d4cb6bSTao Ma 	le16_add_cpu(&root_el->l_tree_depth, 1);
1020e7d4cb6bSTao Ma 	root_el->l_recs[0].e_cpos = 0;
1021e7d4cb6bSTao Ma 	root_el->l_recs[0].e_blkno = eb->h_blkno;
1022e7d4cb6bSTao Ma 	root_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters);
1023e7d4cb6bSTao Ma 	for (i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1024e7d4cb6bSTao Ma 		memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
1025e7d4cb6bSTao Ma 	root_el->l_next_free_rec = cpu_to_le16(1);
1026ccd979bdSMark Fasheh 
1027ccd979bdSMark Fasheh 	/* If this is our 1st tree depth shift, then last_eb_blk
1028ccd979bdSMark Fasheh 	 * becomes the allocated extent block */
1029e7d4cb6bSTao Ma 	if (root_el->l_tree_depth == cpu_to_le16(1))
103035dc0aa3SJoel Becker 		ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
1031ccd979bdSMark Fasheh 
1032ce1d9ea6SJoel Becker 	status = ocfs2_journal_dirty(handle, et->et_root_bh);
1033ccd979bdSMark Fasheh 	if (status < 0) {
1034ccd979bdSMark Fasheh 		mlog_errno(status);
1035ccd979bdSMark Fasheh 		goto bail;
1036ccd979bdSMark Fasheh 	}
1037ccd979bdSMark Fasheh 
1038ccd979bdSMark Fasheh 	*ret_new_eb_bh = new_eb_bh;
1039ccd979bdSMark Fasheh 	new_eb_bh = NULL;
1040ccd979bdSMark Fasheh 	status = 0;
1041ccd979bdSMark Fasheh bail:
1042ccd979bdSMark Fasheh 	if (new_eb_bh)
1043ccd979bdSMark Fasheh 		brelse(new_eb_bh);
1044ccd979bdSMark Fasheh 
1045ccd979bdSMark Fasheh 	mlog_exit(status);
1046ccd979bdSMark Fasheh 	return status;
1047ccd979bdSMark Fasheh }
1048ccd979bdSMark Fasheh 
1049ccd979bdSMark Fasheh /*
1050ccd979bdSMark Fasheh  * Should only be called when there is no space left in any of the
1051ccd979bdSMark Fasheh  * leaf nodes. What we want to do is find the lowest tree depth
1052ccd979bdSMark Fasheh  * non-leaf extent block with room for new records. There are three
1053ccd979bdSMark Fasheh  * valid results of this search:
1054ccd979bdSMark Fasheh  *
1055ccd979bdSMark Fasheh  * 1) a lowest extent block is found, then we pass it back in
1056ccd979bdSMark Fasheh  *    *lowest_eb_bh and return '0'
1057ccd979bdSMark Fasheh  *
1058e7d4cb6bSTao Ma  * 2) the search fails to find anything, but the root_el has room. We
1059ccd979bdSMark Fasheh  *    pass NULL back in *lowest_eb_bh, but still return '0'
1060ccd979bdSMark Fasheh  *
1061e7d4cb6bSTao Ma  * 3) the search fails to find anything AND the root_el is full, in
1062ccd979bdSMark Fasheh  *    which case we return > 0
1063ccd979bdSMark Fasheh  *
1064ccd979bdSMark Fasheh  * return status < 0 indicates an error.
1065ccd979bdSMark Fasheh  */
1066ccd979bdSMark Fasheh static int ocfs2_find_branch_target(struct ocfs2_super *osb,
1067ccd979bdSMark Fasheh 				    struct inode *inode,
1068e7d4cb6bSTao Ma 				    struct ocfs2_extent_tree *et,
1069ccd979bdSMark Fasheh 				    struct buffer_head **target_bh)
1070ccd979bdSMark Fasheh {
1071ccd979bdSMark Fasheh 	int status = 0, i;
1072ccd979bdSMark Fasheh 	u64 blkno;
1073ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
1074ccd979bdSMark Fasheh 	struct ocfs2_extent_list  *el;
1075ccd979bdSMark Fasheh 	struct buffer_head *bh = NULL;
1076ccd979bdSMark Fasheh 	struct buffer_head *lowest_bh = NULL;
1077ccd979bdSMark Fasheh 
1078ccd979bdSMark Fasheh 	mlog_entry_void();
1079ccd979bdSMark Fasheh 
1080ccd979bdSMark Fasheh 	*target_bh = NULL;
1081ccd979bdSMark Fasheh 
1082ce1d9ea6SJoel Becker 	el = et->et_root_el;
1083ccd979bdSMark Fasheh 
1084ccd979bdSMark Fasheh 	while(le16_to_cpu(el->l_tree_depth) > 1) {
1085ccd979bdSMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) == 0) {
1086b0697053SMark Fasheh 			ocfs2_error(inode->i_sb, "Dinode %llu has empty "
1087ccd979bdSMark Fasheh 				    "extent list (next_free_rec == 0)",
1088b0697053SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno);
1089ccd979bdSMark Fasheh 			status = -EIO;
1090ccd979bdSMark Fasheh 			goto bail;
1091ccd979bdSMark Fasheh 		}
1092ccd979bdSMark Fasheh 		i = le16_to_cpu(el->l_next_free_rec) - 1;
1093ccd979bdSMark Fasheh 		blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1094ccd979bdSMark Fasheh 		if (!blkno) {
1095b0697053SMark Fasheh 			ocfs2_error(inode->i_sb, "Dinode %llu has extent "
1096ccd979bdSMark Fasheh 				    "list where extent # %d has no physical "
1097ccd979bdSMark Fasheh 				    "block start",
1098b0697053SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno, i);
1099ccd979bdSMark Fasheh 			status = -EIO;
1100ccd979bdSMark Fasheh 			goto bail;
1101ccd979bdSMark Fasheh 		}
1102ccd979bdSMark Fasheh 
1103ccd979bdSMark Fasheh 		if (bh) {
1104ccd979bdSMark Fasheh 			brelse(bh);
1105ccd979bdSMark Fasheh 			bh = NULL;
1106ccd979bdSMark Fasheh 		}
1107ccd979bdSMark Fasheh 
1108ccd979bdSMark Fasheh 		status = ocfs2_read_block(osb, blkno, &bh, OCFS2_BH_CACHED,
1109ccd979bdSMark Fasheh 					  inode);
1110ccd979bdSMark Fasheh 		if (status < 0) {
1111ccd979bdSMark Fasheh 			mlog_errno(status);
1112ccd979bdSMark Fasheh 			goto bail;
1113ccd979bdSMark Fasheh 		}
1114ccd979bdSMark Fasheh 
1115ccd979bdSMark Fasheh 		eb = (struct ocfs2_extent_block *) bh->b_data;
1116ccd979bdSMark Fasheh 		if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
1117ccd979bdSMark Fasheh 			OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
1118ccd979bdSMark Fasheh 			status = -EIO;
1119ccd979bdSMark Fasheh 			goto bail;
1120ccd979bdSMark Fasheh 		}
1121ccd979bdSMark Fasheh 		el = &eb->h_list;
1122ccd979bdSMark Fasheh 
1123ccd979bdSMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) <
1124ccd979bdSMark Fasheh 		    le16_to_cpu(el->l_count)) {
1125ccd979bdSMark Fasheh 			if (lowest_bh)
1126ccd979bdSMark Fasheh 				brelse(lowest_bh);
1127ccd979bdSMark Fasheh 			lowest_bh = bh;
1128ccd979bdSMark Fasheh 			get_bh(lowest_bh);
1129ccd979bdSMark Fasheh 		}
1130ccd979bdSMark Fasheh 	}
1131ccd979bdSMark Fasheh 
1132ccd979bdSMark Fasheh 	/* If we didn't find one and the fe doesn't have any room,
1133ccd979bdSMark Fasheh 	 * then return '1' */
1134ce1d9ea6SJoel Becker 	el = et->et_root_el;
1135e7d4cb6bSTao Ma 	if (!lowest_bh && (el->l_next_free_rec == el->l_count))
1136ccd979bdSMark Fasheh 		status = 1;
1137ccd979bdSMark Fasheh 
1138ccd979bdSMark Fasheh 	*target_bh = lowest_bh;
1139ccd979bdSMark Fasheh bail:
1140ccd979bdSMark Fasheh 	if (bh)
1141ccd979bdSMark Fasheh 		brelse(bh);
1142ccd979bdSMark Fasheh 
1143ccd979bdSMark Fasheh 	mlog_exit(status);
1144ccd979bdSMark Fasheh 	return status;
1145ccd979bdSMark Fasheh }
1146ccd979bdSMark Fasheh 
1147e48edee2SMark Fasheh /*
1148c3afcbb3SMark Fasheh  * Grow a b-tree so that it has more records.
1149c3afcbb3SMark Fasheh  *
1150c3afcbb3SMark Fasheh  * We might shift the tree depth in which case existing paths should
1151c3afcbb3SMark Fasheh  * be considered invalid.
1152c3afcbb3SMark Fasheh  *
1153c3afcbb3SMark Fasheh  * Tree depth after the grow is returned via *final_depth.
1154328d5752SMark Fasheh  *
1155328d5752SMark Fasheh  * *last_eb_bh will be updated by ocfs2_add_branch().
1156c3afcbb3SMark Fasheh  */
1157c3afcbb3SMark Fasheh static int ocfs2_grow_tree(struct inode *inode, handle_t *handle,
1158e7d4cb6bSTao Ma 			   struct ocfs2_extent_tree *et, int *final_depth,
1159328d5752SMark Fasheh 			   struct buffer_head **last_eb_bh,
1160c3afcbb3SMark Fasheh 			   struct ocfs2_alloc_context *meta_ac)
1161c3afcbb3SMark Fasheh {
1162c3afcbb3SMark Fasheh 	int ret, shift;
1163ce1d9ea6SJoel Becker 	struct ocfs2_extent_list *el = et->et_root_el;
1164e7d4cb6bSTao Ma 	int depth = le16_to_cpu(el->l_tree_depth);
1165c3afcbb3SMark Fasheh 	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1166c3afcbb3SMark Fasheh 	struct buffer_head *bh = NULL;
1167c3afcbb3SMark Fasheh 
1168c3afcbb3SMark Fasheh 	BUG_ON(meta_ac == NULL);
1169c3afcbb3SMark Fasheh 
1170e7d4cb6bSTao Ma 	shift = ocfs2_find_branch_target(osb, inode, et, &bh);
1171c3afcbb3SMark Fasheh 	if (shift < 0) {
1172c3afcbb3SMark Fasheh 		ret = shift;
1173c3afcbb3SMark Fasheh 		mlog_errno(ret);
1174c3afcbb3SMark Fasheh 		goto out;
1175c3afcbb3SMark Fasheh 	}
1176c3afcbb3SMark Fasheh 
1177c3afcbb3SMark Fasheh 	/* We traveled all the way to the bottom of the allocation tree
1178c3afcbb3SMark Fasheh 	 * and didn't find room for any more extents - we need to add
1179c3afcbb3SMark Fasheh 	 * another tree level */
1180c3afcbb3SMark Fasheh 	if (shift) {
1181c3afcbb3SMark Fasheh 		BUG_ON(bh);
1182c3afcbb3SMark Fasheh 		mlog(0, "need to shift tree depth (current = %d)\n", depth);
1183c3afcbb3SMark Fasheh 
1184c3afcbb3SMark Fasheh 		/* ocfs2_shift_tree_depth will return us a buffer with
1185c3afcbb3SMark Fasheh 		 * the new extent block (so we can pass that to
1186c3afcbb3SMark Fasheh 		 * ocfs2_add_branch). */
1187e7d4cb6bSTao Ma 		ret = ocfs2_shift_tree_depth(osb, handle, inode, et,
1188c3afcbb3SMark Fasheh 					     meta_ac, &bh);
1189c3afcbb3SMark Fasheh 		if (ret < 0) {
1190c3afcbb3SMark Fasheh 			mlog_errno(ret);
1191c3afcbb3SMark Fasheh 			goto out;
1192c3afcbb3SMark Fasheh 		}
1193c3afcbb3SMark Fasheh 		depth++;
1194328d5752SMark Fasheh 		if (depth == 1) {
1195328d5752SMark Fasheh 			/*
1196328d5752SMark Fasheh 			 * Special case: we have room now if we shifted from
1197328d5752SMark Fasheh 			 * tree_depth 0, so no more work needs to be done.
1198328d5752SMark Fasheh 			 *
1199328d5752SMark Fasheh 			 * We won't be calling add_branch, so pass
1200328d5752SMark Fasheh 			 * back *last_eb_bh as the new leaf. At depth
1201328d5752SMark Fasheh 			 * zero, it should always be null so there's
1202328d5752SMark Fasheh 			 * no reason to brelse.
1203328d5752SMark Fasheh 			 */
1204328d5752SMark Fasheh 			BUG_ON(*last_eb_bh);
1205328d5752SMark Fasheh 			get_bh(bh);
1206328d5752SMark Fasheh 			*last_eb_bh = bh;
1207c3afcbb3SMark Fasheh 			goto out;
1208c3afcbb3SMark Fasheh 		}
1209328d5752SMark Fasheh 	}
1210c3afcbb3SMark Fasheh 
1211c3afcbb3SMark Fasheh 	/* call ocfs2_add_branch to add the final part of the tree with
1212c3afcbb3SMark Fasheh 	 * the new data. */
1213c3afcbb3SMark Fasheh 	mlog(0, "add branch. bh = %p\n", bh);
1214e7d4cb6bSTao Ma 	ret = ocfs2_add_branch(osb, handle, inode, et, bh, last_eb_bh,
1215c3afcbb3SMark Fasheh 			       meta_ac);
1216c3afcbb3SMark Fasheh 	if (ret < 0) {
1217c3afcbb3SMark Fasheh 		mlog_errno(ret);
1218c3afcbb3SMark Fasheh 		goto out;
1219c3afcbb3SMark Fasheh 	}
1220c3afcbb3SMark Fasheh 
1221c3afcbb3SMark Fasheh out:
1222c3afcbb3SMark Fasheh 	if (final_depth)
1223c3afcbb3SMark Fasheh 		*final_depth = depth;
1224c3afcbb3SMark Fasheh 	brelse(bh);
1225c3afcbb3SMark Fasheh 	return ret;
1226c3afcbb3SMark Fasheh }
1227c3afcbb3SMark Fasheh 
1228c3afcbb3SMark Fasheh /*
1229dcd0538fSMark Fasheh  * This function will discard the rightmost extent record.
1230dcd0538fSMark Fasheh  */
1231dcd0538fSMark Fasheh static void ocfs2_shift_records_right(struct ocfs2_extent_list *el)
1232dcd0538fSMark Fasheh {
1233dcd0538fSMark Fasheh 	int next_free = le16_to_cpu(el->l_next_free_rec);
1234dcd0538fSMark Fasheh 	int count = le16_to_cpu(el->l_count);
1235dcd0538fSMark Fasheh 	unsigned int num_bytes;
1236dcd0538fSMark Fasheh 
1237dcd0538fSMark Fasheh 	BUG_ON(!next_free);
1238dcd0538fSMark Fasheh 	/* This will cause us to go off the end of our extent list. */
1239dcd0538fSMark Fasheh 	BUG_ON(next_free >= count);
1240dcd0538fSMark Fasheh 
1241dcd0538fSMark Fasheh 	num_bytes = sizeof(struct ocfs2_extent_rec) * next_free;
1242dcd0538fSMark Fasheh 
1243dcd0538fSMark Fasheh 	memmove(&el->l_recs[1], &el->l_recs[0], num_bytes);
1244dcd0538fSMark Fasheh }
1245dcd0538fSMark Fasheh 
1246dcd0538fSMark Fasheh static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el,
1247dcd0538fSMark Fasheh 			      struct ocfs2_extent_rec *insert_rec)
1248dcd0538fSMark Fasheh {
1249dcd0538fSMark Fasheh 	int i, insert_index, next_free, has_empty, num_bytes;
1250dcd0538fSMark Fasheh 	u32 insert_cpos = le32_to_cpu(insert_rec->e_cpos);
1251dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *rec;
1252dcd0538fSMark Fasheh 
1253dcd0538fSMark Fasheh 	next_free = le16_to_cpu(el->l_next_free_rec);
1254dcd0538fSMark Fasheh 	has_empty = ocfs2_is_empty_extent(&el->l_recs[0]);
1255dcd0538fSMark Fasheh 
1256dcd0538fSMark Fasheh 	BUG_ON(!next_free);
1257dcd0538fSMark Fasheh 
1258dcd0538fSMark Fasheh 	/* The tree code before us didn't allow enough room in the leaf. */
1259b1f3550fSJulia Lawall 	BUG_ON(el->l_next_free_rec == el->l_count && !has_empty);
1260dcd0538fSMark Fasheh 
1261dcd0538fSMark Fasheh 	/*
1262dcd0538fSMark Fasheh 	 * The easiest way to approach this is to just remove the
1263dcd0538fSMark Fasheh 	 * empty extent and temporarily decrement next_free.
1264dcd0538fSMark Fasheh 	 */
1265dcd0538fSMark Fasheh 	if (has_empty) {
1266dcd0538fSMark Fasheh 		/*
1267dcd0538fSMark Fasheh 		 * If next_free was 1 (only an empty extent), this
1268dcd0538fSMark Fasheh 		 * loop won't execute, which is fine. We still want
1269dcd0538fSMark Fasheh 		 * the decrement above to happen.
1270dcd0538fSMark Fasheh 		 */
1271dcd0538fSMark Fasheh 		for(i = 0; i < (next_free - 1); i++)
1272dcd0538fSMark Fasheh 			el->l_recs[i] = el->l_recs[i+1];
1273dcd0538fSMark Fasheh 
1274dcd0538fSMark Fasheh 		next_free--;
1275dcd0538fSMark Fasheh 	}
1276dcd0538fSMark Fasheh 
1277dcd0538fSMark Fasheh 	/*
1278dcd0538fSMark Fasheh 	 * Figure out what the new record index should be.
1279dcd0538fSMark Fasheh 	 */
1280dcd0538fSMark Fasheh 	for(i = 0; i < next_free; i++) {
1281dcd0538fSMark Fasheh 		rec = &el->l_recs[i];
1282dcd0538fSMark Fasheh 
1283dcd0538fSMark Fasheh 		if (insert_cpos < le32_to_cpu(rec->e_cpos))
1284dcd0538fSMark Fasheh 			break;
1285dcd0538fSMark Fasheh 	}
1286dcd0538fSMark Fasheh 	insert_index = i;
1287dcd0538fSMark Fasheh 
1288dcd0538fSMark Fasheh 	mlog(0, "ins %u: index %d, has_empty %d, next_free %d, count %d\n",
1289dcd0538fSMark Fasheh 	     insert_cpos, insert_index, has_empty, next_free, le16_to_cpu(el->l_count));
1290dcd0538fSMark Fasheh 
1291dcd0538fSMark Fasheh 	BUG_ON(insert_index < 0);
1292dcd0538fSMark Fasheh 	BUG_ON(insert_index >= le16_to_cpu(el->l_count));
1293dcd0538fSMark Fasheh 	BUG_ON(insert_index > next_free);
1294dcd0538fSMark Fasheh 
1295dcd0538fSMark Fasheh 	/*
1296dcd0538fSMark Fasheh 	 * No need to memmove if we're just adding to the tail.
1297dcd0538fSMark Fasheh 	 */
1298dcd0538fSMark Fasheh 	if (insert_index != next_free) {
1299dcd0538fSMark Fasheh 		BUG_ON(next_free >= le16_to_cpu(el->l_count));
1300dcd0538fSMark Fasheh 
1301dcd0538fSMark Fasheh 		num_bytes = next_free - insert_index;
1302dcd0538fSMark Fasheh 		num_bytes *= sizeof(struct ocfs2_extent_rec);
1303dcd0538fSMark Fasheh 		memmove(&el->l_recs[insert_index + 1],
1304dcd0538fSMark Fasheh 			&el->l_recs[insert_index],
1305dcd0538fSMark Fasheh 			num_bytes);
1306dcd0538fSMark Fasheh 	}
1307dcd0538fSMark Fasheh 
1308dcd0538fSMark Fasheh 	/*
1309dcd0538fSMark Fasheh 	 * Either we had an empty extent, and need to re-increment or
1310dcd0538fSMark Fasheh 	 * there was no empty extent on a non full rightmost leaf node,
1311dcd0538fSMark Fasheh 	 * in which case we still need to increment.
1312dcd0538fSMark Fasheh 	 */
1313dcd0538fSMark Fasheh 	next_free++;
1314dcd0538fSMark Fasheh 	el->l_next_free_rec = cpu_to_le16(next_free);
1315dcd0538fSMark Fasheh 	/*
1316dcd0538fSMark Fasheh 	 * Make sure none of the math above just messed up our tree.
1317dcd0538fSMark Fasheh 	 */
1318dcd0538fSMark Fasheh 	BUG_ON(le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count));
1319dcd0538fSMark Fasheh 
1320dcd0538fSMark Fasheh 	el->l_recs[insert_index] = *insert_rec;
1321dcd0538fSMark Fasheh 
1322dcd0538fSMark Fasheh }
1323dcd0538fSMark Fasheh 
1324328d5752SMark Fasheh static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el)
1325328d5752SMark Fasheh {
1326328d5752SMark Fasheh 	int size, num_recs = le16_to_cpu(el->l_next_free_rec);
1327328d5752SMark Fasheh 
1328328d5752SMark Fasheh 	BUG_ON(num_recs == 0);
1329328d5752SMark Fasheh 
1330328d5752SMark Fasheh 	if (ocfs2_is_empty_extent(&el->l_recs[0])) {
1331328d5752SMark Fasheh 		num_recs--;
1332328d5752SMark Fasheh 		size = num_recs * sizeof(struct ocfs2_extent_rec);
1333328d5752SMark Fasheh 		memmove(&el->l_recs[0], &el->l_recs[1], size);
1334328d5752SMark Fasheh 		memset(&el->l_recs[num_recs], 0,
1335328d5752SMark Fasheh 		       sizeof(struct ocfs2_extent_rec));
1336328d5752SMark Fasheh 		el->l_next_free_rec = cpu_to_le16(num_recs);
1337328d5752SMark Fasheh 	}
1338328d5752SMark Fasheh }
1339328d5752SMark Fasheh 
1340dcd0538fSMark Fasheh /*
1341dcd0538fSMark Fasheh  * Create an empty extent record .
1342dcd0538fSMark Fasheh  *
1343dcd0538fSMark Fasheh  * l_next_free_rec may be updated.
1344dcd0538fSMark Fasheh  *
1345dcd0538fSMark Fasheh  * If an empty extent already exists do nothing.
1346dcd0538fSMark Fasheh  */
1347dcd0538fSMark Fasheh static void ocfs2_create_empty_extent(struct ocfs2_extent_list *el)
1348dcd0538fSMark Fasheh {
1349dcd0538fSMark Fasheh 	int next_free = le16_to_cpu(el->l_next_free_rec);
1350dcd0538fSMark Fasheh 
1351e48edee2SMark Fasheh 	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
1352e48edee2SMark Fasheh 
1353dcd0538fSMark Fasheh 	if (next_free == 0)
1354dcd0538fSMark Fasheh 		goto set_and_inc;
1355dcd0538fSMark Fasheh 
1356dcd0538fSMark Fasheh 	if (ocfs2_is_empty_extent(&el->l_recs[0]))
1357dcd0538fSMark Fasheh 		return;
1358dcd0538fSMark Fasheh 
1359dcd0538fSMark Fasheh 	mlog_bug_on_msg(el->l_count == el->l_next_free_rec,
1360dcd0538fSMark Fasheh 			"Asked to create an empty extent in a full list:\n"
1361dcd0538fSMark Fasheh 			"count = %u, tree depth = %u",
1362dcd0538fSMark Fasheh 			le16_to_cpu(el->l_count),
1363dcd0538fSMark Fasheh 			le16_to_cpu(el->l_tree_depth));
1364dcd0538fSMark Fasheh 
1365dcd0538fSMark Fasheh 	ocfs2_shift_records_right(el);
1366dcd0538fSMark Fasheh 
1367dcd0538fSMark Fasheh set_and_inc:
1368dcd0538fSMark Fasheh 	le16_add_cpu(&el->l_next_free_rec, 1);
1369dcd0538fSMark Fasheh 	memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
1370dcd0538fSMark Fasheh }
1371dcd0538fSMark Fasheh 
1372dcd0538fSMark Fasheh /*
1373dcd0538fSMark Fasheh  * For a rotation which involves two leaf nodes, the "root node" is
1374dcd0538fSMark Fasheh  * the lowest level tree node which contains a path to both leafs. This
1375dcd0538fSMark Fasheh  * resulting set of information can be used to form a complete "subtree"
1376dcd0538fSMark Fasheh  *
1377dcd0538fSMark Fasheh  * This function is passed two full paths from the dinode down to a
1378dcd0538fSMark Fasheh  * pair of adjacent leaves. It's task is to figure out which path
1379dcd0538fSMark Fasheh  * index contains the subtree root - this can be the root index itself
1380dcd0538fSMark Fasheh  * in a worst-case rotation.
1381dcd0538fSMark Fasheh  *
1382dcd0538fSMark Fasheh  * The array index of the subtree root is passed back.
1383dcd0538fSMark Fasheh  */
1384dcd0538fSMark Fasheh static int ocfs2_find_subtree_root(struct inode *inode,
1385dcd0538fSMark Fasheh 				   struct ocfs2_path *left,
1386dcd0538fSMark Fasheh 				   struct ocfs2_path *right)
1387dcd0538fSMark Fasheh {
1388dcd0538fSMark Fasheh 	int i = 0;
1389dcd0538fSMark Fasheh 
1390dcd0538fSMark Fasheh 	/*
1391dcd0538fSMark Fasheh 	 * Check that the caller passed in two paths from the same tree.
1392dcd0538fSMark Fasheh 	 */
1393dcd0538fSMark Fasheh 	BUG_ON(path_root_bh(left) != path_root_bh(right));
1394dcd0538fSMark Fasheh 
1395dcd0538fSMark Fasheh 	do {
1396dcd0538fSMark Fasheh 		i++;
1397dcd0538fSMark Fasheh 
1398dcd0538fSMark Fasheh 		/*
1399dcd0538fSMark Fasheh 		 * The caller didn't pass two adjacent paths.
1400dcd0538fSMark Fasheh 		 */
1401dcd0538fSMark Fasheh 		mlog_bug_on_msg(i > left->p_tree_depth,
1402dcd0538fSMark Fasheh 				"Inode %lu, left depth %u, right depth %u\n"
1403dcd0538fSMark Fasheh 				"left leaf blk %llu, right leaf blk %llu\n",
1404dcd0538fSMark Fasheh 				inode->i_ino, left->p_tree_depth,
1405dcd0538fSMark Fasheh 				right->p_tree_depth,
1406dcd0538fSMark Fasheh 				(unsigned long long)path_leaf_bh(left)->b_blocknr,
1407dcd0538fSMark Fasheh 				(unsigned long long)path_leaf_bh(right)->b_blocknr);
1408dcd0538fSMark Fasheh 	} while (left->p_node[i].bh->b_blocknr ==
1409dcd0538fSMark Fasheh 		 right->p_node[i].bh->b_blocknr);
1410dcd0538fSMark Fasheh 
1411dcd0538fSMark Fasheh 	return i - 1;
1412dcd0538fSMark Fasheh }
1413dcd0538fSMark Fasheh 
1414dcd0538fSMark Fasheh typedef void (path_insert_t)(void *, struct buffer_head *);
1415dcd0538fSMark Fasheh 
1416dcd0538fSMark Fasheh /*
1417dcd0538fSMark Fasheh  * Traverse a btree path in search of cpos, starting at root_el.
1418dcd0538fSMark Fasheh  *
1419dcd0538fSMark Fasheh  * This code can be called with a cpos larger than the tree, in which
1420dcd0538fSMark Fasheh  * case it will return the rightmost path.
1421dcd0538fSMark Fasheh  */
1422dcd0538fSMark Fasheh static int __ocfs2_find_path(struct inode *inode,
1423dcd0538fSMark Fasheh 			     struct ocfs2_extent_list *root_el, u32 cpos,
1424dcd0538fSMark Fasheh 			     path_insert_t *func, void *data)
1425dcd0538fSMark Fasheh {
1426dcd0538fSMark Fasheh 	int i, ret = 0;
1427dcd0538fSMark Fasheh 	u32 range;
1428dcd0538fSMark Fasheh 	u64 blkno;
1429dcd0538fSMark Fasheh 	struct buffer_head *bh = NULL;
1430dcd0538fSMark Fasheh 	struct ocfs2_extent_block *eb;
1431dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el;
1432dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *rec;
1433dcd0538fSMark Fasheh 	struct ocfs2_inode_info *oi = OCFS2_I(inode);
1434dcd0538fSMark Fasheh 
1435dcd0538fSMark Fasheh 	el = root_el;
1436dcd0538fSMark Fasheh 	while (el->l_tree_depth) {
1437dcd0538fSMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) == 0) {
1438dcd0538fSMark Fasheh 			ocfs2_error(inode->i_sb,
1439dcd0538fSMark Fasheh 				    "Inode %llu has empty extent list at "
1440dcd0538fSMark Fasheh 				    "depth %u\n",
1441dcd0538fSMark Fasheh 				    (unsigned long long)oi->ip_blkno,
1442dcd0538fSMark Fasheh 				    le16_to_cpu(el->l_tree_depth));
1443dcd0538fSMark Fasheh 			ret = -EROFS;
1444dcd0538fSMark Fasheh 			goto out;
1445dcd0538fSMark Fasheh 
1446dcd0538fSMark Fasheh 		}
1447dcd0538fSMark Fasheh 
1448dcd0538fSMark Fasheh 		for(i = 0; i < le16_to_cpu(el->l_next_free_rec) - 1; i++) {
1449dcd0538fSMark Fasheh 			rec = &el->l_recs[i];
1450dcd0538fSMark Fasheh 
1451dcd0538fSMark Fasheh 			/*
1452dcd0538fSMark Fasheh 			 * In the case that cpos is off the allocation
1453dcd0538fSMark Fasheh 			 * tree, this should just wind up returning the
1454dcd0538fSMark Fasheh 			 * rightmost record.
1455dcd0538fSMark Fasheh 			 */
1456dcd0538fSMark Fasheh 			range = le32_to_cpu(rec->e_cpos) +
1457e48edee2SMark Fasheh 				ocfs2_rec_clusters(el, rec);
1458dcd0538fSMark Fasheh 			if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
1459dcd0538fSMark Fasheh 			    break;
1460dcd0538fSMark Fasheh 		}
1461dcd0538fSMark Fasheh 
1462dcd0538fSMark Fasheh 		blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1463dcd0538fSMark Fasheh 		if (blkno == 0) {
1464dcd0538fSMark Fasheh 			ocfs2_error(inode->i_sb,
1465dcd0538fSMark Fasheh 				    "Inode %llu has bad blkno in extent list "
1466dcd0538fSMark Fasheh 				    "at depth %u (index %d)\n",
1467dcd0538fSMark Fasheh 				    (unsigned long long)oi->ip_blkno,
1468dcd0538fSMark Fasheh 				    le16_to_cpu(el->l_tree_depth), i);
1469dcd0538fSMark Fasheh 			ret = -EROFS;
1470dcd0538fSMark Fasheh 			goto out;
1471dcd0538fSMark Fasheh 		}
1472dcd0538fSMark Fasheh 
1473dcd0538fSMark Fasheh 		brelse(bh);
1474dcd0538fSMark Fasheh 		bh = NULL;
1475dcd0538fSMark Fasheh 		ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), blkno,
1476dcd0538fSMark Fasheh 				       &bh, OCFS2_BH_CACHED, inode);
1477dcd0538fSMark Fasheh 		if (ret) {
1478dcd0538fSMark Fasheh 			mlog_errno(ret);
1479dcd0538fSMark Fasheh 			goto out;
1480dcd0538fSMark Fasheh 		}
1481dcd0538fSMark Fasheh 
1482dcd0538fSMark Fasheh 		eb = (struct ocfs2_extent_block *) bh->b_data;
1483dcd0538fSMark Fasheh 		el = &eb->h_list;
1484dcd0538fSMark Fasheh 		if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
1485dcd0538fSMark Fasheh 			OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
1486dcd0538fSMark Fasheh 			ret = -EIO;
1487dcd0538fSMark Fasheh 			goto out;
1488dcd0538fSMark Fasheh 		}
1489dcd0538fSMark Fasheh 
1490dcd0538fSMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) >
1491dcd0538fSMark Fasheh 		    le16_to_cpu(el->l_count)) {
1492dcd0538fSMark Fasheh 			ocfs2_error(inode->i_sb,
1493dcd0538fSMark Fasheh 				    "Inode %llu has bad count in extent list "
1494dcd0538fSMark Fasheh 				    "at block %llu (next free=%u, count=%u)\n",
1495dcd0538fSMark Fasheh 				    (unsigned long long)oi->ip_blkno,
1496dcd0538fSMark Fasheh 				    (unsigned long long)bh->b_blocknr,
1497dcd0538fSMark Fasheh 				    le16_to_cpu(el->l_next_free_rec),
1498dcd0538fSMark Fasheh 				    le16_to_cpu(el->l_count));
1499dcd0538fSMark Fasheh 			ret = -EROFS;
1500dcd0538fSMark Fasheh 			goto out;
1501dcd0538fSMark Fasheh 		}
1502dcd0538fSMark Fasheh 
1503dcd0538fSMark Fasheh 		if (func)
1504dcd0538fSMark Fasheh 			func(data, bh);
1505dcd0538fSMark Fasheh 	}
1506dcd0538fSMark Fasheh 
1507dcd0538fSMark Fasheh out:
1508dcd0538fSMark Fasheh 	/*
1509dcd0538fSMark Fasheh 	 * Catch any trailing bh that the loop didn't handle.
1510dcd0538fSMark Fasheh 	 */
1511dcd0538fSMark Fasheh 	brelse(bh);
1512dcd0538fSMark Fasheh 
1513dcd0538fSMark Fasheh 	return ret;
1514dcd0538fSMark Fasheh }
1515dcd0538fSMark Fasheh 
1516dcd0538fSMark Fasheh /*
1517dcd0538fSMark Fasheh  * Given an initialized path (that is, it has a valid root extent
1518dcd0538fSMark Fasheh  * list), this function will traverse the btree in search of the path
1519dcd0538fSMark Fasheh  * which would contain cpos.
1520dcd0538fSMark Fasheh  *
1521dcd0538fSMark Fasheh  * The path traveled is recorded in the path structure.
1522dcd0538fSMark Fasheh  *
1523dcd0538fSMark Fasheh  * Note that this will not do any comparisons on leaf node extent
1524dcd0538fSMark Fasheh  * records, so it will work fine in the case that we just added a tree
1525dcd0538fSMark Fasheh  * branch.
1526dcd0538fSMark Fasheh  */
1527dcd0538fSMark Fasheh struct find_path_data {
1528dcd0538fSMark Fasheh 	int index;
1529dcd0538fSMark Fasheh 	struct ocfs2_path *path;
1530dcd0538fSMark Fasheh };
1531dcd0538fSMark Fasheh static void find_path_ins(void *data, struct buffer_head *bh)
1532dcd0538fSMark Fasheh {
1533dcd0538fSMark Fasheh 	struct find_path_data *fp = data;
1534dcd0538fSMark Fasheh 
1535dcd0538fSMark Fasheh 	get_bh(bh);
1536dcd0538fSMark Fasheh 	ocfs2_path_insert_eb(fp->path, fp->index, bh);
1537dcd0538fSMark Fasheh 	fp->index++;
1538dcd0538fSMark Fasheh }
1539dcd0538fSMark Fasheh static int ocfs2_find_path(struct inode *inode, struct ocfs2_path *path,
1540dcd0538fSMark Fasheh 			   u32 cpos)
1541dcd0538fSMark Fasheh {
1542dcd0538fSMark Fasheh 	struct find_path_data data;
1543dcd0538fSMark Fasheh 
1544dcd0538fSMark Fasheh 	data.index = 1;
1545dcd0538fSMark Fasheh 	data.path = path;
1546dcd0538fSMark Fasheh 	return __ocfs2_find_path(inode, path_root_el(path), cpos,
1547dcd0538fSMark Fasheh 				 find_path_ins, &data);
1548dcd0538fSMark Fasheh }
1549dcd0538fSMark Fasheh 
1550dcd0538fSMark Fasheh static void find_leaf_ins(void *data, struct buffer_head *bh)
1551dcd0538fSMark Fasheh {
1552dcd0538fSMark Fasheh 	struct ocfs2_extent_block *eb =(struct ocfs2_extent_block *)bh->b_data;
1553dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el = &eb->h_list;
1554dcd0538fSMark Fasheh 	struct buffer_head **ret = data;
1555dcd0538fSMark Fasheh 
1556dcd0538fSMark Fasheh 	/* We want to retain only the leaf block. */
1557dcd0538fSMark Fasheh 	if (le16_to_cpu(el->l_tree_depth) == 0) {
1558dcd0538fSMark Fasheh 		get_bh(bh);
1559dcd0538fSMark Fasheh 		*ret = bh;
1560dcd0538fSMark Fasheh 	}
1561dcd0538fSMark Fasheh }
1562dcd0538fSMark Fasheh /*
1563dcd0538fSMark Fasheh  * Find the leaf block in the tree which would contain cpos. No
1564dcd0538fSMark Fasheh  * checking of the actual leaf is done.
1565dcd0538fSMark Fasheh  *
1566dcd0538fSMark Fasheh  * Some paths want to call this instead of allocating a path structure
1567dcd0538fSMark Fasheh  * and calling ocfs2_find_path().
1568dcd0538fSMark Fasheh  *
1569dcd0538fSMark Fasheh  * This function doesn't handle non btree extent lists.
1570dcd0538fSMark Fasheh  */
1571363041a5SMark Fasheh int ocfs2_find_leaf(struct inode *inode, struct ocfs2_extent_list *root_el,
1572363041a5SMark Fasheh 		    u32 cpos, struct buffer_head **leaf_bh)
1573dcd0538fSMark Fasheh {
1574dcd0538fSMark Fasheh 	int ret;
1575dcd0538fSMark Fasheh 	struct buffer_head *bh = NULL;
1576dcd0538fSMark Fasheh 
1577dcd0538fSMark Fasheh 	ret = __ocfs2_find_path(inode, root_el, cpos, find_leaf_ins, &bh);
1578dcd0538fSMark Fasheh 	if (ret) {
1579dcd0538fSMark Fasheh 		mlog_errno(ret);
1580dcd0538fSMark Fasheh 		goto out;
1581dcd0538fSMark Fasheh 	}
1582dcd0538fSMark Fasheh 
1583dcd0538fSMark Fasheh 	*leaf_bh = bh;
1584dcd0538fSMark Fasheh out:
1585dcd0538fSMark Fasheh 	return ret;
1586dcd0538fSMark Fasheh }
1587dcd0538fSMark Fasheh 
1588dcd0538fSMark Fasheh /*
1589dcd0538fSMark Fasheh  * Adjust the adjacent records (left_rec, right_rec) involved in a rotation.
1590dcd0538fSMark Fasheh  *
1591dcd0538fSMark Fasheh  * Basically, we've moved stuff around at the bottom of the tree and
1592dcd0538fSMark Fasheh  * we need to fix up the extent records above the changes to reflect
1593dcd0538fSMark Fasheh  * the new changes.
1594dcd0538fSMark Fasheh  *
1595dcd0538fSMark Fasheh  * left_rec: the record on the left.
1596dcd0538fSMark Fasheh  * left_child_el: is the child list pointed to by left_rec
1597dcd0538fSMark Fasheh  * right_rec: the record to the right of left_rec
1598dcd0538fSMark Fasheh  * right_child_el: is the child list pointed to by right_rec
1599dcd0538fSMark Fasheh  *
1600dcd0538fSMark Fasheh  * By definition, this only works on interior nodes.
1601dcd0538fSMark Fasheh  */
1602dcd0538fSMark Fasheh static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec,
1603dcd0538fSMark Fasheh 				  struct ocfs2_extent_list *left_child_el,
1604dcd0538fSMark Fasheh 				  struct ocfs2_extent_rec *right_rec,
1605dcd0538fSMark Fasheh 				  struct ocfs2_extent_list *right_child_el)
1606dcd0538fSMark Fasheh {
1607dcd0538fSMark Fasheh 	u32 left_clusters, right_end;
1608dcd0538fSMark Fasheh 
1609dcd0538fSMark Fasheh 	/*
1610dcd0538fSMark Fasheh 	 * Interior nodes never have holes. Their cpos is the cpos of
1611dcd0538fSMark Fasheh 	 * the leftmost record in their child list. Their cluster
1612dcd0538fSMark Fasheh 	 * count covers the full theoretical range of their child list
1613dcd0538fSMark Fasheh 	 * - the range between their cpos and the cpos of the record
1614dcd0538fSMark Fasheh 	 * immediately to their right.
1615dcd0538fSMark Fasheh 	 */
1616dcd0538fSMark Fasheh 	left_clusters = le32_to_cpu(right_child_el->l_recs[0].e_cpos);
1617328d5752SMark Fasheh 	if (ocfs2_is_empty_extent(&right_child_el->l_recs[0])) {
1618328d5752SMark Fasheh 		BUG_ON(le16_to_cpu(right_child_el->l_next_free_rec) <= 1);
1619328d5752SMark Fasheh 		left_clusters = le32_to_cpu(right_child_el->l_recs[1].e_cpos);
1620328d5752SMark Fasheh 	}
1621dcd0538fSMark Fasheh 	left_clusters -= le32_to_cpu(left_rec->e_cpos);
1622e48edee2SMark Fasheh 	left_rec->e_int_clusters = cpu_to_le32(left_clusters);
1623dcd0538fSMark Fasheh 
1624dcd0538fSMark Fasheh 	/*
1625dcd0538fSMark Fasheh 	 * Calculate the rightmost cluster count boundary before
1626e48edee2SMark Fasheh 	 * moving cpos - we will need to adjust clusters after
1627dcd0538fSMark Fasheh 	 * updating e_cpos to keep the same highest cluster count.
1628dcd0538fSMark Fasheh 	 */
1629dcd0538fSMark Fasheh 	right_end = le32_to_cpu(right_rec->e_cpos);
1630e48edee2SMark Fasheh 	right_end += le32_to_cpu(right_rec->e_int_clusters);
1631dcd0538fSMark Fasheh 
1632dcd0538fSMark Fasheh 	right_rec->e_cpos = left_rec->e_cpos;
1633dcd0538fSMark Fasheh 	le32_add_cpu(&right_rec->e_cpos, left_clusters);
1634dcd0538fSMark Fasheh 
1635dcd0538fSMark Fasheh 	right_end -= le32_to_cpu(right_rec->e_cpos);
1636e48edee2SMark Fasheh 	right_rec->e_int_clusters = cpu_to_le32(right_end);
1637dcd0538fSMark Fasheh }
1638dcd0538fSMark Fasheh 
1639dcd0538fSMark Fasheh /*
1640dcd0538fSMark Fasheh  * Adjust the adjacent root node records involved in a
1641dcd0538fSMark Fasheh  * rotation. left_el_blkno is passed in as a key so that we can easily
1642dcd0538fSMark Fasheh  * find it's index in the root list.
1643dcd0538fSMark Fasheh  */
1644dcd0538fSMark Fasheh static void ocfs2_adjust_root_records(struct ocfs2_extent_list *root_el,
1645dcd0538fSMark Fasheh 				      struct ocfs2_extent_list *left_el,
1646dcd0538fSMark Fasheh 				      struct ocfs2_extent_list *right_el,
1647dcd0538fSMark Fasheh 				      u64 left_el_blkno)
1648dcd0538fSMark Fasheh {
1649dcd0538fSMark Fasheh 	int i;
1650dcd0538fSMark Fasheh 
1651dcd0538fSMark Fasheh 	BUG_ON(le16_to_cpu(root_el->l_tree_depth) <=
1652dcd0538fSMark Fasheh 	       le16_to_cpu(left_el->l_tree_depth));
1653dcd0538fSMark Fasheh 
1654dcd0538fSMark Fasheh 	for(i = 0; i < le16_to_cpu(root_el->l_next_free_rec) - 1; i++) {
1655dcd0538fSMark Fasheh 		if (le64_to_cpu(root_el->l_recs[i].e_blkno) == left_el_blkno)
1656dcd0538fSMark Fasheh 			break;
1657dcd0538fSMark Fasheh 	}
1658dcd0538fSMark Fasheh 
1659dcd0538fSMark Fasheh 	/*
1660dcd0538fSMark Fasheh 	 * The path walking code should have never returned a root and
1661dcd0538fSMark Fasheh 	 * two paths which are not adjacent.
1662dcd0538fSMark Fasheh 	 */
1663dcd0538fSMark Fasheh 	BUG_ON(i >= (le16_to_cpu(root_el->l_next_free_rec) - 1));
1664dcd0538fSMark Fasheh 
1665dcd0538fSMark Fasheh 	ocfs2_adjust_adjacent_records(&root_el->l_recs[i], left_el,
1666dcd0538fSMark Fasheh 				      &root_el->l_recs[i + 1], right_el);
1667dcd0538fSMark Fasheh }
1668dcd0538fSMark Fasheh 
1669dcd0538fSMark Fasheh /*
1670dcd0538fSMark Fasheh  * We've changed a leaf block (in right_path) and need to reflect that
1671dcd0538fSMark Fasheh  * change back up the subtree.
1672dcd0538fSMark Fasheh  *
1673dcd0538fSMark Fasheh  * This happens in multiple places:
1674dcd0538fSMark Fasheh  *   - When we've moved an extent record from the left path leaf to the right
1675dcd0538fSMark Fasheh  *     path leaf to make room for an empty extent in the left path leaf.
1676dcd0538fSMark Fasheh  *   - When our insert into the right path leaf is at the leftmost edge
1677dcd0538fSMark Fasheh  *     and requires an update of the path immediately to it's left. This
1678dcd0538fSMark Fasheh  *     can occur at the end of some types of rotation and appending inserts.
1679677b9752STao Ma  *   - When we've adjusted the last extent record in the left path leaf and the
1680677b9752STao Ma  *     1st extent record in the right path leaf during cross extent block merge.
1681dcd0538fSMark Fasheh  */
1682dcd0538fSMark Fasheh static void ocfs2_complete_edge_insert(struct inode *inode, handle_t *handle,
1683dcd0538fSMark Fasheh 				       struct ocfs2_path *left_path,
1684dcd0538fSMark Fasheh 				       struct ocfs2_path *right_path,
1685dcd0538fSMark Fasheh 				       int subtree_index)
1686dcd0538fSMark Fasheh {
1687dcd0538fSMark Fasheh 	int ret, i, idx;
1688dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el, *left_el, *right_el;
1689dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *left_rec, *right_rec;
1690dcd0538fSMark Fasheh 	struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
1691dcd0538fSMark Fasheh 
1692dcd0538fSMark Fasheh 	/*
1693dcd0538fSMark Fasheh 	 * Update the counts and position values within all the
1694dcd0538fSMark Fasheh 	 * interior nodes to reflect the leaf rotation we just did.
1695dcd0538fSMark Fasheh 	 *
1696dcd0538fSMark Fasheh 	 * The root node is handled below the loop.
1697dcd0538fSMark Fasheh 	 *
1698dcd0538fSMark Fasheh 	 * We begin the loop with right_el and left_el pointing to the
1699dcd0538fSMark Fasheh 	 * leaf lists and work our way up.
1700dcd0538fSMark Fasheh 	 *
1701dcd0538fSMark Fasheh 	 * NOTE: within this loop, left_el and right_el always refer
1702dcd0538fSMark Fasheh 	 * to the *child* lists.
1703dcd0538fSMark Fasheh 	 */
1704dcd0538fSMark Fasheh 	left_el = path_leaf_el(left_path);
1705dcd0538fSMark Fasheh 	right_el = path_leaf_el(right_path);
1706dcd0538fSMark Fasheh 	for(i = left_path->p_tree_depth - 1; i > subtree_index; i--) {
1707dcd0538fSMark Fasheh 		mlog(0, "Adjust records at index %u\n", i);
1708dcd0538fSMark Fasheh 
1709dcd0538fSMark Fasheh 		/*
1710dcd0538fSMark Fasheh 		 * One nice property of knowing that all of these
1711dcd0538fSMark Fasheh 		 * nodes are below the root is that we only deal with
1712dcd0538fSMark Fasheh 		 * the leftmost right node record and the rightmost
1713dcd0538fSMark Fasheh 		 * left node record.
1714dcd0538fSMark Fasheh 		 */
1715dcd0538fSMark Fasheh 		el = left_path->p_node[i].el;
1716dcd0538fSMark Fasheh 		idx = le16_to_cpu(left_el->l_next_free_rec) - 1;
1717dcd0538fSMark Fasheh 		left_rec = &el->l_recs[idx];
1718dcd0538fSMark Fasheh 
1719dcd0538fSMark Fasheh 		el = right_path->p_node[i].el;
1720dcd0538fSMark Fasheh 		right_rec = &el->l_recs[0];
1721dcd0538fSMark Fasheh 
1722dcd0538fSMark Fasheh 		ocfs2_adjust_adjacent_records(left_rec, left_el, right_rec,
1723dcd0538fSMark Fasheh 					      right_el);
1724dcd0538fSMark Fasheh 
1725dcd0538fSMark Fasheh 		ret = ocfs2_journal_dirty(handle, left_path->p_node[i].bh);
1726dcd0538fSMark Fasheh 		if (ret)
1727dcd0538fSMark Fasheh 			mlog_errno(ret);
1728dcd0538fSMark Fasheh 
1729dcd0538fSMark Fasheh 		ret = ocfs2_journal_dirty(handle, right_path->p_node[i].bh);
1730dcd0538fSMark Fasheh 		if (ret)
1731dcd0538fSMark Fasheh 			mlog_errno(ret);
1732dcd0538fSMark Fasheh 
1733dcd0538fSMark Fasheh 		/*
1734dcd0538fSMark Fasheh 		 * Setup our list pointers now so that the current
1735dcd0538fSMark Fasheh 		 * parents become children in the next iteration.
1736dcd0538fSMark Fasheh 		 */
1737dcd0538fSMark Fasheh 		left_el = left_path->p_node[i].el;
1738dcd0538fSMark Fasheh 		right_el = right_path->p_node[i].el;
1739dcd0538fSMark Fasheh 	}
1740dcd0538fSMark Fasheh 
1741dcd0538fSMark Fasheh 	/*
1742dcd0538fSMark Fasheh 	 * At the root node, adjust the two adjacent records which
1743dcd0538fSMark Fasheh 	 * begin our path to the leaves.
1744dcd0538fSMark Fasheh 	 */
1745dcd0538fSMark Fasheh 
1746dcd0538fSMark Fasheh 	el = left_path->p_node[subtree_index].el;
1747dcd0538fSMark Fasheh 	left_el = left_path->p_node[subtree_index + 1].el;
1748dcd0538fSMark Fasheh 	right_el = right_path->p_node[subtree_index + 1].el;
1749dcd0538fSMark Fasheh 
1750dcd0538fSMark Fasheh 	ocfs2_adjust_root_records(el, left_el, right_el,
1751dcd0538fSMark Fasheh 				  left_path->p_node[subtree_index + 1].bh->b_blocknr);
1752dcd0538fSMark Fasheh 
1753dcd0538fSMark Fasheh 	root_bh = left_path->p_node[subtree_index].bh;
1754dcd0538fSMark Fasheh 
1755dcd0538fSMark Fasheh 	ret = ocfs2_journal_dirty(handle, root_bh);
1756dcd0538fSMark Fasheh 	if (ret)
1757dcd0538fSMark Fasheh 		mlog_errno(ret);
1758dcd0538fSMark Fasheh }
1759dcd0538fSMark Fasheh 
1760dcd0538fSMark Fasheh static int ocfs2_rotate_subtree_right(struct inode *inode,
1761dcd0538fSMark Fasheh 				      handle_t *handle,
1762dcd0538fSMark Fasheh 				      struct ocfs2_path *left_path,
1763dcd0538fSMark Fasheh 				      struct ocfs2_path *right_path,
1764dcd0538fSMark Fasheh 				      int subtree_index)
1765dcd0538fSMark Fasheh {
1766dcd0538fSMark Fasheh 	int ret, i;
1767dcd0538fSMark Fasheh 	struct buffer_head *right_leaf_bh;
1768dcd0538fSMark Fasheh 	struct buffer_head *left_leaf_bh = NULL;
1769dcd0538fSMark Fasheh 	struct buffer_head *root_bh;
1770dcd0538fSMark Fasheh 	struct ocfs2_extent_list *right_el, *left_el;
1771dcd0538fSMark Fasheh 	struct ocfs2_extent_rec move_rec;
1772dcd0538fSMark Fasheh 
1773dcd0538fSMark Fasheh 	left_leaf_bh = path_leaf_bh(left_path);
1774dcd0538fSMark Fasheh 	left_el = path_leaf_el(left_path);
1775dcd0538fSMark Fasheh 
1776dcd0538fSMark Fasheh 	if (left_el->l_next_free_rec != left_el->l_count) {
1777dcd0538fSMark Fasheh 		ocfs2_error(inode->i_sb,
1778dcd0538fSMark Fasheh 			    "Inode %llu has non-full interior leaf node %llu"
1779dcd0538fSMark Fasheh 			    "(next free = %u)",
1780dcd0538fSMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
1781dcd0538fSMark Fasheh 			    (unsigned long long)left_leaf_bh->b_blocknr,
1782dcd0538fSMark Fasheh 			    le16_to_cpu(left_el->l_next_free_rec));
1783dcd0538fSMark Fasheh 		return -EROFS;
1784dcd0538fSMark Fasheh 	}
1785dcd0538fSMark Fasheh 
1786dcd0538fSMark Fasheh 	/*
1787dcd0538fSMark Fasheh 	 * This extent block may already have an empty record, so we
1788dcd0538fSMark Fasheh 	 * return early if so.
1789dcd0538fSMark Fasheh 	 */
1790dcd0538fSMark Fasheh 	if (ocfs2_is_empty_extent(&left_el->l_recs[0]))
1791dcd0538fSMark Fasheh 		return 0;
1792dcd0538fSMark Fasheh 
1793dcd0538fSMark Fasheh 	root_bh = left_path->p_node[subtree_index].bh;
1794dcd0538fSMark Fasheh 	BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
1795dcd0538fSMark Fasheh 
1796dcd0538fSMark Fasheh 	ret = ocfs2_journal_access(handle, inode, root_bh,
1797dcd0538fSMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
1798dcd0538fSMark Fasheh 	if (ret) {
1799dcd0538fSMark Fasheh 		mlog_errno(ret);
1800dcd0538fSMark Fasheh 		goto out;
1801dcd0538fSMark Fasheh 	}
1802dcd0538fSMark Fasheh 
1803dcd0538fSMark Fasheh 	for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
1804dcd0538fSMark Fasheh 		ret = ocfs2_journal_access(handle, inode,
1805dcd0538fSMark Fasheh 					   right_path->p_node[i].bh,
1806dcd0538fSMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
1807dcd0538fSMark Fasheh 		if (ret) {
1808dcd0538fSMark Fasheh 			mlog_errno(ret);
1809dcd0538fSMark Fasheh 			goto out;
1810dcd0538fSMark Fasheh 		}
1811dcd0538fSMark Fasheh 
1812dcd0538fSMark Fasheh 		ret = ocfs2_journal_access(handle, inode,
1813dcd0538fSMark Fasheh 					   left_path->p_node[i].bh,
1814dcd0538fSMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
1815dcd0538fSMark Fasheh 		if (ret) {
1816dcd0538fSMark Fasheh 			mlog_errno(ret);
1817dcd0538fSMark Fasheh 			goto out;
1818dcd0538fSMark Fasheh 		}
1819dcd0538fSMark Fasheh 	}
1820dcd0538fSMark Fasheh 
1821dcd0538fSMark Fasheh 	right_leaf_bh = path_leaf_bh(right_path);
1822dcd0538fSMark Fasheh 	right_el = path_leaf_el(right_path);
1823dcd0538fSMark Fasheh 
1824dcd0538fSMark Fasheh 	/* This is a code error, not a disk corruption. */
1825dcd0538fSMark Fasheh 	mlog_bug_on_msg(!right_el->l_next_free_rec, "Inode %llu: Rotate fails "
1826dcd0538fSMark Fasheh 			"because rightmost leaf block %llu is empty\n",
1827dcd0538fSMark Fasheh 			(unsigned long long)OCFS2_I(inode)->ip_blkno,
1828dcd0538fSMark Fasheh 			(unsigned long long)right_leaf_bh->b_blocknr);
1829dcd0538fSMark Fasheh 
1830dcd0538fSMark Fasheh 	ocfs2_create_empty_extent(right_el);
1831dcd0538fSMark Fasheh 
1832dcd0538fSMark Fasheh 	ret = ocfs2_journal_dirty(handle, right_leaf_bh);
1833dcd0538fSMark Fasheh 	if (ret) {
1834dcd0538fSMark Fasheh 		mlog_errno(ret);
1835dcd0538fSMark Fasheh 		goto out;
1836dcd0538fSMark Fasheh 	}
1837dcd0538fSMark Fasheh 
1838dcd0538fSMark Fasheh 	/* Do the copy now. */
1839dcd0538fSMark Fasheh 	i = le16_to_cpu(left_el->l_next_free_rec) - 1;
1840dcd0538fSMark Fasheh 	move_rec = left_el->l_recs[i];
1841dcd0538fSMark Fasheh 	right_el->l_recs[0] = move_rec;
1842dcd0538fSMark Fasheh 
1843dcd0538fSMark Fasheh 	/*
1844dcd0538fSMark Fasheh 	 * Clear out the record we just copied and shift everything
1845dcd0538fSMark Fasheh 	 * over, leaving an empty extent in the left leaf.
1846dcd0538fSMark Fasheh 	 *
1847dcd0538fSMark Fasheh 	 * We temporarily subtract from next_free_rec so that the
1848dcd0538fSMark Fasheh 	 * shift will lose the tail record (which is now defunct).
1849dcd0538fSMark Fasheh 	 */
1850dcd0538fSMark Fasheh 	le16_add_cpu(&left_el->l_next_free_rec, -1);
1851dcd0538fSMark Fasheh 	ocfs2_shift_records_right(left_el);
1852dcd0538fSMark Fasheh 	memset(&left_el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
1853dcd0538fSMark Fasheh 	le16_add_cpu(&left_el->l_next_free_rec, 1);
1854dcd0538fSMark Fasheh 
1855dcd0538fSMark Fasheh 	ret = ocfs2_journal_dirty(handle, left_leaf_bh);
1856dcd0538fSMark Fasheh 	if (ret) {
1857dcd0538fSMark Fasheh 		mlog_errno(ret);
1858dcd0538fSMark Fasheh 		goto out;
1859dcd0538fSMark Fasheh 	}
1860dcd0538fSMark Fasheh 
1861dcd0538fSMark Fasheh 	ocfs2_complete_edge_insert(inode, handle, left_path, right_path,
1862dcd0538fSMark Fasheh 				subtree_index);
1863dcd0538fSMark Fasheh 
1864dcd0538fSMark Fasheh out:
1865dcd0538fSMark Fasheh 	return ret;
1866dcd0538fSMark Fasheh }
1867dcd0538fSMark Fasheh 
1868dcd0538fSMark Fasheh /*
1869dcd0538fSMark Fasheh  * Given a full path, determine what cpos value would return us a path
1870dcd0538fSMark Fasheh  * containing the leaf immediately to the left of the current one.
1871dcd0538fSMark Fasheh  *
1872dcd0538fSMark Fasheh  * Will return zero if the path passed in is already the leftmost path.
1873dcd0538fSMark Fasheh  */
1874dcd0538fSMark Fasheh static int ocfs2_find_cpos_for_left_leaf(struct super_block *sb,
1875dcd0538fSMark Fasheh 					 struct ocfs2_path *path, u32 *cpos)
1876dcd0538fSMark Fasheh {
1877dcd0538fSMark Fasheh 	int i, j, ret = 0;
1878dcd0538fSMark Fasheh 	u64 blkno;
1879dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el;
1880dcd0538fSMark Fasheh 
1881e48edee2SMark Fasheh 	BUG_ON(path->p_tree_depth == 0);
1882e48edee2SMark Fasheh 
1883dcd0538fSMark Fasheh 	*cpos = 0;
1884dcd0538fSMark Fasheh 
1885dcd0538fSMark Fasheh 	blkno = path_leaf_bh(path)->b_blocknr;
1886dcd0538fSMark Fasheh 
1887dcd0538fSMark Fasheh 	/* Start at the tree node just above the leaf and work our way up. */
1888dcd0538fSMark Fasheh 	i = path->p_tree_depth - 1;
1889dcd0538fSMark Fasheh 	while (i >= 0) {
1890dcd0538fSMark Fasheh 		el = path->p_node[i].el;
1891dcd0538fSMark Fasheh 
1892dcd0538fSMark Fasheh 		/*
1893dcd0538fSMark Fasheh 		 * Find the extent record just before the one in our
1894dcd0538fSMark Fasheh 		 * path.
1895dcd0538fSMark Fasheh 		 */
1896dcd0538fSMark Fasheh 		for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
1897dcd0538fSMark Fasheh 			if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
1898dcd0538fSMark Fasheh 				if (j == 0) {
1899dcd0538fSMark Fasheh 					if (i == 0) {
1900dcd0538fSMark Fasheh 						/*
1901dcd0538fSMark Fasheh 						 * We've determined that the
1902dcd0538fSMark Fasheh 						 * path specified is already
1903dcd0538fSMark Fasheh 						 * the leftmost one - return a
1904dcd0538fSMark Fasheh 						 * cpos of zero.
1905dcd0538fSMark Fasheh 						 */
1906dcd0538fSMark Fasheh 						goto out;
1907dcd0538fSMark Fasheh 					}
1908dcd0538fSMark Fasheh 					/*
1909dcd0538fSMark Fasheh 					 * The leftmost record points to our
1910dcd0538fSMark Fasheh 					 * leaf - we need to travel up the
1911dcd0538fSMark Fasheh 					 * tree one level.
1912dcd0538fSMark Fasheh 					 */
1913dcd0538fSMark Fasheh 					goto next_node;
1914dcd0538fSMark Fasheh 				}
1915dcd0538fSMark Fasheh 
1916dcd0538fSMark Fasheh 				*cpos = le32_to_cpu(el->l_recs[j - 1].e_cpos);
1917e48edee2SMark Fasheh 				*cpos = *cpos + ocfs2_rec_clusters(el,
1918e48edee2SMark Fasheh 							   &el->l_recs[j - 1]);
1919e48edee2SMark Fasheh 				*cpos = *cpos - 1;
1920dcd0538fSMark Fasheh 				goto out;
1921dcd0538fSMark Fasheh 			}
1922dcd0538fSMark Fasheh 		}
1923dcd0538fSMark Fasheh 
1924dcd0538fSMark Fasheh 		/*
1925dcd0538fSMark Fasheh 		 * If we got here, we never found a valid node where
1926dcd0538fSMark Fasheh 		 * the tree indicated one should be.
1927dcd0538fSMark Fasheh 		 */
1928dcd0538fSMark Fasheh 		ocfs2_error(sb,
1929dcd0538fSMark Fasheh 			    "Invalid extent tree at extent block %llu\n",
1930dcd0538fSMark Fasheh 			    (unsigned long long)blkno);
1931dcd0538fSMark Fasheh 		ret = -EROFS;
1932dcd0538fSMark Fasheh 		goto out;
1933dcd0538fSMark Fasheh 
1934dcd0538fSMark Fasheh next_node:
1935dcd0538fSMark Fasheh 		blkno = path->p_node[i].bh->b_blocknr;
1936dcd0538fSMark Fasheh 		i--;
1937dcd0538fSMark Fasheh 	}
1938dcd0538fSMark Fasheh 
1939dcd0538fSMark Fasheh out:
1940dcd0538fSMark Fasheh 	return ret;
1941dcd0538fSMark Fasheh }
1942dcd0538fSMark Fasheh 
1943328d5752SMark Fasheh /*
1944328d5752SMark Fasheh  * Extend the transaction by enough credits to complete the rotation,
1945328d5752SMark Fasheh  * and still leave at least the original number of credits allocated
1946328d5752SMark Fasheh  * to this transaction.
1947328d5752SMark Fasheh  */
1948dcd0538fSMark Fasheh static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth,
1949328d5752SMark Fasheh 					   int op_credits,
1950dcd0538fSMark Fasheh 					   struct ocfs2_path *path)
1951dcd0538fSMark Fasheh {
1952328d5752SMark Fasheh 	int credits = (path->p_tree_depth - subtree_depth) * 2 + 1 + op_credits;
1953dcd0538fSMark Fasheh 
1954dcd0538fSMark Fasheh 	if (handle->h_buffer_credits < credits)
1955dcd0538fSMark Fasheh 		return ocfs2_extend_trans(handle, credits);
1956dcd0538fSMark Fasheh 
1957dcd0538fSMark Fasheh 	return 0;
1958dcd0538fSMark Fasheh }
1959dcd0538fSMark Fasheh 
1960dcd0538fSMark Fasheh /*
1961dcd0538fSMark Fasheh  * Trap the case where we're inserting into the theoretical range past
1962dcd0538fSMark Fasheh  * the _actual_ left leaf range. Otherwise, we'll rotate a record
1963dcd0538fSMark Fasheh  * whose cpos is less than ours into the right leaf.
1964dcd0538fSMark Fasheh  *
1965dcd0538fSMark Fasheh  * It's only necessary to look at the rightmost record of the left
1966dcd0538fSMark Fasheh  * leaf because the logic that calls us should ensure that the
1967dcd0538fSMark Fasheh  * theoretical ranges in the path components above the leaves are
1968dcd0538fSMark Fasheh  * correct.
1969dcd0538fSMark Fasheh  */
1970dcd0538fSMark Fasheh static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path,
1971dcd0538fSMark Fasheh 						 u32 insert_cpos)
1972dcd0538fSMark Fasheh {
1973dcd0538fSMark Fasheh 	struct ocfs2_extent_list *left_el;
1974dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *rec;
1975dcd0538fSMark Fasheh 	int next_free;
1976dcd0538fSMark Fasheh 
1977dcd0538fSMark Fasheh 	left_el = path_leaf_el(left_path);
1978dcd0538fSMark Fasheh 	next_free = le16_to_cpu(left_el->l_next_free_rec);
1979dcd0538fSMark Fasheh 	rec = &left_el->l_recs[next_free - 1];
1980dcd0538fSMark Fasheh 
1981dcd0538fSMark Fasheh 	if (insert_cpos > le32_to_cpu(rec->e_cpos))
1982dcd0538fSMark Fasheh 		return 1;
1983dcd0538fSMark Fasheh 	return 0;
1984dcd0538fSMark Fasheh }
1985dcd0538fSMark Fasheh 
1986328d5752SMark Fasheh static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos)
1987328d5752SMark Fasheh {
1988328d5752SMark Fasheh 	int next_free = le16_to_cpu(el->l_next_free_rec);
1989328d5752SMark Fasheh 	unsigned int range;
1990328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec;
1991328d5752SMark Fasheh 
1992328d5752SMark Fasheh 	if (next_free == 0)
1993328d5752SMark Fasheh 		return 0;
1994328d5752SMark Fasheh 
1995328d5752SMark Fasheh 	rec = &el->l_recs[0];
1996328d5752SMark Fasheh 	if (ocfs2_is_empty_extent(rec)) {
1997328d5752SMark Fasheh 		/* Empty list. */
1998328d5752SMark Fasheh 		if (next_free == 1)
1999328d5752SMark Fasheh 			return 0;
2000328d5752SMark Fasheh 		rec = &el->l_recs[1];
2001328d5752SMark Fasheh 	}
2002328d5752SMark Fasheh 
2003328d5752SMark Fasheh 	range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2004328d5752SMark Fasheh 	if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
2005328d5752SMark Fasheh 		return 1;
2006328d5752SMark Fasheh 	return 0;
2007328d5752SMark Fasheh }
2008328d5752SMark Fasheh 
2009dcd0538fSMark Fasheh /*
2010dcd0538fSMark Fasheh  * Rotate all the records in a btree right one record, starting at insert_cpos.
2011dcd0538fSMark Fasheh  *
2012dcd0538fSMark Fasheh  * The path to the rightmost leaf should be passed in.
2013dcd0538fSMark Fasheh  *
2014dcd0538fSMark Fasheh  * The array is assumed to be large enough to hold an entire path (tree depth).
2015dcd0538fSMark Fasheh  *
2016dcd0538fSMark Fasheh  * Upon succesful return from this function:
2017dcd0538fSMark Fasheh  *
2018dcd0538fSMark Fasheh  * - The 'right_path' array will contain a path to the leaf block
2019dcd0538fSMark Fasheh  *   whose range contains e_cpos.
2020dcd0538fSMark Fasheh  * - That leaf block will have a single empty extent in list index 0.
2021dcd0538fSMark Fasheh  * - In the case that the rotation requires a post-insert update,
2022dcd0538fSMark Fasheh  *   *ret_left_path will contain a valid path which can be passed to
2023dcd0538fSMark Fasheh  *   ocfs2_insert_path().
2024dcd0538fSMark Fasheh  */
2025dcd0538fSMark Fasheh static int ocfs2_rotate_tree_right(struct inode *inode,
2026dcd0538fSMark Fasheh 				   handle_t *handle,
2027328d5752SMark Fasheh 				   enum ocfs2_split_type split,
2028dcd0538fSMark Fasheh 				   u32 insert_cpos,
2029dcd0538fSMark Fasheh 				   struct ocfs2_path *right_path,
2030dcd0538fSMark Fasheh 				   struct ocfs2_path **ret_left_path)
2031dcd0538fSMark Fasheh {
2032328d5752SMark Fasheh 	int ret, start, orig_credits = handle->h_buffer_credits;
2033dcd0538fSMark Fasheh 	u32 cpos;
2034dcd0538fSMark Fasheh 	struct ocfs2_path *left_path = NULL;
2035dcd0538fSMark Fasheh 
2036dcd0538fSMark Fasheh 	*ret_left_path = NULL;
2037dcd0538fSMark Fasheh 
2038dcd0538fSMark Fasheh 	left_path = ocfs2_new_path(path_root_bh(right_path),
2039dcd0538fSMark Fasheh 				   path_root_el(right_path));
2040dcd0538fSMark Fasheh 	if (!left_path) {
2041dcd0538fSMark Fasheh 		ret = -ENOMEM;
2042dcd0538fSMark Fasheh 		mlog_errno(ret);
2043dcd0538fSMark Fasheh 		goto out;
2044dcd0538fSMark Fasheh 	}
2045dcd0538fSMark Fasheh 
2046dcd0538fSMark Fasheh 	ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path, &cpos);
2047dcd0538fSMark Fasheh 	if (ret) {
2048dcd0538fSMark Fasheh 		mlog_errno(ret);
2049dcd0538fSMark Fasheh 		goto out;
2050dcd0538fSMark Fasheh 	}
2051dcd0538fSMark Fasheh 
2052dcd0538fSMark Fasheh 	mlog(0, "Insert: %u, first left path cpos: %u\n", insert_cpos, cpos);
2053dcd0538fSMark Fasheh 
2054dcd0538fSMark Fasheh 	/*
2055dcd0538fSMark Fasheh 	 * What we want to do here is:
2056dcd0538fSMark Fasheh 	 *
2057dcd0538fSMark Fasheh 	 * 1) Start with the rightmost path.
2058dcd0538fSMark Fasheh 	 *
2059dcd0538fSMark Fasheh 	 * 2) Determine a path to the leaf block directly to the left
2060dcd0538fSMark Fasheh 	 *    of that leaf.
2061dcd0538fSMark Fasheh 	 *
2062dcd0538fSMark Fasheh 	 * 3) Determine the 'subtree root' - the lowest level tree node
2063dcd0538fSMark Fasheh 	 *    which contains a path to both leaves.
2064dcd0538fSMark Fasheh 	 *
2065dcd0538fSMark Fasheh 	 * 4) Rotate the subtree.
2066dcd0538fSMark Fasheh 	 *
2067dcd0538fSMark Fasheh 	 * 5) Find the next subtree by considering the left path to be
2068dcd0538fSMark Fasheh 	 *    the new right path.
2069dcd0538fSMark Fasheh 	 *
2070dcd0538fSMark Fasheh 	 * The check at the top of this while loop also accepts
2071dcd0538fSMark Fasheh 	 * insert_cpos == cpos because cpos is only a _theoretical_
2072dcd0538fSMark Fasheh 	 * value to get us the left path - insert_cpos might very well
2073dcd0538fSMark Fasheh 	 * be filling that hole.
2074dcd0538fSMark Fasheh 	 *
2075dcd0538fSMark Fasheh 	 * Stop at a cpos of '0' because we either started at the
2076dcd0538fSMark Fasheh 	 * leftmost branch (i.e., a tree with one branch and a
2077dcd0538fSMark Fasheh 	 * rotation inside of it), or we've gone as far as we can in
2078dcd0538fSMark Fasheh 	 * rotating subtrees.
2079dcd0538fSMark Fasheh 	 */
2080dcd0538fSMark Fasheh 	while (cpos && insert_cpos <= cpos) {
2081dcd0538fSMark Fasheh 		mlog(0, "Rotating a tree: ins. cpos: %u, left path cpos: %u\n",
2082dcd0538fSMark Fasheh 		     insert_cpos, cpos);
2083dcd0538fSMark Fasheh 
2084dcd0538fSMark Fasheh 		ret = ocfs2_find_path(inode, left_path, cpos);
2085dcd0538fSMark Fasheh 		if (ret) {
2086dcd0538fSMark Fasheh 			mlog_errno(ret);
2087dcd0538fSMark Fasheh 			goto out;
2088dcd0538fSMark Fasheh 		}
2089dcd0538fSMark Fasheh 
2090dcd0538fSMark Fasheh 		mlog_bug_on_msg(path_leaf_bh(left_path) ==
2091dcd0538fSMark Fasheh 				path_leaf_bh(right_path),
2092dcd0538fSMark Fasheh 				"Inode %lu: error during insert of %u "
2093dcd0538fSMark Fasheh 				"(left path cpos %u) results in two identical "
2094dcd0538fSMark Fasheh 				"paths ending at %llu\n",
2095dcd0538fSMark Fasheh 				inode->i_ino, insert_cpos, cpos,
2096dcd0538fSMark Fasheh 				(unsigned long long)
2097dcd0538fSMark Fasheh 				path_leaf_bh(left_path)->b_blocknr);
2098dcd0538fSMark Fasheh 
2099328d5752SMark Fasheh 		if (split == SPLIT_NONE &&
2100328d5752SMark Fasheh 		    ocfs2_rotate_requires_path_adjustment(left_path,
2101dcd0538fSMark Fasheh 							  insert_cpos)) {
2102dcd0538fSMark Fasheh 
2103dcd0538fSMark Fasheh 			/*
2104dcd0538fSMark Fasheh 			 * We've rotated the tree as much as we
2105dcd0538fSMark Fasheh 			 * should. The rest is up to
2106dcd0538fSMark Fasheh 			 * ocfs2_insert_path() to complete, after the
2107dcd0538fSMark Fasheh 			 * record insertion. We indicate this
2108dcd0538fSMark Fasheh 			 * situation by returning the left path.
2109dcd0538fSMark Fasheh 			 *
2110dcd0538fSMark Fasheh 			 * The reason we don't adjust the records here
2111dcd0538fSMark Fasheh 			 * before the record insert is that an error
2112dcd0538fSMark Fasheh 			 * later might break the rule where a parent
2113dcd0538fSMark Fasheh 			 * record e_cpos will reflect the actual
2114dcd0538fSMark Fasheh 			 * e_cpos of the 1st nonempty record of the
2115dcd0538fSMark Fasheh 			 * child list.
2116dcd0538fSMark Fasheh 			 */
2117dcd0538fSMark Fasheh 			*ret_left_path = left_path;
2118dcd0538fSMark Fasheh 			goto out_ret_path;
2119dcd0538fSMark Fasheh 		}
2120dcd0538fSMark Fasheh 
2121dcd0538fSMark Fasheh 		start = ocfs2_find_subtree_root(inode, left_path, right_path);
2122dcd0538fSMark Fasheh 
2123dcd0538fSMark Fasheh 		mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n",
2124dcd0538fSMark Fasheh 		     start,
2125dcd0538fSMark Fasheh 		     (unsigned long long) right_path->p_node[start].bh->b_blocknr,
2126dcd0538fSMark Fasheh 		     right_path->p_tree_depth);
2127dcd0538fSMark Fasheh 
2128dcd0538fSMark Fasheh 		ret = ocfs2_extend_rotate_transaction(handle, start,
2129328d5752SMark Fasheh 						      orig_credits, right_path);
2130dcd0538fSMark Fasheh 		if (ret) {
2131dcd0538fSMark Fasheh 			mlog_errno(ret);
2132dcd0538fSMark Fasheh 			goto out;
2133dcd0538fSMark Fasheh 		}
2134dcd0538fSMark Fasheh 
2135dcd0538fSMark Fasheh 		ret = ocfs2_rotate_subtree_right(inode, handle, left_path,
2136dcd0538fSMark Fasheh 						 right_path, start);
2137dcd0538fSMark Fasheh 		if (ret) {
2138dcd0538fSMark Fasheh 			mlog_errno(ret);
2139dcd0538fSMark Fasheh 			goto out;
2140dcd0538fSMark Fasheh 		}
2141dcd0538fSMark Fasheh 
2142328d5752SMark Fasheh 		if (split != SPLIT_NONE &&
2143328d5752SMark Fasheh 		    ocfs2_leftmost_rec_contains(path_leaf_el(right_path),
2144328d5752SMark Fasheh 						insert_cpos)) {
2145328d5752SMark Fasheh 			/*
2146328d5752SMark Fasheh 			 * A rotate moves the rightmost left leaf
2147328d5752SMark Fasheh 			 * record over to the leftmost right leaf
2148328d5752SMark Fasheh 			 * slot. If we're doing an extent split
2149328d5752SMark Fasheh 			 * instead of a real insert, then we have to
2150328d5752SMark Fasheh 			 * check that the extent to be split wasn't
2151328d5752SMark Fasheh 			 * just moved over. If it was, then we can
2152328d5752SMark Fasheh 			 * exit here, passing left_path back -
2153328d5752SMark Fasheh 			 * ocfs2_split_extent() is smart enough to
2154328d5752SMark Fasheh 			 * search both leaves.
2155328d5752SMark Fasheh 			 */
2156328d5752SMark Fasheh 			*ret_left_path = left_path;
2157328d5752SMark Fasheh 			goto out_ret_path;
2158328d5752SMark Fasheh 		}
2159328d5752SMark Fasheh 
2160dcd0538fSMark Fasheh 		/*
2161dcd0538fSMark Fasheh 		 * There is no need to re-read the next right path
2162dcd0538fSMark Fasheh 		 * as we know that it'll be our current left
2163dcd0538fSMark Fasheh 		 * path. Optimize by copying values instead.
2164dcd0538fSMark Fasheh 		 */
2165dcd0538fSMark Fasheh 		ocfs2_mv_path(right_path, left_path);
2166dcd0538fSMark Fasheh 
2167dcd0538fSMark Fasheh 		ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path,
2168dcd0538fSMark Fasheh 						    &cpos);
2169dcd0538fSMark Fasheh 		if (ret) {
2170dcd0538fSMark Fasheh 			mlog_errno(ret);
2171dcd0538fSMark Fasheh 			goto out;
2172dcd0538fSMark Fasheh 		}
2173dcd0538fSMark Fasheh 	}
2174dcd0538fSMark Fasheh 
2175dcd0538fSMark Fasheh out:
2176dcd0538fSMark Fasheh 	ocfs2_free_path(left_path);
2177dcd0538fSMark Fasheh 
2178dcd0538fSMark Fasheh out_ret_path:
2179dcd0538fSMark Fasheh 	return ret;
2180dcd0538fSMark Fasheh }
2181dcd0538fSMark Fasheh 
2182328d5752SMark Fasheh static void ocfs2_update_edge_lengths(struct inode *inode, handle_t *handle,
2183328d5752SMark Fasheh 				      struct ocfs2_path *path)
2184328d5752SMark Fasheh {
2185328d5752SMark Fasheh 	int i, idx;
2186328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec;
2187328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
2188328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
2189328d5752SMark Fasheh 	u32 range;
2190328d5752SMark Fasheh 
2191328d5752SMark Fasheh 	/* Path should always be rightmost. */
2192328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
2193328d5752SMark Fasheh 	BUG_ON(eb->h_next_leaf_blk != 0ULL);
2194328d5752SMark Fasheh 
2195328d5752SMark Fasheh 	el = &eb->h_list;
2196328d5752SMark Fasheh 	BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
2197328d5752SMark Fasheh 	idx = le16_to_cpu(el->l_next_free_rec) - 1;
2198328d5752SMark Fasheh 	rec = &el->l_recs[idx];
2199328d5752SMark Fasheh 	range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2200328d5752SMark Fasheh 
2201328d5752SMark Fasheh 	for (i = 0; i < path->p_tree_depth; i++) {
2202328d5752SMark Fasheh 		el = path->p_node[i].el;
2203328d5752SMark Fasheh 		idx = le16_to_cpu(el->l_next_free_rec) - 1;
2204328d5752SMark Fasheh 		rec = &el->l_recs[idx];
2205328d5752SMark Fasheh 
2206328d5752SMark Fasheh 		rec->e_int_clusters = cpu_to_le32(range);
2207328d5752SMark Fasheh 		le32_add_cpu(&rec->e_int_clusters, -le32_to_cpu(rec->e_cpos));
2208328d5752SMark Fasheh 
2209328d5752SMark Fasheh 		ocfs2_journal_dirty(handle, path->p_node[i].bh);
2210328d5752SMark Fasheh 	}
2211328d5752SMark Fasheh }
2212328d5752SMark Fasheh 
2213328d5752SMark Fasheh static void ocfs2_unlink_path(struct inode *inode, handle_t *handle,
2214328d5752SMark Fasheh 			      struct ocfs2_cached_dealloc_ctxt *dealloc,
2215328d5752SMark Fasheh 			      struct ocfs2_path *path, int unlink_start)
2216328d5752SMark Fasheh {
2217328d5752SMark Fasheh 	int ret, i;
2218328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
2219328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
2220328d5752SMark Fasheh 	struct buffer_head *bh;
2221328d5752SMark Fasheh 
2222328d5752SMark Fasheh 	for(i = unlink_start; i < path_num_items(path); i++) {
2223328d5752SMark Fasheh 		bh = path->p_node[i].bh;
2224328d5752SMark Fasheh 
2225328d5752SMark Fasheh 		eb = (struct ocfs2_extent_block *)bh->b_data;
2226328d5752SMark Fasheh 		/*
2227328d5752SMark Fasheh 		 * Not all nodes might have had their final count
2228328d5752SMark Fasheh 		 * decremented by the caller - handle this here.
2229328d5752SMark Fasheh 		 */
2230328d5752SMark Fasheh 		el = &eb->h_list;
2231328d5752SMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) > 1) {
2232328d5752SMark Fasheh 			mlog(ML_ERROR,
2233328d5752SMark Fasheh 			     "Inode %llu, attempted to remove extent block "
2234328d5752SMark Fasheh 			     "%llu with %u records\n",
2235328d5752SMark Fasheh 			     (unsigned long long)OCFS2_I(inode)->ip_blkno,
2236328d5752SMark Fasheh 			     (unsigned long long)le64_to_cpu(eb->h_blkno),
2237328d5752SMark Fasheh 			     le16_to_cpu(el->l_next_free_rec));
2238328d5752SMark Fasheh 
2239328d5752SMark Fasheh 			ocfs2_journal_dirty(handle, bh);
2240328d5752SMark Fasheh 			ocfs2_remove_from_cache(inode, bh);
2241328d5752SMark Fasheh 			continue;
2242328d5752SMark Fasheh 		}
2243328d5752SMark Fasheh 
2244328d5752SMark Fasheh 		el->l_next_free_rec = 0;
2245328d5752SMark Fasheh 		memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2246328d5752SMark Fasheh 
2247328d5752SMark Fasheh 		ocfs2_journal_dirty(handle, bh);
2248328d5752SMark Fasheh 
2249328d5752SMark Fasheh 		ret = ocfs2_cache_extent_block_free(dealloc, eb);
2250328d5752SMark Fasheh 		if (ret)
2251328d5752SMark Fasheh 			mlog_errno(ret);
2252328d5752SMark Fasheh 
2253328d5752SMark Fasheh 		ocfs2_remove_from_cache(inode, bh);
2254328d5752SMark Fasheh 	}
2255328d5752SMark Fasheh }
2256328d5752SMark Fasheh 
2257328d5752SMark Fasheh static void ocfs2_unlink_subtree(struct inode *inode, handle_t *handle,
2258328d5752SMark Fasheh 				 struct ocfs2_path *left_path,
2259328d5752SMark Fasheh 				 struct ocfs2_path *right_path,
2260328d5752SMark Fasheh 				 int subtree_index,
2261328d5752SMark Fasheh 				 struct ocfs2_cached_dealloc_ctxt *dealloc)
2262328d5752SMark Fasheh {
2263328d5752SMark Fasheh 	int i;
2264328d5752SMark Fasheh 	struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
2265328d5752SMark Fasheh 	struct ocfs2_extent_list *root_el = left_path->p_node[subtree_index].el;
2266328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
2267328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
2268328d5752SMark Fasheh 
2269328d5752SMark Fasheh 	el = path_leaf_el(left_path);
2270328d5752SMark Fasheh 
2271328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)right_path->p_node[subtree_index + 1].bh->b_data;
2272328d5752SMark Fasheh 
2273328d5752SMark Fasheh 	for(i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
2274328d5752SMark Fasheh 		if (root_el->l_recs[i].e_blkno == eb->h_blkno)
2275328d5752SMark Fasheh 			break;
2276328d5752SMark Fasheh 
2277328d5752SMark Fasheh 	BUG_ON(i >= le16_to_cpu(root_el->l_next_free_rec));
2278328d5752SMark Fasheh 
2279328d5752SMark Fasheh 	memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
2280328d5752SMark Fasheh 	le16_add_cpu(&root_el->l_next_free_rec, -1);
2281328d5752SMark Fasheh 
2282328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2283328d5752SMark Fasheh 	eb->h_next_leaf_blk = 0;
2284328d5752SMark Fasheh 
2285328d5752SMark Fasheh 	ocfs2_journal_dirty(handle, root_bh);
2286328d5752SMark Fasheh 	ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2287328d5752SMark Fasheh 
2288328d5752SMark Fasheh 	ocfs2_unlink_path(inode, handle, dealloc, right_path,
2289328d5752SMark Fasheh 			  subtree_index + 1);
2290328d5752SMark Fasheh }
2291328d5752SMark Fasheh 
2292328d5752SMark Fasheh static int ocfs2_rotate_subtree_left(struct inode *inode, handle_t *handle,
2293328d5752SMark Fasheh 				     struct ocfs2_path *left_path,
2294328d5752SMark Fasheh 				     struct ocfs2_path *right_path,
2295328d5752SMark Fasheh 				     int subtree_index,
2296328d5752SMark Fasheh 				     struct ocfs2_cached_dealloc_ctxt *dealloc,
2297e7d4cb6bSTao Ma 				     int *deleted,
2298e7d4cb6bSTao Ma 				     struct ocfs2_extent_tree *et)
2299328d5752SMark Fasheh {
2300328d5752SMark Fasheh 	int ret, i, del_right_subtree = 0, right_has_empty = 0;
2301e7d4cb6bSTao Ma 	struct buffer_head *root_bh, *et_root_bh = path_root_bh(right_path);
2302328d5752SMark Fasheh 	struct ocfs2_extent_list *right_leaf_el, *left_leaf_el;
2303328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
2304328d5752SMark Fasheh 
2305328d5752SMark Fasheh 	*deleted = 0;
2306328d5752SMark Fasheh 
2307328d5752SMark Fasheh 	right_leaf_el = path_leaf_el(right_path);
2308328d5752SMark Fasheh 	left_leaf_el = path_leaf_el(left_path);
2309328d5752SMark Fasheh 	root_bh = left_path->p_node[subtree_index].bh;
2310328d5752SMark Fasheh 	BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2311328d5752SMark Fasheh 
2312328d5752SMark Fasheh 	if (!ocfs2_is_empty_extent(&left_leaf_el->l_recs[0]))
2313328d5752SMark Fasheh 		return 0;
2314328d5752SMark Fasheh 
2315328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)path_leaf_bh(right_path)->b_data;
2316328d5752SMark Fasheh 	if (ocfs2_is_empty_extent(&right_leaf_el->l_recs[0])) {
2317328d5752SMark Fasheh 		/*
2318328d5752SMark Fasheh 		 * It's legal for us to proceed if the right leaf is
2319328d5752SMark Fasheh 		 * the rightmost one and it has an empty extent. There
2320328d5752SMark Fasheh 		 * are two cases to handle - whether the leaf will be
2321328d5752SMark Fasheh 		 * empty after removal or not. If the leaf isn't empty
2322328d5752SMark Fasheh 		 * then just remove the empty extent up front. The
2323328d5752SMark Fasheh 		 * next block will handle empty leaves by flagging
2324328d5752SMark Fasheh 		 * them for unlink.
2325328d5752SMark Fasheh 		 *
2326328d5752SMark Fasheh 		 * Non rightmost leaves will throw -EAGAIN and the
2327328d5752SMark Fasheh 		 * caller can manually move the subtree and retry.
2328328d5752SMark Fasheh 		 */
2329328d5752SMark Fasheh 
2330328d5752SMark Fasheh 		if (eb->h_next_leaf_blk != 0ULL)
2331328d5752SMark Fasheh 			return -EAGAIN;
2332328d5752SMark Fasheh 
2333328d5752SMark Fasheh 		if (le16_to_cpu(right_leaf_el->l_next_free_rec) > 1) {
2334328d5752SMark Fasheh 			ret = ocfs2_journal_access(handle, inode,
2335328d5752SMark Fasheh 						   path_leaf_bh(right_path),
2336328d5752SMark Fasheh 						   OCFS2_JOURNAL_ACCESS_WRITE);
2337328d5752SMark Fasheh 			if (ret) {
2338328d5752SMark Fasheh 				mlog_errno(ret);
2339328d5752SMark Fasheh 				goto out;
2340328d5752SMark Fasheh 			}
2341328d5752SMark Fasheh 
2342328d5752SMark Fasheh 			ocfs2_remove_empty_extent(right_leaf_el);
2343328d5752SMark Fasheh 		} else
2344328d5752SMark Fasheh 			right_has_empty = 1;
2345328d5752SMark Fasheh 	}
2346328d5752SMark Fasheh 
2347328d5752SMark Fasheh 	if (eb->h_next_leaf_blk == 0ULL &&
2348328d5752SMark Fasheh 	    le16_to_cpu(right_leaf_el->l_next_free_rec) == 1) {
2349328d5752SMark Fasheh 		/*
2350328d5752SMark Fasheh 		 * We have to update i_last_eb_blk during the meta
2351328d5752SMark Fasheh 		 * data delete.
2352328d5752SMark Fasheh 		 */
2353e7d4cb6bSTao Ma 		ret = ocfs2_journal_access(handle, inode, et_root_bh,
2354328d5752SMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
2355328d5752SMark Fasheh 		if (ret) {
2356328d5752SMark Fasheh 			mlog_errno(ret);
2357328d5752SMark Fasheh 			goto out;
2358328d5752SMark Fasheh 		}
2359328d5752SMark Fasheh 
2360328d5752SMark Fasheh 		del_right_subtree = 1;
2361328d5752SMark Fasheh 	}
2362328d5752SMark Fasheh 
2363328d5752SMark Fasheh 	/*
2364328d5752SMark Fasheh 	 * Getting here with an empty extent in the right path implies
2365328d5752SMark Fasheh 	 * that it's the rightmost path and will be deleted.
2366328d5752SMark Fasheh 	 */
2367328d5752SMark Fasheh 	BUG_ON(right_has_empty && !del_right_subtree);
2368328d5752SMark Fasheh 
2369328d5752SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, root_bh,
2370328d5752SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
2371328d5752SMark Fasheh 	if (ret) {
2372328d5752SMark Fasheh 		mlog_errno(ret);
2373328d5752SMark Fasheh 		goto out;
2374328d5752SMark Fasheh 	}
2375328d5752SMark Fasheh 
2376328d5752SMark Fasheh 	for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2377328d5752SMark Fasheh 		ret = ocfs2_journal_access(handle, inode,
2378328d5752SMark Fasheh 					   right_path->p_node[i].bh,
2379328d5752SMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
2380328d5752SMark Fasheh 		if (ret) {
2381328d5752SMark Fasheh 			mlog_errno(ret);
2382328d5752SMark Fasheh 			goto out;
2383328d5752SMark Fasheh 		}
2384328d5752SMark Fasheh 
2385328d5752SMark Fasheh 		ret = ocfs2_journal_access(handle, inode,
2386328d5752SMark Fasheh 					   left_path->p_node[i].bh,
2387328d5752SMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
2388328d5752SMark Fasheh 		if (ret) {
2389328d5752SMark Fasheh 			mlog_errno(ret);
2390328d5752SMark Fasheh 			goto out;
2391328d5752SMark Fasheh 		}
2392328d5752SMark Fasheh 	}
2393328d5752SMark Fasheh 
2394328d5752SMark Fasheh 	if (!right_has_empty) {
2395328d5752SMark Fasheh 		/*
2396328d5752SMark Fasheh 		 * Only do this if we're moving a real
2397328d5752SMark Fasheh 		 * record. Otherwise, the action is delayed until
2398328d5752SMark Fasheh 		 * after removal of the right path in which case we
2399328d5752SMark Fasheh 		 * can do a simple shift to remove the empty extent.
2400328d5752SMark Fasheh 		 */
2401328d5752SMark Fasheh 		ocfs2_rotate_leaf(left_leaf_el, &right_leaf_el->l_recs[0]);
2402328d5752SMark Fasheh 		memset(&right_leaf_el->l_recs[0], 0,
2403328d5752SMark Fasheh 		       sizeof(struct ocfs2_extent_rec));
2404328d5752SMark Fasheh 	}
2405328d5752SMark Fasheh 	if (eb->h_next_leaf_blk == 0ULL) {
2406328d5752SMark Fasheh 		/*
2407328d5752SMark Fasheh 		 * Move recs over to get rid of empty extent, decrease
2408328d5752SMark Fasheh 		 * next_free. This is allowed to remove the last
2409328d5752SMark Fasheh 		 * extent in our leaf (setting l_next_free_rec to
2410328d5752SMark Fasheh 		 * zero) - the delete code below won't care.
2411328d5752SMark Fasheh 		 */
2412328d5752SMark Fasheh 		ocfs2_remove_empty_extent(right_leaf_el);
2413328d5752SMark Fasheh 	}
2414328d5752SMark Fasheh 
2415328d5752SMark Fasheh 	ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2416328d5752SMark Fasheh 	if (ret)
2417328d5752SMark Fasheh 		mlog_errno(ret);
2418328d5752SMark Fasheh 	ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
2419328d5752SMark Fasheh 	if (ret)
2420328d5752SMark Fasheh 		mlog_errno(ret);
2421328d5752SMark Fasheh 
2422328d5752SMark Fasheh 	if (del_right_subtree) {
2423328d5752SMark Fasheh 		ocfs2_unlink_subtree(inode, handle, left_path, right_path,
2424328d5752SMark Fasheh 				     subtree_index, dealloc);
2425328d5752SMark Fasheh 		ocfs2_update_edge_lengths(inode, handle, left_path);
2426328d5752SMark Fasheh 
2427328d5752SMark Fasheh 		eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
242835dc0aa3SJoel Becker 		ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
2429328d5752SMark Fasheh 
2430328d5752SMark Fasheh 		/*
2431328d5752SMark Fasheh 		 * Removal of the extent in the left leaf was skipped
2432328d5752SMark Fasheh 		 * above so we could delete the right path
2433328d5752SMark Fasheh 		 * 1st.
2434328d5752SMark Fasheh 		 */
2435328d5752SMark Fasheh 		if (right_has_empty)
2436328d5752SMark Fasheh 			ocfs2_remove_empty_extent(left_leaf_el);
2437328d5752SMark Fasheh 
2438e7d4cb6bSTao Ma 		ret = ocfs2_journal_dirty(handle, et_root_bh);
2439328d5752SMark Fasheh 		if (ret)
2440328d5752SMark Fasheh 			mlog_errno(ret);
2441328d5752SMark Fasheh 
2442328d5752SMark Fasheh 		*deleted = 1;
2443328d5752SMark Fasheh 	} else
2444328d5752SMark Fasheh 		ocfs2_complete_edge_insert(inode, handle, left_path, right_path,
2445328d5752SMark Fasheh 					   subtree_index);
2446328d5752SMark Fasheh 
2447328d5752SMark Fasheh out:
2448328d5752SMark Fasheh 	return ret;
2449328d5752SMark Fasheh }
2450328d5752SMark Fasheh 
2451328d5752SMark Fasheh /*
2452328d5752SMark Fasheh  * Given a full path, determine what cpos value would return us a path
2453328d5752SMark Fasheh  * containing the leaf immediately to the right of the current one.
2454328d5752SMark Fasheh  *
2455328d5752SMark Fasheh  * Will return zero if the path passed in is already the rightmost path.
2456328d5752SMark Fasheh  *
2457328d5752SMark Fasheh  * This looks similar, but is subtly different to
2458328d5752SMark Fasheh  * ocfs2_find_cpos_for_left_leaf().
2459328d5752SMark Fasheh  */
2460328d5752SMark Fasheh static int ocfs2_find_cpos_for_right_leaf(struct super_block *sb,
2461328d5752SMark Fasheh 					  struct ocfs2_path *path, u32 *cpos)
2462328d5752SMark Fasheh {
2463328d5752SMark Fasheh 	int i, j, ret = 0;
2464328d5752SMark Fasheh 	u64 blkno;
2465328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
2466328d5752SMark Fasheh 
2467328d5752SMark Fasheh 	*cpos = 0;
2468328d5752SMark Fasheh 
2469328d5752SMark Fasheh 	if (path->p_tree_depth == 0)
2470328d5752SMark Fasheh 		return 0;
2471328d5752SMark Fasheh 
2472328d5752SMark Fasheh 	blkno = path_leaf_bh(path)->b_blocknr;
2473328d5752SMark Fasheh 
2474328d5752SMark Fasheh 	/* Start at the tree node just above the leaf and work our way up. */
2475328d5752SMark Fasheh 	i = path->p_tree_depth - 1;
2476328d5752SMark Fasheh 	while (i >= 0) {
2477328d5752SMark Fasheh 		int next_free;
2478328d5752SMark Fasheh 
2479328d5752SMark Fasheh 		el = path->p_node[i].el;
2480328d5752SMark Fasheh 
2481328d5752SMark Fasheh 		/*
2482328d5752SMark Fasheh 		 * Find the extent record just after the one in our
2483328d5752SMark Fasheh 		 * path.
2484328d5752SMark Fasheh 		 */
2485328d5752SMark Fasheh 		next_free = le16_to_cpu(el->l_next_free_rec);
2486328d5752SMark Fasheh 		for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2487328d5752SMark Fasheh 			if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2488328d5752SMark Fasheh 				if (j == (next_free - 1)) {
2489328d5752SMark Fasheh 					if (i == 0) {
2490328d5752SMark Fasheh 						/*
2491328d5752SMark Fasheh 						 * We've determined that the
2492328d5752SMark Fasheh 						 * path specified is already
2493328d5752SMark Fasheh 						 * the rightmost one - return a
2494328d5752SMark Fasheh 						 * cpos of zero.
2495328d5752SMark Fasheh 						 */
2496328d5752SMark Fasheh 						goto out;
2497328d5752SMark Fasheh 					}
2498328d5752SMark Fasheh 					/*
2499328d5752SMark Fasheh 					 * The rightmost record points to our
2500328d5752SMark Fasheh 					 * leaf - we need to travel up the
2501328d5752SMark Fasheh 					 * tree one level.
2502328d5752SMark Fasheh 					 */
2503328d5752SMark Fasheh 					goto next_node;
2504328d5752SMark Fasheh 				}
2505328d5752SMark Fasheh 
2506328d5752SMark Fasheh 				*cpos = le32_to_cpu(el->l_recs[j + 1].e_cpos);
2507328d5752SMark Fasheh 				goto out;
2508328d5752SMark Fasheh 			}
2509328d5752SMark Fasheh 		}
2510328d5752SMark Fasheh 
2511328d5752SMark Fasheh 		/*
2512328d5752SMark Fasheh 		 * If we got here, we never found a valid node where
2513328d5752SMark Fasheh 		 * the tree indicated one should be.
2514328d5752SMark Fasheh 		 */
2515328d5752SMark Fasheh 		ocfs2_error(sb,
2516328d5752SMark Fasheh 			    "Invalid extent tree at extent block %llu\n",
2517328d5752SMark Fasheh 			    (unsigned long long)blkno);
2518328d5752SMark Fasheh 		ret = -EROFS;
2519328d5752SMark Fasheh 		goto out;
2520328d5752SMark Fasheh 
2521328d5752SMark Fasheh next_node:
2522328d5752SMark Fasheh 		blkno = path->p_node[i].bh->b_blocknr;
2523328d5752SMark Fasheh 		i--;
2524328d5752SMark Fasheh 	}
2525328d5752SMark Fasheh 
2526328d5752SMark Fasheh out:
2527328d5752SMark Fasheh 	return ret;
2528328d5752SMark Fasheh }
2529328d5752SMark Fasheh 
2530328d5752SMark Fasheh static int ocfs2_rotate_rightmost_leaf_left(struct inode *inode,
2531328d5752SMark Fasheh 					    handle_t *handle,
2532328d5752SMark Fasheh 					    struct buffer_head *bh,
2533328d5752SMark Fasheh 					    struct ocfs2_extent_list *el)
2534328d5752SMark Fasheh {
2535328d5752SMark Fasheh 	int ret;
2536328d5752SMark Fasheh 
2537328d5752SMark Fasheh 	if (!ocfs2_is_empty_extent(&el->l_recs[0]))
2538328d5752SMark Fasheh 		return 0;
2539328d5752SMark Fasheh 
2540328d5752SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, bh,
2541328d5752SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
2542328d5752SMark Fasheh 	if (ret) {
2543328d5752SMark Fasheh 		mlog_errno(ret);
2544328d5752SMark Fasheh 		goto out;
2545328d5752SMark Fasheh 	}
2546328d5752SMark Fasheh 
2547328d5752SMark Fasheh 	ocfs2_remove_empty_extent(el);
2548328d5752SMark Fasheh 
2549328d5752SMark Fasheh 	ret = ocfs2_journal_dirty(handle, bh);
2550328d5752SMark Fasheh 	if (ret)
2551328d5752SMark Fasheh 		mlog_errno(ret);
2552328d5752SMark Fasheh 
2553328d5752SMark Fasheh out:
2554328d5752SMark Fasheh 	return ret;
2555328d5752SMark Fasheh }
2556328d5752SMark Fasheh 
2557328d5752SMark Fasheh static int __ocfs2_rotate_tree_left(struct inode *inode,
2558328d5752SMark Fasheh 				    handle_t *handle, int orig_credits,
2559328d5752SMark Fasheh 				    struct ocfs2_path *path,
2560328d5752SMark Fasheh 				    struct ocfs2_cached_dealloc_ctxt *dealloc,
2561e7d4cb6bSTao Ma 				    struct ocfs2_path **empty_extent_path,
2562e7d4cb6bSTao Ma 				    struct ocfs2_extent_tree *et)
2563328d5752SMark Fasheh {
2564328d5752SMark Fasheh 	int ret, subtree_root, deleted;
2565328d5752SMark Fasheh 	u32 right_cpos;
2566328d5752SMark Fasheh 	struct ocfs2_path *left_path = NULL;
2567328d5752SMark Fasheh 	struct ocfs2_path *right_path = NULL;
2568328d5752SMark Fasheh 
2569328d5752SMark Fasheh 	BUG_ON(!ocfs2_is_empty_extent(&(path_leaf_el(path)->l_recs[0])));
2570328d5752SMark Fasheh 
2571328d5752SMark Fasheh 	*empty_extent_path = NULL;
2572328d5752SMark Fasheh 
2573328d5752SMark Fasheh 	ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, path,
2574328d5752SMark Fasheh 					     &right_cpos);
2575328d5752SMark Fasheh 	if (ret) {
2576328d5752SMark Fasheh 		mlog_errno(ret);
2577328d5752SMark Fasheh 		goto out;
2578328d5752SMark Fasheh 	}
2579328d5752SMark Fasheh 
2580328d5752SMark Fasheh 	left_path = ocfs2_new_path(path_root_bh(path),
2581328d5752SMark Fasheh 				   path_root_el(path));
2582328d5752SMark Fasheh 	if (!left_path) {
2583328d5752SMark Fasheh 		ret = -ENOMEM;
2584328d5752SMark Fasheh 		mlog_errno(ret);
2585328d5752SMark Fasheh 		goto out;
2586328d5752SMark Fasheh 	}
2587328d5752SMark Fasheh 
2588328d5752SMark Fasheh 	ocfs2_cp_path(left_path, path);
2589328d5752SMark Fasheh 
2590328d5752SMark Fasheh 	right_path = ocfs2_new_path(path_root_bh(path),
2591328d5752SMark Fasheh 				    path_root_el(path));
2592328d5752SMark Fasheh 	if (!right_path) {
2593328d5752SMark Fasheh 		ret = -ENOMEM;
2594328d5752SMark Fasheh 		mlog_errno(ret);
2595328d5752SMark Fasheh 		goto out;
2596328d5752SMark Fasheh 	}
2597328d5752SMark Fasheh 
2598328d5752SMark Fasheh 	while (right_cpos) {
2599328d5752SMark Fasheh 		ret = ocfs2_find_path(inode, right_path, right_cpos);
2600328d5752SMark Fasheh 		if (ret) {
2601328d5752SMark Fasheh 			mlog_errno(ret);
2602328d5752SMark Fasheh 			goto out;
2603328d5752SMark Fasheh 		}
2604328d5752SMark Fasheh 
2605328d5752SMark Fasheh 		subtree_root = ocfs2_find_subtree_root(inode, left_path,
2606328d5752SMark Fasheh 						       right_path);
2607328d5752SMark Fasheh 
2608328d5752SMark Fasheh 		mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n",
2609328d5752SMark Fasheh 		     subtree_root,
2610328d5752SMark Fasheh 		     (unsigned long long)
2611328d5752SMark Fasheh 		     right_path->p_node[subtree_root].bh->b_blocknr,
2612328d5752SMark Fasheh 		     right_path->p_tree_depth);
2613328d5752SMark Fasheh 
2614328d5752SMark Fasheh 		ret = ocfs2_extend_rotate_transaction(handle, subtree_root,
2615328d5752SMark Fasheh 						      orig_credits, left_path);
2616328d5752SMark Fasheh 		if (ret) {
2617328d5752SMark Fasheh 			mlog_errno(ret);
2618328d5752SMark Fasheh 			goto out;
2619328d5752SMark Fasheh 		}
2620328d5752SMark Fasheh 
2621e8aed345SMark Fasheh 		/*
2622e8aed345SMark Fasheh 		 * Caller might still want to make changes to the
2623e8aed345SMark Fasheh 		 * tree root, so re-add it to the journal here.
2624e8aed345SMark Fasheh 		 */
2625e8aed345SMark Fasheh 		ret = ocfs2_journal_access(handle, inode,
2626e8aed345SMark Fasheh 					   path_root_bh(left_path),
2627e8aed345SMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
2628e8aed345SMark Fasheh 		if (ret) {
2629e8aed345SMark Fasheh 			mlog_errno(ret);
2630e8aed345SMark Fasheh 			goto out;
2631e8aed345SMark Fasheh 		}
2632e8aed345SMark Fasheh 
2633328d5752SMark Fasheh 		ret = ocfs2_rotate_subtree_left(inode, handle, left_path,
2634328d5752SMark Fasheh 						right_path, subtree_root,
2635e7d4cb6bSTao Ma 						dealloc, &deleted, et);
2636328d5752SMark Fasheh 		if (ret == -EAGAIN) {
2637328d5752SMark Fasheh 			/*
2638328d5752SMark Fasheh 			 * The rotation has to temporarily stop due to
2639328d5752SMark Fasheh 			 * the right subtree having an empty
2640328d5752SMark Fasheh 			 * extent. Pass it back to the caller for a
2641328d5752SMark Fasheh 			 * fixup.
2642328d5752SMark Fasheh 			 */
2643328d5752SMark Fasheh 			*empty_extent_path = right_path;
2644328d5752SMark Fasheh 			right_path = NULL;
2645328d5752SMark Fasheh 			goto out;
2646328d5752SMark Fasheh 		}
2647328d5752SMark Fasheh 		if (ret) {
2648328d5752SMark Fasheh 			mlog_errno(ret);
2649328d5752SMark Fasheh 			goto out;
2650328d5752SMark Fasheh 		}
2651328d5752SMark Fasheh 
2652328d5752SMark Fasheh 		/*
2653328d5752SMark Fasheh 		 * The subtree rotate might have removed records on
2654328d5752SMark Fasheh 		 * the rightmost edge. If so, then rotation is
2655328d5752SMark Fasheh 		 * complete.
2656328d5752SMark Fasheh 		 */
2657328d5752SMark Fasheh 		if (deleted)
2658328d5752SMark Fasheh 			break;
2659328d5752SMark Fasheh 
2660328d5752SMark Fasheh 		ocfs2_mv_path(left_path, right_path);
2661328d5752SMark Fasheh 
2662328d5752SMark Fasheh 		ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, left_path,
2663328d5752SMark Fasheh 						     &right_cpos);
2664328d5752SMark Fasheh 		if (ret) {
2665328d5752SMark Fasheh 			mlog_errno(ret);
2666328d5752SMark Fasheh 			goto out;
2667328d5752SMark Fasheh 		}
2668328d5752SMark Fasheh 	}
2669328d5752SMark Fasheh 
2670328d5752SMark Fasheh out:
2671328d5752SMark Fasheh 	ocfs2_free_path(right_path);
2672328d5752SMark Fasheh 	ocfs2_free_path(left_path);
2673328d5752SMark Fasheh 
2674328d5752SMark Fasheh 	return ret;
2675328d5752SMark Fasheh }
2676328d5752SMark Fasheh 
2677328d5752SMark Fasheh static int ocfs2_remove_rightmost_path(struct inode *inode, handle_t *handle,
2678328d5752SMark Fasheh 				struct ocfs2_path *path,
2679e7d4cb6bSTao Ma 				struct ocfs2_cached_dealloc_ctxt *dealloc,
2680e7d4cb6bSTao Ma 				struct ocfs2_extent_tree *et)
2681328d5752SMark Fasheh {
2682328d5752SMark Fasheh 	int ret, subtree_index;
2683328d5752SMark Fasheh 	u32 cpos;
2684328d5752SMark Fasheh 	struct ocfs2_path *left_path = NULL;
2685328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
2686328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
2687328d5752SMark Fasheh 
2688328d5752SMark Fasheh 
268935dc0aa3SJoel Becker 	ret = ocfs2_et_sanity_check(inode, et);
2690e7d4cb6bSTao Ma 	if (ret)
2691e7d4cb6bSTao Ma 		goto out;
2692328d5752SMark Fasheh 	/*
2693328d5752SMark Fasheh 	 * There's two ways we handle this depending on
2694328d5752SMark Fasheh 	 * whether path is the only existing one.
2695328d5752SMark Fasheh 	 */
2696328d5752SMark Fasheh 	ret = ocfs2_extend_rotate_transaction(handle, 0,
2697328d5752SMark Fasheh 					      handle->h_buffer_credits,
2698328d5752SMark Fasheh 					      path);
2699328d5752SMark Fasheh 	if (ret) {
2700328d5752SMark Fasheh 		mlog_errno(ret);
2701328d5752SMark Fasheh 		goto out;
2702328d5752SMark Fasheh 	}
2703328d5752SMark Fasheh 
2704328d5752SMark Fasheh 	ret = ocfs2_journal_access_path(inode, handle, path);
2705328d5752SMark Fasheh 	if (ret) {
2706328d5752SMark Fasheh 		mlog_errno(ret);
2707328d5752SMark Fasheh 		goto out;
2708328d5752SMark Fasheh 	}
2709328d5752SMark Fasheh 
2710328d5752SMark Fasheh 	ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, &cpos);
2711328d5752SMark Fasheh 	if (ret) {
2712328d5752SMark Fasheh 		mlog_errno(ret);
2713328d5752SMark Fasheh 		goto out;
2714328d5752SMark Fasheh 	}
2715328d5752SMark Fasheh 
2716328d5752SMark Fasheh 	if (cpos) {
2717328d5752SMark Fasheh 		/*
2718328d5752SMark Fasheh 		 * We have a path to the left of this one - it needs
2719328d5752SMark Fasheh 		 * an update too.
2720328d5752SMark Fasheh 		 */
2721328d5752SMark Fasheh 		left_path = ocfs2_new_path(path_root_bh(path),
2722328d5752SMark Fasheh 					   path_root_el(path));
2723328d5752SMark Fasheh 		if (!left_path) {
2724328d5752SMark Fasheh 			ret = -ENOMEM;
2725328d5752SMark Fasheh 			mlog_errno(ret);
2726328d5752SMark Fasheh 			goto out;
2727328d5752SMark Fasheh 		}
2728328d5752SMark Fasheh 
2729328d5752SMark Fasheh 		ret = ocfs2_find_path(inode, left_path, cpos);
2730328d5752SMark Fasheh 		if (ret) {
2731328d5752SMark Fasheh 			mlog_errno(ret);
2732328d5752SMark Fasheh 			goto out;
2733328d5752SMark Fasheh 		}
2734328d5752SMark Fasheh 
2735328d5752SMark Fasheh 		ret = ocfs2_journal_access_path(inode, handle, left_path);
2736328d5752SMark Fasheh 		if (ret) {
2737328d5752SMark Fasheh 			mlog_errno(ret);
2738328d5752SMark Fasheh 			goto out;
2739328d5752SMark Fasheh 		}
2740328d5752SMark Fasheh 
2741328d5752SMark Fasheh 		subtree_index = ocfs2_find_subtree_root(inode, left_path, path);
2742328d5752SMark Fasheh 
2743328d5752SMark Fasheh 		ocfs2_unlink_subtree(inode, handle, left_path, path,
2744328d5752SMark Fasheh 				     subtree_index, dealloc);
2745328d5752SMark Fasheh 		ocfs2_update_edge_lengths(inode, handle, left_path);
2746328d5752SMark Fasheh 
2747328d5752SMark Fasheh 		eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
274835dc0aa3SJoel Becker 		ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
2749328d5752SMark Fasheh 	} else {
2750328d5752SMark Fasheh 		/*
2751328d5752SMark Fasheh 		 * 'path' is also the leftmost path which
2752328d5752SMark Fasheh 		 * means it must be the only one. This gets
2753328d5752SMark Fasheh 		 * handled differently because we want to
2754328d5752SMark Fasheh 		 * revert the inode back to having extents
2755328d5752SMark Fasheh 		 * in-line.
2756328d5752SMark Fasheh 		 */
2757328d5752SMark Fasheh 		ocfs2_unlink_path(inode, handle, dealloc, path, 1);
2758328d5752SMark Fasheh 
2759ce1d9ea6SJoel Becker 		el = et->et_root_el;
2760328d5752SMark Fasheh 		el->l_tree_depth = 0;
2761328d5752SMark Fasheh 		el->l_next_free_rec = 0;
2762328d5752SMark Fasheh 		memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2763328d5752SMark Fasheh 
276435dc0aa3SJoel Becker 		ocfs2_et_set_last_eb_blk(et, 0);
2765328d5752SMark Fasheh 	}
2766328d5752SMark Fasheh 
2767328d5752SMark Fasheh 	ocfs2_journal_dirty(handle, path_root_bh(path));
2768328d5752SMark Fasheh 
2769328d5752SMark Fasheh out:
2770328d5752SMark Fasheh 	ocfs2_free_path(left_path);
2771328d5752SMark Fasheh 	return ret;
2772328d5752SMark Fasheh }
2773328d5752SMark Fasheh 
2774328d5752SMark Fasheh /*
2775328d5752SMark Fasheh  * Left rotation of btree records.
2776328d5752SMark Fasheh  *
2777328d5752SMark Fasheh  * In many ways, this is (unsurprisingly) the opposite of right
2778328d5752SMark Fasheh  * rotation. We start at some non-rightmost path containing an empty
2779328d5752SMark Fasheh  * extent in the leaf block. The code works its way to the rightmost
2780328d5752SMark Fasheh  * path by rotating records to the left in every subtree.
2781328d5752SMark Fasheh  *
2782328d5752SMark Fasheh  * This is used by any code which reduces the number of extent records
2783328d5752SMark Fasheh  * in a leaf. After removal, an empty record should be placed in the
2784328d5752SMark Fasheh  * leftmost list position.
2785328d5752SMark Fasheh  *
2786328d5752SMark Fasheh  * This won't handle a length update of the rightmost path records if
2787328d5752SMark Fasheh  * the rightmost tree leaf record is removed so the caller is
2788328d5752SMark Fasheh  * responsible for detecting and correcting that.
2789328d5752SMark Fasheh  */
2790328d5752SMark Fasheh static int ocfs2_rotate_tree_left(struct inode *inode, handle_t *handle,
2791328d5752SMark Fasheh 				  struct ocfs2_path *path,
2792e7d4cb6bSTao Ma 				  struct ocfs2_cached_dealloc_ctxt *dealloc,
2793e7d4cb6bSTao Ma 				  struct ocfs2_extent_tree *et)
2794328d5752SMark Fasheh {
2795328d5752SMark Fasheh 	int ret, orig_credits = handle->h_buffer_credits;
2796328d5752SMark Fasheh 	struct ocfs2_path *tmp_path = NULL, *restart_path = NULL;
2797328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
2798328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
2799328d5752SMark Fasheh 
2800328d5752SMark Fasheh 	el = path_leaf_el(path);
2801328d5752SMark Fasheh 	if (!ocfs2_is_empty_extent(&el->l_recs[0]))
2802328d5752SMark Fasheh 		return 0;
2803328d5752SMark Fasheh 
2804328d5752SMark Fasheh 	if (path->p_tree_depth == 0) {
2805328d5752SMark Fasheh rightmost_no_delete:
2806328d5752SMark Fasheh 		/*
2807e7d4cb6bSTao Ma 		 * Inline extents. This is trivially handled, so do
2808328d5752SMark Fasheh 		 * it up front.
2809328d5752SMark Fasheh 		 */
2810328d5752SMark Fasheh 		ret = ocfs2_rotate_rightmost_leaf_left(inode, handle,
2811328d5752SMark Fasheh 						       path_leaf_bh(path),
2812328d5752SMark Fasheh 						       path_leaf_el(path));
2813328d5752SMark Fasheh 		if (ret)
2814328d5752SMark Fasheh 			mlog_errno(ret);
2815328d5752SMark Fasheh 		goto out;
2816328d5752SMark Fasheh 	}
2817328d5752SMark Fasheh 
2818328d5752SMark Fasheh 	/*
2819328d5752SMark Fasheh 	 * Handle rightmost branch now. There's several cases:
2820328d5752SMark Fasheh 	 *  1) simple rotation leaving records in there. That's trivial.
2821328d5752SMark Fasheh 	 *  2) rotation requiring a branch delete - there's no more
2822328d5752SMark Fasheh 	 *     records left. Two cases of this:
2823328d5752SMark Fasheh 	 *     a) There are branches to the left.
2824328d5752SMark Fasheh 	 *     b) This is also the leftmost (the only) branch.
2825328d5752SMark Fasheh 	 *
2826328d5752SMark Fasheh 	 *  1) is handled via ocfs2_rotate_rightmost_leaf_left()
2827328d5752SMark Fasheh 	 *  2a) we need the left branch so that we can update it with the unlink
2828328d5752SMark Fasheh 	 *  2b) we need to bring the inode back to inline extents.
2829328d5752SMark Fasheh 	 */
2830328d5752SMark Fasheh 
2831328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
2832328d5752SMark Fasheh 	el = &eb->h_list;
2833328d5752SMark Fasheh 	if (eb->h_next_leaf_blk == 0) {
2834328d5752SMark Fasheh 		/*
2835328d5752SMark Fasheh 		 * This gets a bit tricky if we're going to delete the
2836328d5752SMark Fasheh 		 * rightmost path. Get the other cases out of the way
2837328d5752SMark Fasheh 		 * 1st.
2838328d5752SMark Fasheh 		 */
2839328d5752SMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) > 1)
2840328d5752SMark Fasheh 			goto rightmost_no_delete;
2841328d5752SMark Fasheh 
2842328d5752SMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) == 0) {
2843328d5752SMark Fasheh 			ret = -EIO;
2844328d5752SMark Fasheh 			ocfs2_error(inode->i_sb,
2845328d5752SMark Fasheh 				    "Inode %llu has empty extent block at %llu",
2846328d5752SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno,
2847328d5752SMark Fasheh 				    (unsigned long long)le64_to_cpu(eb->h_blkno));
2848328d5752SMark Fasheh 			goto out;
2849328d5752SMark Fasheh 		}
2850328d5752SMark Fasheh 
2851328d5752SMark Fasheh 		/*
2852328d5752SMark Fasheh 		 * XXX: The caller can not trust "path" any more after
2853328d5752SMark Fasheh 		 * this as it will have been deleted. What do we do?
2854328d5752SMark Fasheh 		 *
2855328d5752SMark Fasheh 		 * In theory the rotate-for-merge code will never get
2856328d5752SMark Fasheh 		 * here because it'll always ask for a rotate in a
2857328d5752SMark Fasheh 		 * nonempty list.
2858328d5752SMark Fasheh 		 */
2859328d5752SMark Fasheh 
2860328d5752SMark Fasheh 		ret = ocfs2_remove_rightmost_path(inode, handle, path,
2861e7d4cb6bSTao Ma 						  dealloc, et);
2862328d5752SMark Fasheh 		if (ret)
2863328d5752SMark Fasheh 			mlog_errno(ret);
2864328d5752SMark Fasheh 		goto out;
2865328d5752SMark Fasheh 	}
2866328d5752SMark Fasheh 
2867328d5752SMark Fasheh 	/*
2868328d5752SMark Fasheh 	 * Now we can loop, remembering the path we get from -EAGAIN
2869328d5752SMark Fasheh 	 * and restarting from there.
2870328d5752SMark Fasheh 	 */
2871328d5752SMark Fasheh try_rotate:
2872328d5752SMark Fasheh 	ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits, path,
2873e7d4cb6bSTao Ma 				       dealloc, &restart_path, et);
2874328d5752SMark Fasheh 	if (ret && ret != -EAGAIN) {
2875328d5752SMark Fasheh 		mlog_errno(ret);
2876328d5752SMark Fasheh 		goto out;
2877328d5752SMark Fasheh 	}
2878328d5752SMark Fasheh 
2879328d5752SMark Fasheh 	while (ret == -EAGAIN) {
2880328d5752SMark Fasheh 		tmp_path = restart_path;
2881328d5752SMark Fasheh 		restart_path = NULL;
2882328d5752SMark Fasheh 
2883328d5752SMark Fasheh 		ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits,
2884328d5752SMark Fasheh 					       tmp_path, dealloc,
2885e7d4cb6bSTao Ma 					       &restart_path, et);
2886328d5752SMark Fasheh 		if (ret && ret != -EAGAIN) {
2887328d5752SMark Fasheh 			mlog_errno(ret);
2888328d5752SMark Fasheh 			goto out;
2889328d5752SMark Fasheh 		}
2890328d5752SMark Fasheh 
2891328d5752SMark Fasheh 		ocfs2_free_path(tmp_path);
2892328d5752SMark Fasheh 		tmp_path = NULL;
2893328d5752SMark Fasheh 
2894328d5752SMark Fasheh 		if (ret == 0)
2895328d5752SMark Fasheh 			goto try_rotate;
2896328d5752SMark Fasheh 	}
2897328d5752SMark Fasheh 
2898328d5752SMark Fasheh out:
2899328d5752SMark Fasheh 	ocfs2_free_path(tmp_path);
2900328d5752SMark Fasheh 	ocfs2_free_path(restart_path);
2901328d5752SMark Fasheh 	return ret;
2902328d5752SMark Fasheh }
2903328d5752SMark Fasheh 
2904328d5752SMark Fasheh static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el,
2905328d5752SMark Fasheh 				int index)
2906328d5752SMark Fasheh {
2907328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec = &el->l_recs[index];
2908328d5752SMark Fasheh 	unsigned int size;
2909328d5752SMark Fasheh 
2910328d5752SMark Fasheh 	if (rec->e_leaf_clusters == 0) {
2911328d5752SMark Fasheh 		/*
2912328d5752SMark Fasheh 		 * We consumed all of the merged-from record. An empty
2913328d5752SMark Fasheh 		 * extent cannot exist anywhere but the 1st array
2914328d5752SMark Fasheh 		 * position, so move things over if the merged-from
2915328d5752SMark Fasheh 		 * record doesn't occupy that position.
2916328d5752SMark Fasheh 		 *
2917328d5752SMark Fasheh 		 * This creates a new empty extent so the caller
2918328d5752SMark Fasheh 		 * should be smart enough to have removed any existing
2919328d5752SMark Fasheh 		 * ones.
2920328d5752SMark Fasheh 		 */
2921328d5752SMark Fasheh 		if (index > 0) {
2922328d5752SMark Fasheh 			BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
2923328d5752SMark Fasheh 			size = index * sizeof(struct ocfs2_extent_rec);
2924328d5752SMark Fasheh 			memmove(&el->l_recs[1], &el->l_recs[0], size);
2925328d5752SMark Fasheh 		}
2926328d5752SMark Fasheh 
2927328d5752SMark Fasheh 		/*
2928328d5752SMark Fasheh 		 * Always memset - the caller doesn't check whether it
2929328d5752SMark Fasheh 		 * created an empty extent, so there could be junk in
2930328d5752SMark Fasheh 		 * the other fields.
2931328d5752SMark Fasheh 		 */
2932328d5752SMark Fasheh 		memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2933328d5752SMark Fasheh 	}
2934328d5752SMark Fasheh }
2935328d5752SMark Fasheh 
2936677b9752STao Ma static int ocfs2_get_right_path(struct inode *inode,
2937677b9752STao Ma 				struct ocfs2_path *left_path,
2938677b9752STao Ma 				struct ocfs2_path **ret_right_path)
2939328d5752SMark Fasheh {
2940328d5752SMark Fasheh 	int ret;
2941677b9752STao Ma 	u32 right_cpos;
2942677b9752STao Ma 	struct ocfs2_path *right_path = NULL;
2943677b9752STao Ma 	struct ocfs2_extent_list *left_el;
2944677b9752STao Ma 
2945677b9752STao Ma 	*ret_right_path = NULL;
2946677b9752STao Ma 
2947677b9752STao Ma 	/* This function shouldn't be called for non-trees. */
2948677b9752STao Ma 	BUG_ON(left_path->p_tree_depth == 0);
2949677b9752STao Ma 
2950677b9752STao Ma 	left_el = path_leaf_el(left_path);
2951677b9752STao Ma 	BUG_ON(left_el->l_next_free_rec != left_el->l_count);
2952677b9752STao Ma 
2953677b9752STao Ma 	ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, left_path,
2954677b9752STao Ma 					     &right_cpos);
2955677b9752STao Ma 	if (ret) {
2956677b9752STao Ma 		mlog_errno(ret);
2957677b9752STao Ma 		goto out;
2958677b9752STao Ma 	}
2959677b9752STao Ma 
2960677b9752STao Ma 	/* This function shouldn't be called for the rightmost leaf. */
2961677b9752STao Ma 	BUG_ON(right_cpos == 0);
2962677b9752STao Ma 
2963677b9752STao Ma 	right_path = ocfs2_new_path(path_root_bh(left_path),
2964677b9752STao Ma 				    path_root_el(left_path));
2965677b9752STao Ma 	if (!right_path) {
2966677b9752STao Ma 		ret = -ENOMEM;
2967677b9752STao Ma 		mlog_errno(ret);
2968677b9752STao Ma 		goto out;
2969677b9752STao Ma 	}
2970677b9752STao Ma 
2971677b9752STao Ma 	ret = ocfs2_find_path(inode, right_path, right_cpos);
2972677b9752STao Ma 	if (ret) {
2973677b9752STao Ma 		mlog_errno(ret);
2974677b9752STao Ma 		goto out;
2975677b9752STao Ma 	}
2976677b9752STao Ma 
2977677b9752STao Ma 	*ret_right_path = right_path;
2978677b9752STao Ma out:
2979677b9752STao Ma 	if (ret)
2980677b9752STao Ma 		ocfs2_free_path(right_path);
2981677b9752STao Ma 	return ret;
2982677b9752STao Ma }
2983677b9752STao Ma 
2984677b9752STao Ma /*
2985677b9752STao Ma  * Remove split_rec clusters from the record at index and merge them
2986677b9752STao Ma  * onto the beginning of the record "next" to it.
2987677b9752STao Ma  * For index < l_count - 1, the next means the extent rec at index + 1.
2988677b9752STao Ma  * For index == l_count - 1, the "next" means the 1st extent rec of the
2989677b9752STao Ma  * next extent block.
2990677b9752STao Ma  */
2991677b9752STao Ma static int ocfs2_merge_rec_right(struct inode *inode,
2992677b9752STao Ma 				 struct ocfs2_path *left_path,
2993677b9752STao Ma 				 handle_t *handle,
2994677b9752STao Ma 				 struct ocfs2_extent_rec *split_rec,
2995677b9752STao Ma 				 int index)
2996677b9752STao Ma {
2997677b9752STao Ma 	int ret, next_free, i;
2998328d5752SMark Fasheh 	unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
2999328d5752SMark Fasheh 	struct ocfs2_extent_rec *left_rec;
3000328d5752SMark Fasheh 	struct ocfs2_extent_rec *right_rec;
3001677b9752STao Ma 	struct ocfs2_extent_list *right_el;
3002677b9752STao Ma 	struct ocfs2_path *right_path = NULL;
3003677b9752STao Ma 	int subtree_index = 0;
3004677b9752STao Ma 	struct ocfs2_extent_list *el = path_leaf_el(left_path);
3005677b9752STao Ma 	struct buffer_head *bh = path_leaf_bh(left_path);
3006677b9752STao Ma 	struct buffer_head *root_bh = NULL;
3007328d5752SMark Fasheh 
3008328d5752SMark Fasheh 	BUG_ON(index >= le16_to_cpu(el->l_next_free_rec));
3009328d5752SMark Fasheh 	left_rec = &el->l_recs[index];
3010677b9752STao Ma 
30119d8df6aaSAl Viro 	if (index == le16_to_cpu(el->l_next_free_rec) - 1 &&
3012677b9752STao Ma 	    le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count)) {
3013677b9752STao Ma 		/* we meet with a cross extent block merge. */
3014677b9752STao Ma 		ret = ocfs2_get_right_path(inode, left_path, &right_path);
3015677b9752STao Ma 		if (ret) {
3016677b9752STao Ma 			mlog_errno(ret);
3017677b9752STao Ma 			goto out;
3018677b9752STao Ma 		}
3019677b9752STao Ma 
3020677b9752STao Ma 		right_el = path_leaf_el(right_path);
3021677b9752STao Ma 		next_free = le16_to_cpu(right_el->l_next_free_rec);
3022677b9752STao Ma 		BUG_ON(next_free <= 0);
3023677b9752STao Ma 		right_rec = &right_el->l_recs[0];
3024677b9752STao Ma 		if (ocfs2_is_empty_extent(right_rec)) {
30259d8df6aaSAl Viro 			BUG_ON(next_free <= 1);
3026677b9752STao Ma 			right_rec = &right_el->l_recs[1];
3027677b9752STao Ma 		}
3028677b9752STao Ma 
3029677b9752STao Ma 		BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3030677b9752STao Ma 		       le16_to_cpu(left_rec->e_leaf_clusters) !=
3031677b9752STao Ma 		       le32_to_cpu(right_rec->e_cpos));
3032677b9752STao Ma 
3033677b9752STao Ma 		subtree_index = ocfs2_find_subtree_root(inode,
3034677b9752STao Ma 							left_path, right_path);
3035677b9752STao Ma 
3036677b9752STao Ma 		ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
3037677b9752STao Ma 						      handle->h_buffer_credits,
3038677b9752STao Ma 						      right_path);
3039677b9752STao Ma 		if (ret) {
3040677b9752STao Ma 			mlog_errno(ret);
3041677b9752STao Ma 			goto out;
3042677b9752STao Ma 		}
3043677b9752STao Ma 
3044677b9752STao Ma 		root_bh = left_path->p_node[subtree_index].bh;
3045677b9752STao Ma 		BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3046677b9752STao Ma 
3047677b9752STao Ma 		ret = ocfs2_journal_access(handle, inode, root_bh,
3048677b9752STao Ma 					   OCFS2_JOURNAL_ACCESS_WRITE);
3049677b9752STao Ma 		if (ret) {
3050677b9752STao Ma 			mlog_errno(ret);
3051677b9752STao Ma 			goto out;
3052677b9752STao Ma 		}
3053677b9752STao Ma 
3054677b9752STao Ma 		for (i = subtree_index + 1;
3055677b9752STao Ma 		     i < path_num_items(right_path); i++) {
3056677b9752STao Ma 			ret = ocfs2_journal_access(handle, inode,
3057677b9752STao Ma 						   right_path->p_node[i].bh,
3058677b9752STao Ma 						   OCFS2_JOURNAL_ACCESS_WRITE);
3059677b9752STao Ma 			if (ret) {
3060677b9752STao Ma 				mlog_errno(ret);
3061677b9752STao Ma 				goto out;
3062677b9752STao Ma 			}
3063677b9752STao Ma 
3064677b9752STao Ma 			ret = ocfs2_journal_access(handle, inode,
3065677b9752STao Ma 						   left_path->p_node[i].bh,
3066677b9752STao Ma 						   OCFS2_JOURNAL_ACCESS_WRITE);
3067677b9752STao Ma 			if (ret) {
3068677b9752STao Ma 				mlog_errno(ret);
3069677b9752STao Ma 				goto out;
3070677b9752STao Ma 			}
3071677b9752STao Ma 		}
3072677b9752STao Ma 
3073677b9752STao Ma 	} else {
3074677b9752STao Ma 		BUG_ON(index == le16_to_cpu(el->l_next_free_rec) - 1);
3075328d5752SMark Fasheh 		right_rec = &el->l_recs[index + 1];
3076677b9752STao Ma 	}
3077328d5752SMark Fasheh 
3078328d5752SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, bh,
3079328d5752SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
3080328d5752SMark Fasheh 	if (ret) {
3081328d5752SMark Fasheh 		mlog_errno(ret);
3082328d5752SMark Fasheh 		goto out;
3083328d5752SMark Fasheh 	}
3084328d5752SMark Fasheh 
3085328d5752SMark Fasheh 	le16_add_cpu(&left_rec->e_leaf_clusters, -split_clusters);
3086328d5752SMark Fasheh 
3087328d5752SMark Fasheh 	le32_add_cpu(&right_rec->e_cpos, -split_clusters);
3088328d5752SMark Fasheh 	le64_add_cpu(&right_rec->e_blkno,
3089328d5752SMark Fasheh 		     -ocfs2_clusters_to_blocks(inode->i_sb, split_clusters));
3090328d5752SMark Fasheh 	le16_add_cpu(&right_rec->e_leaf_clusters, split_clusters);
3091328d5752SMark Fasheh 
3092328d5752SMark Fasheh 	ocfs2_cleanup_merge(el, index);
3093328d5752SMark Fasheh 
3094328d5752SMark Fasheh 	ret = ocfs2_journal_dirty(handle, bh);
3095328d5752SMark Fasheh 	if (ret)
3096328d5752SMark Fasheh 		mlog_errno(ret);
3097328d5752SMark Fasheh 
3098677b9752STao Ma 	if (right_path) {
3099677b9752STao Ma 		ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
3100677b9752STao Ma 		if (ret)
3101677b9752STao Ma 			mlog_errno(ret);
3102677b9752STao Ma 
3103677b9752STao Ma 		ocfs2_complete_edge_insert(inode, handle, left_path,
3104677b9752STao Ma 					   right_path, subtree_index);
3105677b9752STao Ma 	}
3106328d5752SMark Fasheh out:
3107677b9752STao Ma 	if (right_path)
3108677b9752STao Ma 		ocfs2_free_path(right_path);
3109677b9752STao Ma 	return ret;
3110677b9752STao Ma }
3111677b9752STao Ma 
3112677b9752STao Ma static int ocfs2_get_left_path(struct inode *inode,
3113677b9752STao Ma 			       struct ocfs2_path *right_path,
3114677b9752STao Ma 			       struct ocfs2_path **ret_left_path)
3115677b9752STao Ma {
3116677b9752STao Ma 	int ret;
3117677b9752STao Ma 	u32 left_cpos;
3118677b9752STao Ma 	struct ocfs2_path *left_path = NULL;
3119677b9752STao Ma 
3120677b9752STao Ma 	*ret_left_path = NULL;
3121677b9752STao Ma 
3122677b9752STao Ma 	/* This function shouldn't be called for non-trees. */
3123677b9752STao Ma 	BUG_ON(right_path->p_tree_depth == 0);
3124677b9752STao Ma 
3125677b9752STao Ma 	ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb,
3126677b9752STao Ma 					    right_path, &left_cpos);
3127677b9752STao Ma 	if (ret) {
3128677b9752STao Ma 		mlog_errno(ret);
3129677b9752STao Ma 		goto out;
3130677b9752STao Ma 	}
3131677b9752STao Ma 
3132677b9752STao Ma 	/* This function shouldn't be called for the leftmost leaf. */
3133677b9752STao Ma 	BUG_ON(left_cpos == 0);
3134677b9752STao Ma 
3135677b9752STao Ma 	left_path = ocfs2_new_path(path_root_bh(right_path),
3136677b9752STao Ma 				   path_root_el(right_path));
3137677b9752STao Ma 	if (!left_path) {
3138677b9752STao Ma 		ret = -ENOMEM;
3139677b9752STao Ma 		mlog_errno(ret);
3140677b9752STao Ma 		goto out;
3141677b9752STao Ma 	}
3142677b9752STao Ma 
3143677b9752STao Ma 	ret = ocfs2_find_path(inode, left_path, left_cpos);
3144677b9752STao Ma 	if (ret) {
3145677b9752STao Ma 		mlog_errno(ret);
3146677b9752STao Ma 		goto out;
3147677b9752STao Ma 	}
3148677b9752STao Ma 
3149677b9752STao Ma 	*ret_left_path = left_path;
3150677b9752STao Ma out:
3151677b9752STao Ma 	if (ret)
3152677b9752STao Ma 		ocfs2_free_path(left_path);
3153328d5752SMark Fasheh 	return ret;
3154328d5752SMark Fasheh }
3155328d5752SMark Fasheh 
3156328d5752SMark Fasheh /*
3157328d5752SMark Fasheh  * Remove split_rec clusters from the record at index and merge them
3158677b9752STao Ma  * onto the tail of the record "before" it.
3159677b9752STao Ma  * For index > 0, the "before" means the extent rec at index - 1.
3160677b9752STao Ma  *
3161677b9752STao Ma  * For index == 0, the "before" means the last record of the previous
3162677b9752STao Ma  * extent block. And there is also a situation that we may need to
3163677b9752STao Ma  * remove the rightmost leaf extent block in the right_path and change
3164677b9752STao Ma  * the right path to indicate the new rightmost path.
3165328d5752SMark Fasheh  */
3166677b9752STao Ma static int ocfs2_merge_rec_left(struct inode *inode,
3167677b9752STao Ma 				struct ocfs2_path *right_path,
3168328d5752SMark Fasheh 				handle_t *handle,
3169328d5752SMark Fasheh 				struct ocfs2_extent_rec *split_rec,
3170677b9752STao Ma 				struct ocfs2_cached_dealloc_ctxt *dealloc,
3171e7d4cb6bSTao Ma 				struct ocfs2_extent_tree *et,
3172677b9752STao Ma 				int index)
3173328d5752SMark Fasheh {
3174677b9752STao Ma 	int ret, i, subtree_index = 0, has_empty_extent = 0;
3175328d5752SMark Fasheh 	unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3176328d5752SMark Fasheh 	struct ocfs2_extent_rec *left_rec;
3177328d5752SMark Fasheh 	struct ocfs2_extent_rec *right_rec;
3178677b9752STao Ma 	struct ocfs2_extent_list *el = path_leaf_el(right_path);
3179677b9752STao Ma 	struct buffer_head *bh = path_leaf_bh(right_path);
3180677b9752STao Ma 	struct buffer_head *root_bh = NULL;
3181677b9752STao Ma 	struct ocfs2_path *left_path = NULL;
3182677b9752STao Ma 	struct ocfs2_extent_list *left_el;
3183328d5752SMark Fasheh 
3184677b9752STao Ma 	BUG_ON(index < 0);
3185328d5752SMark Fasheh 
3186328d5752SMark Fasheh 	right_rec = &el->l_recs[index];
3187677b9752STao Ma 	if (index == 0) {
3188677b9752STao Ma 		/* we meet with a cross extent block merge. */
3189677b9752STao Ma 		ret = ocfs2_get_left_path(inode, right_path, &left_path);
3190677b9752STao Ma 		if (ret) {
3191677b9752STao Ma 			mlog_errno(ret);
3192677b9752STao Ma 			goto out;
3193677b9752STao Ma 		}
3194677b9752STao Ma 
3195677b9752STao Ma 		left_el = path_leaf_el(left_path);
3196677b9752STao Ma 		BUG_ON(le16_to_cpu(left_el->l_next_free_rec) !=
3197677b9752STao Ma 		       le16_to_cpu(left_el->l_count));
3198677b9752STao Ma 
3199677b9752STao Ma 		left_rec = &left_el->l_recs[
3200677b9752STao Ma 				le16_to_cpu(left_el->l_next_free_rec) - 1];
3201677b9752STao Ma 		BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3202677b9752STao Ma 		       le16_to_cpu(left_rec->e_leaf_clusters) !=
3203677b9752STao Ma 		       le32_to_cpu(split_rec->e_cpos));
3204677b9752STao Ma 
3205677b9752STao Ma 		subtree_index = ocfs2_find_subtree_root(inode,
3206677b9752STao Ma 							left_path, right_path);
3207677b9752STao Ma 
3208677b9752STao Ma 		ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
3209677b9752STao Ma 						      handle->h_buffer_credits,
3210677b9752STao Ma 						      left_path);
3211677b9752STao Ma 		if (ret) {
3212677b9752STao Ma 			mlog_errno(ret);
3213677b9752STao Ma 			goto out;
3214677b9752STao Ma 		}
3215677b9752STao Ma 
3216677b9752STao Ma 		root_bh = left_path->p_node[subtree_index].bh;
3217677b9752STao Ma 		BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3218677b9752STao Ma 
3219677b9752STao Ma 		ret = ocfs2_journal_access(handle, inode, root_bh,
3220677b9752STao Ma 					   OCFS2_JOURNAL_ACCESS_WRITE);
3221677b9752STao Ma 		if (ret) {
3222677b9752STao Ma 			mlog_errno(ret);
3223677b9752STao Ma 			goto out;
3224677b9752STao Ma 		}
3225677b9752STao Ma 
3226677b9752STao Ma 		for (i = subtree_index + 1;
3227677b9752STao Ma 		     i < path_num_items(right_path); i++) {
3228677b9752STao Ma 			ret = ocfs2_journal_access(handle, inode,
3229677b9752STao Ma 						   right_path->p_node[i].bh,
3230677b9752STao Ma 						   OCFS2_JOURNAL_ACCESS_WRITE);
3231677b9752STao Ma 			if (ret) {
3232677b9752STao Ma 				mlog_errno(ret);
3233677b9752STao Ma 				goto out;
3234677b9752STao Ma 			}
3235677b9752STao Ma 
3236677b9752STao Ma 			ret = ocfs2_journal_access(handle, inode,
3237677b9752STao Ma 						   left_path->p_node[i].bh,
3238677b9752STao Ma 						   OCFS2_JOURNAL_ACCESS_WRITE);
3239677b9752STao Ma 			if (ret) {
3240677b9752STao Ma 				mlog_errno(ret);
3241677b9752STao Ma 				goto out;
3242677b9752STao Ma 			}
3243677b9752STao Ma 		}
3244677b9752STao Ma 	} else {
3245677b9752STao Ma 		left_rec = &el->l_recs[index - 1];
3246328d5752SMark Fasheh 		if (ocfs2_is_empty_extent(&el->l_recs[0]))
3247328d5752SMark Fasheh 			has_empty_extent = 1;
3248677b9752STao Ma 	}
3249328d5752SMark Fasheh 
3250328d5752SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, bh,
3251328d5752SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
3252328d5752SMark Fasheh 	if (ret) {
3253328d5752SMark Fasheh 		mlog_errno(ret);
3254328d5752SMark Fasheh 		goto out;
3255328d5752SMark Fasheh 	}
3256328d5752SMark Fasheh 
3257328d5752SMark Fasheh 	if (has_empty_extent && index == 1) {
3258328d5752SMark Fasheh 		/*
3259328d5752SMark Fasheh 		 * The easy case - we can just plop the record right in.
3260328d5752SMark Fasheh 		 */
3261328d5752SMark Fasheh 		*left_rec = *split_rec;
3262328d5752SMark Fasheh 
3263328d5752SMark Fasheh 		has_empty_extent = 0;
3264677b9752STao Ma 	} else
3265328d5752SMark Fasheh 		le16_add_cpu(&left_rec->e_leaf_clusters, split_clusters);
3266328d5752SMark Fasheh 
3267328d5752SMark Fasheh 	le32_add_cpu(&right_rec->e_cpos, split_clusters);
3268328d5752SMark Fasheh 	le64_add_cpu(&right_rec->e_blkno,
3269328d5752SMark Fasheh 		     ocfs2_clusters_to_blocks(inode->i_sb, split_clusters));
3270328d5752SMark Fasheh 	le16_add_cpu(&right_rec->e_leaf_clusters, -split_clusters);
3271328d5752SMark Fasheh 
3272328d5752SMark Fasheh 	ocfs2_cleanup_merge(el, index);
3273328d5752SMark Fasheh 
3274328d5752SMark Fasheh 	ret = ocfs2_journal_dirty(handle, bh);
3275328d5752SMark Fasheh 	if (ret)
3276328d5752SMark Fasheh 		mlog_errno(ret);
3277328d5752SMark Fasheh 
3278677b9752STao Ma 	if (left_path) {
3279677b9752STao Ma 		ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
3280677b9752STao Ma 		if (ret)
3281677b9752STao Ma 			mlog_errno(ret);
3282677b9752STao Ma 
3283677b9752STao Ma 		/*
3284677b9752STao Ma 		 * In the situation that the right_rec is empty and the extent
3285677b9752STao Ma 		 * block is empty also,  ocfs2_complete_edge_insert can't handle
3286677b9752STao Ma 		 * it and we need to delete the right extent block.
3287677b9752STao Ma 		 */
3288677b9752STao Ma 		if (le16_to_cpu(right_rec->e_leaf_clusters) == 0 &&
3289677b9752STao Ma 		    le16_to_cpu(el->l_next_free_rec) == 1) {
3290677b9752STao Ma 
3291677b9752STao Ma 			ret = ocfs2_remove_rightmost_path(inode, handle,
3292e7d4cb6bSTao Ma 							  right_path,
3293e7d4cb6bSTao Ma 							  dealloc, et);
3294677b9752STao Ma 			if (ret) {
3295677b9752STao Ma 				mlog_errno(ret);
3296677b9752STao Ma 				goto out;
3297677b9752STao Ma 			}
3298677b9752STao Ma 
3299677b9752STao Ma 			/* Now the rightmost extent block has been deleted.
3300677b9752STao Ma 			 * So we use the new rightmost path.
3301677b9752STao Ma 			 */
3302677b9752STao Ma 			ocfs2_mv_path(right_path, left_path);
3303677b9752STao Ma 			left_path = NULL;
3304677b9752STao Ma 		} else
3305677b9752STao Ma 			ocfs2_complete_edge_insert(inode, handle, left_path,
3306677b9752STao Ma 						   right_path, subtree_index);
3307677b9752STao Ma 	}
3308328d5752SMark Fasheh out:
3309677b9752STao Ma 	if (left_path)
3310677b9752STao Ma 		ocfs2_free_path(left_path);
3311328d5752SMark Fasheh 	return ret;
3312328d5752SMark Fasheh }
3313328d5752SMark Fasheh 
3314328d5752SMark Fasheh static int ocfs2_try_to_merge_extent(struct inode *inode,
3315328d5752SMark Fasheh 				     handle_t *handle,
3316677b9752STao Ma 				     struct ocfs2_path *path,
3317328d5752SMark Fasheh 				     int split_index,
3318328d5752SMark Fasheh 				     struct ocfs2_extent_rec *split_rec,
3319328d5752SMark Fasheh 				     struct ocfs2_cached_dealloc_ctxt *dealloc,
3320e7d4cb6bSTao Ma 				     struct ocfs2_merge_ctxt *ctxt,
3321e7d4cb6bSTao Ma 				     struct ocfs2_extent_tree *et)
3322328d5752SMark Fasheh 
3323328d5752SMark Fasheh {
3324518d7269STao Mao 	int ret = 0;
3325677b9752STao Ma 	struct ocfs2_extent_list *el = path_leaf_el(path);
3326328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
3327328d5752SMark Fasheh 
3328328d5752SMark Fasheh 	BUG_ON(ctxt->c_contig_type == CONTIG_NONE);
3329328d5752SMark Fasheh 
3330518d7269STao Mao 	if (ctxt->c_split_covers_rec && ctxt->c_has_empty_extent) {
3331328d5752SMark Fasheh 		/*
3332328d5752SMark Fasheh 		 * The merge code will need to create an empty
3333328d5752SMark Fasheh 		 * extent to take the place of the newly
3334328d5752SMark Fasheh 		 * emptied slot. Remove any pre-existing empty
3335328d5752SMark Fasheh 		 * extents - having more than one in a leaf is
3336328d5752SMark Fasheh 		 * illegal.
3337328d5752SMark Fasheh 		 */
3338677b9752STao Ma 		ret = ocfs2_rotate_tree_left(inode, handle, path,
3339e7d4cb6bSTao Ma 					     dealloc, et);
3340328d5752SMark Fasheh 		if (ret) {
3341328d5752SMark Fasheh 			mlog_errno(ret);
3342328d5752SMark Fasheh 			goto out;
3343328d5752SMark Fasheh 		}
3344328d5752SMark Fasheh 		split_index--;
3345328d5752SMark Fasheh 		rec = &el->l_recs[split_index];
3346328d5752SMark Fasheh 	}
3347328d5752SMark Fasheh 
3348328d5752SMark Fasheh 	if (ctxt->c_contig_type == CONTIG_LEFTRIGHT) {
3349328d5752SMark Fasheh 		/*
3350328d5752SMark Fasheh 		 * Left-right contig implies this.
3351328d5752SMark Fasheh 		 */
3352328d5752SMark Fasheh 		BUG_ON(!ctxt->c_split_covers_rec);
3353328d5752SMark Fasheh 
3354328d5752SMark Fasheh 		/*
3355328d5752SMark Fasheh 		 * Since the leftright insert always covers the entire
3356328d5752SMark Fasheh 		 * extent, this call will delete the insert record
3357328d5752SMark Fasheh 		 * entirely, resulting in an empty extent record added to
3358328d5752SMark Fasheh 		 * the extent block.
3359328d5752SMark Fasheh 		 *
3360328d5752SMark Fasheh 		 * Since the adding of an empty extent shifts
3361328d5752SMark Fasheh 		 * everything back to the right, there's no need to
3362328d5752SMark Fasheh 		 * update split_index here.
3363677b9752STao Ma 		 *
3364677b9752STao Ma 		 * When the split_index is zero, we need to merge it to the
3365677b9752STao Ma 		 * prevoius extent block. It is more efficient and easier
3366677b9752STao Ma 		 * if we do merge_right first and merge_left later.
3367328d5752SMark Fasheh 		 */
3368677b9752STao Ma 		ret = ocfs2_merge_rec_right(inode, path,
3369677b9752STao Ma 					    handle, split_rec,
3370677b9752STao Ma 					    split_index);
3371328d5752SMark Fasheh 		if (ret) {
3372328d5752SMark Fasheh 			mlog_errno(ret);
3373328d5752SMark Fasheh 			goto out;
3374328d5752SMark Fasheh 		}
3375328d5752SMark Fasheh 
3376328d5752SMark Fasheh 		/*
3377328d5752SMark Fasheh 		 * We can only get this from logic error above.
3378328d5752SMark Fasheh 		 */
3379328d5752SMark Fasheh 		BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0]));
3380328d5752SMark Fasheh 
3381677b9752STao Ma 		/* The merge left us with an empty extent, remove it. */
3382e7d4cb6bSTao Ma 		ret = ocfs2_rotate_tree_left(inode, handle, path,
3383e7d4cb6bSTao Ma 					     dealloc, et);
3384328d5752SMark Fasheh 		if (ret) {
3385328d5752SMark Fasheh 			mlog_errno(ret);
3386328d5752SMark Fasheh 			goto out;
3387328d5752SMark Fasheh 		}
3388677b9752STao Ma 
3389328d5752SMark Fasheh 		rec = &el->l_recs[split_index];
3390328d5752SMark Fasheh 
3391328d5752SMark Fasheh 		/*
3392328d5752SMark Fasheh 		 * Note that we don't pass split_rec here on purpose -
3393677b9752STao Ma 		 * we've merged it into the rec already.
3394328d5752SMark Fasheh 		 */
3395677b9752STao Ma 		ret = ocfs2_merge_rec_left(inode, path,
3396677b9752STao Ma 					   handle, rec,
3397e7d4cb6bSTao Ma 					   dealloc, et,
3398677b9752STao Ma 					   split_index);
3399677b9752STao Ma 
3400328d5752SMark Fasheh 		if (ret) {
3401328d5752SMark Fasheh 			mlog_errno(ret);
3402328d5752SMark Fasheh 			goto out;
3403328d5752SMark Fasheh 		}
3404328d5752SMark Fasheh 
3405677b9752STao Ma 		ret = ocfs2_rotate_tree_left(inode, handle, path,
3406e7d4cb6bSTao Ma 					     dealloc, et);
3407328d5752SMark Fasheh 		/*
3408328d5752SMark Fasheh 		 * Error from this last rotate is not critical, so
3409328d5752SMark Fasheh 		 * print but don't bubble it up.
3410328d5752SMark Fasheh 		 */
3411328d5752SMark Fasheh 		if (ret)
3412328d5752SMark Fasheh 			mlog_errno(ret);
3413328d5752SMark Fasheh 		ret = 0;
3414328d5752SMark Fasheh 	} else {
3415328d5752SMark Fasheh 		/*
3416328d5752SMark Fasheh 		 * Merge a record to the left or right.
3417328d5752SMark Fasheh 		 *
3418328d5752SMark Fasheh 		 * 'contig_type' is relative to the existing record,
3419328d5752SMark Fasheh 		 * so for example, if we're "right contig", it's to
3420328d5752SMark Fasheh 		 * the record on the left (hence the left merge).
3421328d5752SMark Fasheh 		 */
3422328d5752SMark Fasheh 		if (ctxt->c_contig_type == CONTIG_RIGHT) {
3423328d5752SMark Fasheh 			ret = ocfs2_merge_rec_left(inode,
3424677b9752STao Ma 						   path,
3425677b9752STao Ma 						   handle, split_rec,
3426e7d4cb6bSTao Ma 						   dealloc, et,
3427328d5752SMark Fasheh 						   split_index);
3428328d5752SMark Fasheh 			if (ret) {
3429328d5752SMark Fasheh 				mlog_errno(ret);
3430328d5752SMark Fasheh 				goto out;
3431328d5752SMark Fasheh 			}
3432328d5752SMark Fasheh 		} else {
3433328d5752SMark Fasheh 			ret = ocfs2_merge_rec_right(inode,
3434677b9752STao Ma 						    path,
3435677b9752STao Ma 						    handle, split_rec,
3436328d5752SMark Fasheh 						    split_index);
3437328d5752SMark Fasheh 			if (ret) {
3438328d5752SMark Fasheh 				mlog_errno(ret);
3439328d5752SMark Fasheh 				goto out;
3440328d5752SMark Fasheh 			}
3441328d5752SMark Fasheh 		}
3442328d5752SMark Fasheh 
3443328d5752SMark Fasheh 		if (ctxt->c_split_covers_rec) {
3444328d5752SMark Fasheh 			/*
3445328d5752SMark Fasheh 			 * The merge may have left an empty extent in
3446328d5752SMark Fasheh 			 * our leaf. Try to rotate it away.
3447328d5752SMark Fasheh 			 */
3448677b9752STao Ma 			ret = ocfs2_rotate_tree_left(inode, handle, path,
3449e7d4cb6bSTao Ma 						     dealloc, et);
3450328d5752SMark Fasheh 			if (ret)
3451328d5752SMark Fasheh 				mlog_errno(ret);
3452328d5752SMark Fasheh 			ret = 0;
3453328d5752SMark Fasheh 		}
3454328d5752SMark Fasheh 	}
3455328d5752SMark Fasheh 
3456328d5752SMark Fasheh out:
3457328d5752SMark Fasheh 	return ret;
3458328d5752SMark Fasheh }
3459328d5752SMark Fasheh 
3460328d5752SMark Fasheh static void ocfs2_subtract_from_rec(struct super_block *sb,
3461328d5752SMark Fasheh 				    enum ocfs2_split_type split,
3462328d5752SMark Fasheh 				    struct ocfs2_extent_rec *rec,
3463328d5752SMark Fasheh 				    struct ocfs2_extent_rec *split_rec)
3464328d5752SMark Fasheh {
3465328d5752SMark Fasheh 	u64 len_blocks;
3466328d5752SMark Fasheh 
3467328d5752SMark Fasheh 	len_blocks = ocfs2_clusters_to_blocks(sb,
3468328d5752SMark Fasheh 				le16_to_cpu(split_rec->e_leaf_clusters));
3469328d5752SMark Fasheh 
3470328d5752SMark Fasheh 	if (split == SPLIT_LEFT) {
3471328d5752SMark Fasheh 		/*
3472328d5752SMark Fasheh 		 * Region is on the left edge of the existing
3473328d5752SMark Fasheh 		 * record.
3474328d5752SMark Fasheh 		 */
3475328d5752SMark Fasheh 		le32_add_cpu(&rec->e_cpos,
3476328d5752SMark Fasheh 			     le16_to_cpu(split_rec->e_leaf_clusters));
3477328d5752SMark Fasheh 		le64_add_cpu(&rec->e_blkno, len_blocks);
3478328d5752SMark Fasheh 		le16_add_cpu(&rec->e_leaf_clusters,
3479328d5752SMark Fasheh 			     -le16_to_cpu(split_rec->e_leaf_clusters));
3480328d5752SMark Fasheh 	} else {
3481328d5752SMark Fasheh 		/*
3482328d5752SMark Fasheh 		 * Region is on the right edge of the existing
3483328d5752SMark Fasheh 		 * record.
3484328d5752SMark Fasheh 		 */
3485328d5752SMark Fasheh 		le16_add_cpu(&rec->e_leaf_clusters,
3486328d5752SMark Fasheh 			     -le16_to_cpu(split_rec->e_leaf_clusters));
3487328d5752SMark Fasheh 	}
3488328d5752SMark Fasheh }
3489328d5752SMark Fasheh 
3490dcd0538fSMark Fasheh /*
3491dcd0538fSMark Fasheh  * Do the final bits of extent record insertion at the target leaf
3492dcd0538fSMark Fasheh  * list. If this leaf is part of an allocation tree, it is assumed
3493dcd0538fSMark Fasheh  * that the tree above has been prepared.
3494dcd0538fSMark Fasheh  */
3495dcd0538fSMark Fasheh static void ocfs2_insert_at_leaf(struct ocfs2_extent_rec *insert_rec,
3496dcd0538fSMark Fasheh 				 struct ocfs2_extent_list *el,
3497dcd0538fSMark Fasheh 				 struct ocfs2_insert_type *insert,
3498dcd0538fSMark Fasheh 				 struct inode *inode)
3499dcd0538fSMark Fasheh {
3500dcd0538fSMark Fasheh 	int i = insert->ins_contig_index;
3501dcd0538fSMark Fasheh 	unsigned int range;
3502dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *rec;
3503dcd0538fSMark Fasheh 
3504e48edee2SMark Fasheh 	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
3505dcd0538fSMark Fasheh 
3506328d5752SMark Fasheh 	if (insert->ins_split != SPLIT_NONE) {
3507328d5752SMark Fasheh 		i = ocfs2_search_extent_list(el, le32_to_cpu(insert_rec->e_cpos));
3508328d5752SMark Fasheh 		BUG_ON(i == -1);
3509328d5752SMark Fasheh 		rec = &el->l_recs[i];
3510328d5752SMark Fasheh 		ocfs2_subtract_from_rec(inode->i_sb, insert->ins_split, rec,
3511328d5752SMark Fasheh 					insert_rec);
3512328d5752SMark Fasheh 		goto rotate;
3513328d5752SMark Fasheh 	}
3514328d5752SMark Fasheh 
3515dcd0538fSMark Fasheh 	/*
3516dcd0538fSMark Fasheh 	 * Contiguous insert - either left or right.
3517dcd0538fSMark Fasheh 	 */
3518dcd0538fSMark Fasheh 	if (insert->ins_contig != CONTIG_NONE) {
3519dcd0538fSMark Fasheh 		rec = &el->l_recs[i];
3520dcd0538fSMark Fasheh 		if (insert->ins_contig == CONTIG_LEFT) {
3521dcd0538fSMark Fasheh 			rec->e_blkno = insert_rec->e_blkno;
3522dcd0538fSMark Fasheh 			rec->e_cpos = insert_rec->e_cpos;
3523dcd0538fSMark Fasheh 		}
3524e48edee2SMark Fasheh 		le16_add_cpu(&rec->e_leaf_clusters,
3525e48edee2SMark Fasheh 			     le16_to_cpu(insert_rec->e_leaf_clusters));
3526dcd0538fSMark Fasheh 		return;
3527dcd0538fSMark Fasheh 	}
3528dcd0538fSMark Fasheh 
3529dcd0538fSMark Fasheh 	/*
3530dcd0538fSMark Fasheh 	 * Handle insert into an empty leaf.
3531dcd0538fSMark Fasheh 	 */
3532dcd0538fSMark Fasheh 	if (le16_to_cpu(el->l_next_free_rec) == 0 ||
3533dcd0538fSMark Fasheh 	    ((le16_to_cpu(el->l_next_free_rec) == 1) &&
3534dcd0538fSMark Fasheh 	     ocfs2_is_empty_extent(&el->l_recs[0]))) {
3535dcd0538fSMark Fasheh 		el->l_recs[0] = *insert_rec;
3536dcd0538fSMark Fasheh 		el->l_next_free_rec = cpu_to_le16(1);
3537dcd0538fSMark Fasheh 		return;
3538dcd0538fSMark Fasheh 	}
3539dcd0538fSMark Fasheh 
3540dcd0538fSMark Fasheh 	/*
3541dcd0538fSMark Fasheh 	 * Appending insert.
3542dcd0538fSMark Fasheh 	 */
3543dcd0538fSMark Fasheh 	if (insert->ins_appending == APPEND_TAIL) {
3544dcd0538fSMark Fasheh 		i = le16_to_cpu(el->l_next_free_rec) - 1;
3545dcd0538fSMark Fasheh 		rec = &el->l_recs[i];
3546e48edee2SMark Fasheh 		range = le32_to_cpu(rec->e_cpos)
3547e48edee2SMark Fasheh 			+ le16_to_cpu(rec->e_leaf_clusters);
3548dcd0538fSMark Fasheh 		BUG_ON(le32_to_cpu(insert_rec->e_cpos) < range);
3549dcd0538fSMark Fasheh 
3550dcd0538fSMark Fasheh 		mlog_bug_on_msg(le16_to_cpu(el->l_next_free_rec) >=
3551dcd0538fSMark Fasheh 				le16_to_cpu(el->l_count),
3552dcd0538fSMark Fasheh 				"inode %lu, depth %u, count %u, next free %u, "
3553dcd0538fSMark Fasheh 				"rec.cpos %u, rec.clusters %u, "
3554dcd0538fSMark Fasheh 				"insert.cpos %u, insert.clusters %u\n",
3555dcd0538fSMark Fasheh 				inode->i_ino,
3556dcd0538fSMark Fasheh 				le16_to_cpu(el->l_tree_depth),
3557dcd0538fSMark Fasheh 				le16_to_cpu(el->l_count),
3558dcd0538fSMark Fasheh 				le16_to_cpu(el->l_next_free_rec),
3559dcd0538fSMark Fasheh 				le32_to_cpu(el->l_recs[i].e_cpos),
3560e48edee2SMark Fasheh 				le16_to_cpu(el->l_recs[i].e_leaf_clusters),
3561dcd0538fSMark Fasheh 				le32_to_cpu(insert_rec->e_cpos),
3562e48edee2SMark Fasheh 				le16_to_cpu(insert_rec->e_leaf_clusters));
3563dcd0538fSMark Fasheh 		i++;
3564dcd0538fSMark Fasheh 		el->l_recs[i] = *insert_rec;
3565dcd0538fSMark Fasheh 		le16_add_cpu(&el->l_next_free_rec, 1);
3566dcd0538fSMark Fasheh 		return;
3567dcd0538fSMark Fasheh 	}
3568dcd0538fSMark Fasheh 
3569328d5752SMark Fasheh rotate:
3570dcd0538fSMark Fasheh 	/*
3571dcd0538fSMark Fasheh 	 * Ok, we have to rotate.
3572dcd0538fSMark Fasheh 	 *
3573dcd0538fSMark Fasheh 	 * At this point, it is safe to assume that inserting into an
3574dcd0538fSMark Fasheh 	 * empty leaf and appending to a leaf have both been handled
3575dcd0538fSMark Fasheh 	 * above.
3576dcd0538fSMark Fasheh 	 *
3577dcd0538fSMark Fasheh 	 * This leaf needs to have space, either by the empty 1st
3578dcd0538fSMark Fasheh 	 * extent record, or by virtue of an l_next_rec < l_count.
3579dcd0538fSMark Fasheh 	 */
3580dcd0538fSMark Fasheh 	ocfs2_rotate_leaf(el, insert_rec);
3581dcd0538fSMark Fasheh }
3582dcd0538fSMark Fasheh 
3583328d5752SMark Fasheh static void ocfs2_adjust_rightmost_records(struct inode *inode,
3584328d5752SMark Fasheh 					   handle_t *handle,
3585328d5752SMark Fasheh 					   struct ocfs2_path *path,
3586328d5752SMark Fasheh 					   struct ocfs2_extent_rec *insert_rec)
3587328d5752SMark Fasheh {
3588328d5752SMark Fasheh 	int ret, i, next_free;
3589328d5752SMark Fasheh 	struct buffer_head *bh;
3590328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
3591328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec;
3592328d5752SMark Fasheh 
3593328d5752SMark Fasheh 	/*
3594328d5752SMark Fasheh 	 * Update everything except the leaf block.
3595328d5752SMark Fasheh 	 */
3596328d5752SMark Fasheh 	for (i = 0; i < path->p_tree_depth; i++) {
3597328d5752SMark Fasheh 		bh = path->p_node[i].bh;
3598328d5752SMark Fasheh 		el = path->p_node[i].el;
3599328d5752SMark Fasheh 
3600328d5752SMark Fasheh 		next_free = le16_to_cpu(el->l_next_free_rec);
3601328d5752SMark Fasheh 		if (next_free == 0) {
3602328d5752SMark Fasheh 			ocfs2_error(inode->i_sb,
3603328d5752SMark Fasheh 				    "Dinode %llu has a bad extent list",
3604328d5752SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno);
3605328d5752SMark Fasheh 			ret = -EIO;
3606328d5752SMark Fasheh 			return;
3607328d5752SMark Fasheh 		}
3608328d5752SMark Fasheh 
3609328d5752SMark Fasheh 		rec = &el->l_recs[next_free - 1];
3610328d5752SMark Fasheh 
3611328d5752SMark Fasheh 		rec->e_int_clusters = insert_rec->e_cpos;
3612328d5752SMark Fasheh 		le32_add_cpu(&rec->e_int_clusters,
3613328d5752SMark Fasheh 			     le16_to_cpu(insert_rec->e_leaf_clusters));
3614328d5752SMark Fasheh 		le32_add_cpu(&rec->e_int_clusters,
3615328d5752SMark Fasheh 			     -le32_to_cpu(rec->e_cpos));
3616328d5752SMark Fasheh 
3617328d5752SMark Fasheh 		ret = ocfs2_journal_dirty(handle, bh);
3618328d5752SMark Fasheh 		if (ret)
3619328d5752SMark Fasheh 			mlog_errno(ret);
3620328d5752SMark Fasheh 
3621328d5752SMark Fasheh 	}
3622328d5752SMark Fasheh }
3623328d5752SMark Fasheh 
3624dcd0538fSMark Fasheh static int ocfs2_append_rec_to_path(struct inode *inode, handle_t *handle,
3625dcd0538fSMark Fasheh 				    struct ocfs2_extent_rec *insert_rec,
3626dcd0538fSMark Fasheh 				    struct ocfs2_path *right_path,
3627dcd0538fSMark Fasheh 				    struct ocfs2_path **ret_left_path)
3628dcd0538fSMark Fasheh {
3629328d5752SMark Fasheh 	int ret, next_free;
3630dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el;
3631dcd0538fSMark Fasheh 	struct ocfs2_path *left_path = NULL;
3632dcd0538fSMark Fasheh 
3633dcd0538fSMark Fasheh 	*ret_left_path = NULL;
3634dcd0538fSMark Fasheh 
3635dcd0538fSMark Fasheh 	/*
3636e48edee2SMark Fasheh 	 * This shouldn't happen for non-trees. The extent rec cluster
3637e48edee2SMark Fasheh 	 * count manipulation below only works for interior nodes.
3638e48edee2SMark Fasheh 	 */
3639e48edee2SMark Fasheh 	BUG_ON(right_path->p_tree_depth == 0);
3640e48edee2SMark Fasheh 
3641e48edee2SMark Fasheh 	/*
3642dcd0538fSMark Fasheh 	 * If our appending insert is at the leftmost edge of a leaf,
3643dcd0538fSMark Fasheh 	 * then we might need to update the rightmost records of the
3644dcd0538fSMark Fasheh 	 * neighboring path.
3645dcd0538fSMark Fasheh 	 */
3646dcd0538fSMark Fasheh 	el = path_leaf_el(right_path);
3647dcd0538fSMark Fasheh 	next_free = le16_to_cpu(el->l_next_free_rec);
3648dcd0538fSMark Fasheh 	if (next_free == 0 ||
3649dcd0538fSMark Fasheh 	    (next_free == 1 && ocfs2_is_empty_extent(&el->l_recs[0]))) {
3650dcd0538fSMark Fasheh 		u32 left_cpos;
3651dcd0538fSMark Fasheh 
3652dcd0538fSMark Fasheh 		ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path,
3653dcd0538fSMark Fasheh 						    &left_cpos);
3654dcd0538fSMark Fasheh 		if (ret) {
3655dcd0538fSMark Fasheh 			mlog_errno(ret);
3656dcd0538fSMark Fasheh 			goto out;
3657dcd0538fSMark Fasheh 		}
3658dcd0538fSMark Fasheh 
3659dcd0538fSMark Fasheh 		mlog(0, "Append may need a left path update. cpos: %u, "
3660dcd0538fSMark Fasheh 		     "left_cpos: %u\n", le32_to_cpu(insert_rec->e_cpos),
3661dcd0538fSMark Fasheh 		     left_cpos);
3662dcd0538fSMark Fasheh 
3663dcd0538fSMark Fasheh 		/*
3664dcd0538fSMark Fasheh 		 * No need to worry if the append is already in the
3665dcd0538fSMark Fasheh 		 * leftmost leaf.
3666dcd0538fSMark Fasheh 		 */
3667dcd0538fSMark Fasheh 		if (left_cpos) {
3668dcd0538fSMark Fasheh 			left_path = ocfs2_new_path(path_root_bh(right_path),
3669dcd0538fSMark Fasheh 						   path_root_el(right_path));
3670dcd0538fSMark Fasheh 			if (!left_path) {
3671dcd0538fSMark Fasheh 				ret = -ENOMEM;
3672dcd0538fSMark Fasheh 				mlog_errno(ret);
3673dcd0538fSMark Fasheh 				goto out;
3674dcd0538fSMark Fasheh 			}
3675dcd0538fSMark Fasheh 
3676dcd0538fSMark Fasheh 			ret = ocfs2_find_path(inode, left_path, left_cpos);
3677dcd0538fSMark Fasheh 			if (ret) {
3678dcd0538fSMark Fasheh 				mlog_errno(ret);
3679dcd0538fSMark Fasheh 				goto out;
3680dcd0538fSMark Fasheh 			}
3681dcd0538fSMark Fasheh 
3682dcd0538fSMark Fasheh 			/*
3683dcd0538fSMark Fasheh 			 * ocfs2_insert_path() will pass the left_path to the
3684dcd0538fSMark Fasheh 			 * journal for us.
3685dcd0538fSMark Fasheh 			 */
3686dcd0538fSMark Fasheh 		}
3687dcd0538fSMark Fasheh 	}
3688dcd0538fSMark Fasheh 
3689dcd0538fSMark Fasheh 	ret = ocfs2_journal_access_path(inode, handle, right_path);
3690dcd0538fSMark Fasheh 	if (ret) {
3691dcd0538fSMark Fasheh 		mlog_errno(ret);
3692dcd0538fSMark Fasheh 		goto out;
3693dcd0538fSMark Fasheh 	}
3694dcd0538fSMark Fasheh 
3695328d5752SMark Fasheh 	ocfs2_adjust_rightmost_records(inode, handle, right_path, insert_rec);
3696dcd0538fSMark Fasheh 
3697dcd0538fSMark Fasheh 	*ret_left_path = left_path;
3698dcd0538fSMark Fasheh 	ret = 0;
3699dcd0538fSMark Fasheh out:
3700dcd0538fSMark Fasheh 	if (ret != 0)
3701dcd0538fSMark Fasheh 		ocfs2_free_path(left_path);
3702dcd0538fSMark Fasheh 
3703dcd0538fSMark Fasheh 	return ret;
3704dcd0538fSMark Fasheh }
3705dcd0538fSMark Fasheh 
3706328d5752SMark Fasheh static void ocfs2_split_record(struct inode *inode,
3707328d5752SMark Fasheh 			       struct ocfs2_path *left_path,
3708328d5752SMark Fasheh 			       struct ocfs2_path *right_path,
3709328d5752SMark Fasheh 			       struct ocfs2_extent_rec *split_rec,
3710328d5752SMark Fasheh 			       enum ocfs2_split_type split)
3711328d5752SMark Fasheh {
3712328d5752SMark Fasheh 	int index;
3713328d5752SMark Fasheh 	u32 cpos = le32_to_cpu(split_rec->e_cpos);
3714328d5752SMark Fasheh 	struct ocfs2_extent_list *left_el = NULL, *right_el, *insert_el, *el;
3715328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec, *tmprec;
3716328d5752SMark Fasheh 
3717328d5752SMark Fasheh 	right_el = path_leaf_el(right_path);;
3718328d5752SMark Fasheh 	if (left_path)
3719328d5752SMark Fasheh 		left_el = path_leaf_el(left_path);
3720328d5752SMark Fasheh 
3721328d5752SMark Fasheh 	el = right_el;
3722328d5752SMark Fasheh 	insert_el = right_el;
3723328d5752SMark Fasheh 	index = ocfs2_search_extent_list(el, cpos);
3724328d5752SMark Fasheh 	if (index != -1) {
3725328d5752SMark Fasheh 		if (index == 0 && left_path) {
3726328d5752SMark Fasheh 			BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
3727328d5752SMark Fasheh 
3728328d5752SMark Fasheh 			/*
3729328d5752SMark Fasheh 			 * This typically means that the record
3730328d5752SMark Fasheh 			 * started in the left path but moved to the
3731328d5752SMark Fasheh 			 * right as a result of rotation. We either
3732328d5752SMark Fasheh 			 * move the existing record to the left, or we
3733328d5752SMark Fasheh 			 * do the later insert there.
3734328d5752SMark Fasheh 			 *
3735328d5752SMark Fasheh 			 * In this case, the left path should always
3736328d5752SMark Fasheh 			 * exist as the rotate code will have passed
3737328d5752SMark Fasheh 			 * it back for a post-insert update.
3738328d5752SMark Fasheh 			 */
3739328d5752SMark Fasheh 
3740328d5752SMark Fasheh 			if (split == SPLIT_LEFT) {
3741328d5752SMark Fasheh 				/*
3742328d5752SMark Fasheh 				 * It's a left split. Since we know
3743328d5752SMark Fasheh 				 * that the rotate code gave us an
3744328d5752SMark Fasheh 				 * empty extent in the left path, we
3745328d5752SMark Fasheh 				 * can just do the insert there.
3746328d5752SMark Fasheh 				 */
3747328d5752SMark Fasheh 				insert_el = left_el;
3748328d5752SMark Fasheh 			} else {
3749328d5752SMark Fasheh 				/*
3750328d5752SMark Fasheh 				 * Right split - we have to move the
3751328d5752SMark Fasheh 				 * existing record over to the left
3752328d5752SMark Fasheh 				 * leaf. The insert will be into the
3753328d5752SMark Fasheh 				 * newly created empty extent in the
3754328d5752SMark Fasheh 				 * right leaf.
3755328d5752SMark Fasheh 				 */
3756328d5752SMark Fasheh 				tmprec = &right_el->l_recs[index];
3757328d5752SMark Fasheh 				ocfs2_rotate_leaf(left_el, tmprec);
3758328d5752SMark Fasheh 				el = left_el;
3759328d5752SMark Fasheh 
3760328d5752SMark Fasheh 				memset(tmprec, 0, sizeof(*tmprec));
3761328d5752SMark Fasheh 				index = ocfs2_search_extent_list(left_el, cpos);
3762328d5752SMark Fasheh 				BUG_ON(index == -1);
3763328d5752SMark Fasheh 			}
3764328d5752SMark Fasheh 		}
3765328d5752SMark Fasheh 	} else {
3766328d5752SMark Fasheh 		BUG_ON(!left_path);
3767328d5752SMark Fasheh 		BUG_ON(!ocfs2_is_empty_extent(&left_el->l_recs[0]));
3768328d5752SMark Fasheh 		/*
3769328d5752SMark Fasheh 		 * Left path is easy - we can just allow the insert to
3770328d5752SMark Fasheh 		 * happen.
3771328d5752SMark Fasheh 		 */
3772328d5752SMark Fasheh 		el = left_el;
3773328d5752SMark Fasheh 		insert_el = left_el;
3774328d5752SMark Fasheh 		index = ocfs2_search_extent_list(el, cpos);
3775328d5752SMark Fasheh 		BUG_ON(index == -1);
3776328d5752SMark Fasheh 	}
3777328d5752SMark Fasheh 
3778328d5752SMark Fasheh 	rec = &el->l_recs[index];
3779328d5752SMark Fasheh 	ocfs2_subtract_from_rec(inode->i_sb, split, rec, split_rec);
3780328d5752SMark Fasheh 	ocfs2_rotate_leaf(insert_el, split_rec);
3781328d5752SMark Fasheh }
3782328d5752SMark Fasheh 
3783dcd0538fSMark Fasheh /*
3784e7d4cb6bSTao Ma  * This function only does inserts on an allocation b-tree. For tree
3785e7d4cb6bSTao Ma  * depth = 0, ocfs2_insert_at_leaf() is called directly.
3786dcd0538fSMark Fasheh  *
3787dcd0538fSMark Fasheh  * right_path is the path we want to do the actual insert
3788dcd0538fSMark Fasheh  * in. left_path should only be passed in if we need to update that
3789dcd0538fSMark Fasheh  * portion of the tree after an edge insert.
3790dcd0538fSMark Fasheh  */
3791dcd0538fSMark Fasheh static int ocfs2_insert_path(struct inode *inode,
3792dcd0538fSMark Fasheh 			     handle_t *handle,
3793dcd0538fSMark Fasheh 			     struct ocfs2_path *left_path,
3794dcd0538fSMark Fasheh 			     struct ocfs2_path *right_path,
3795dcd0538fSMark Fasheh 			     struct ocfs2_extent_rec *insert_rec,
3796dcd0538fSMark Fasheh 			     struct ocfs2_insert_type *insert)
3797dcd0538fSMark Fasheh {
3798dcd0538fSMark Fasheh 	int ret, subtree_index;
3799dcd0538fSMark Fasheh 	struct buffer_head *leaf_bh = path_leaf_bh(right_path);
3800dcd0538fSMark Fasheh 
3801dcd0538fSMark Fasheh 	if (left_path) {
3802dcd0538fSMark Fasheh 		int credits = handle->h_buffer_credits;
3803dcd0538fSMark Fasheh 
3804dcd0538fSMark Fasheh 		/*
3805dcd0538fSMark Fasheh 		 * There's a chance that left_path got passed back to
3806dcd0538fSMark Fasheh 		 * us without being accounted for in the
3807dcd0538fSMark Fasheh 		 * journal. Extend our transaction here to be sure we
3808dcd0538fSMark Fasheh 		 * can change those blocks.
3809dcd0538fSMark Fasheh 		 */
3810dcd0538fSMark Fasheh 		credits += left_path->p_tree_depth;
3811dcd0538fSMark Fasheh 
3812dcd0538fSMark Fasheh 		ret = ocfs2_extend_trans(handle, credits);
3813dcd0538fSMark Fasheh 		if (ret < 0) {
3814dcd0538fSMark Fasheh 			mlog_errno(ret);
3815dcd0538fSMark Fasheh 			goto out;
3816dcd0538fSMark Fasheh 		}
3817dcd0538fSMark Fasheh 
3818dcd0538fSMark Fasheh 		ret = ocfs2_journal_access_path(inode, handle, left_path);
3819dcd0538fSMark Fasheh 		if (ret < 0) {
3820dcd0538fSMark Fasheh 			mlog_errno(ret);
3821dcd0538fSMark Fasheh 			goto out;
3822dcd0538fSMark Fasheh 		}
3823dcd0538fSMark Fasheh 	}
3824dcd0538fSMark Fasheh 
3825e8aed345SMark Fasheh 	/*
3826e8aed345SMark Fasheh 	 * Pass both paths to the journal. The majority of inserts
3827e8aed345SMark Fasheh 	 * will be touching all components anyway.
3828e8aed345SMark Fasheh 	 */
3829e8aed345SMark Fasheh 	ret = ocfs2_journal_access_path(inode, handle, right_path);
3830e8aed345SMark Fasheh 	if (ret < 0) {
3831e8aed345SMark Fasheh 		mlog_errno(ret);
3832e8aed345SMark Fasheh 		goto out;
3833e8aed345SMark Fasheh 	}
3834e8aed345SMark Fasheh 
3835328d5752SMark Fasheh 	if (insert->ins_split != SPLIT_NONE) {
3836328d5752SMark Fasheh 		/*
3837328d5752SMark Fasheh 		 * We could call ocfs2_insert_at_leaf() for some types
3838c78bad11SJoe Perches 		 * of splits, but it's easier to just let one separate
3839328d5752SMark Fasheh 		 * function sort it all out.
3840328d5752SMark Fasheh 		 */
3841328d5752SMark Fasheh 		ocfs2_split_record(inode, left_path, right_path,
3842328d5752SMark Fasheh 				   insert_rec, insert->ins_split);
3843e8aed345SMark Fasheh 
3844e8aed345SMark Fasheh 		/*
3845e8aed345SMark Fasheh 		 * Split might have modified either leaf and we don't
3846e8aed345SMark Fasheh 		 * have a guarantee that the later edge insert will
3847e8aed345SMark Fasheh 		 * dirty this for us.
3848e8aed345SMark Fasheh 		 */
3849e8aed345SMark Fasheh 		if (left_path)
3850e8aed345SMark Fasheh 			ret = ocfs2_journal_dirty(handle,
3851e8aed345SMark Fasheh 						  path_leaf_bh(left_path));
3852e8aed345SMark Fasheh 			if (ret)
3853e8aed345SMark Fasheh 				mlog_errno(ret);
3854328d5752SMark Fasheh 	} else
3855328d5752SMark Fasheh 		ocfs2_insert_at_leaf(insert_rec, path_leaf_el(right_path),
3856328d5752SMark Fasheh 				     insert, inode);
3857dcd0538fSMark Fasheh 
3858dcd0538fSMark Fasheh 	ret = ocfs2_journal_dirty(handle, leaf_bh);
3859dcd0538fSMark Fasheh 	if (ret)
3860dcd0538fSMark Fasheh 		mlog_errno(ret);
3861dcd0538fSMark Fasheh 
3862dcd0538fSMark Fasheh 	if (left_path) {
3863dcd0538fSMark Fasheh 		/*
3864dcd0538fSMark Fasheh 		 * The rotate code has indicated that we need to fix
3865dcd0538fSMark Fasheh 		 * up portions of the tree after the insert.
3866dcd0538fSMark Fasheh 		 *
3867dcd0538fSMark Fasheh 		 * XXX: Should we extend the transaction here?
3868dcd0538fSMark Fasheh 		 */
3869dcd0538fSMark Fasheh 		subtree_index = ocfs2_find_subtree_root(inode, left_path,
3870dcd0538fSMark Fasheh 							right_path);
3871dcd0538fSMark Fasheh 		ocfs2_complete_edge_insert(inode, handle, left_path,
3872dcd0538fSMark Fasheh 					   right_path, subtree_index);
3873dcd0538fSMark Fasheh 	}
3874dcd0538fSMark Fasheh 
3875dcd0538fSMark Fasheh 	ret = 0;
3876dcd0538fSMark Fasheh out:
3877dcd0538fSMark Fasheh 	return ret;
3878dcd0538fSMark Fasheh }
3879dcd0538fSMark Fasheh 
3880dcd0538fSMark Fasheh static int ocfs2_do_insert_extent(struct inode *inode,
3881dcd0538fSMark Fasheh 				  handle_t *handle,
3882e7d4cb6bSTao Ma 				  struct ocfs2_extent_tree *et,
3883dcd0538fSMark Fasheh 				  struct ocfs2_extent_rec *insert_rec,
3884dcd0538fSMark Fasheh 				  struct ocfs2_insert_type *type)
3885dcd0538fSMark Fasheh {
3886dcd0538fSMark Fasheh 	int ret, rotate = 0;
3887dcd0538fSMark Fasheh 	u32 cpos;
3888dcd0538fSMark Fasheh 	struct ocfs2_path *right_path = NULL;
3889dcd0538fSMark Fasheh 	struct ocfs2_path *left_path = NULL;
3890dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el;
3891dcd0538fSMark Fasheh 
3892ce1d9ea6SJoel Becker 	el = et->et_root_el;
3893dcd0538fSMark Fasheh 
3894ce1d9ea6SJoel Becker 	ret = ocfs2_journal_access(handle, inode, et->et_root_bh,
3895dcd0538fSMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
3896dcd0538fSMark Fasheh 	if (ret) {
3897dcd0538fSMark Fasheh 		mlog_errno(ret);
3898dcd0538fSMark Fasheh 		goto out;
3899dcd0538fSMark Fasheh 	}
3900dcd0538fSMark Fasheh 
3901dcd0538fSMark Fasheh 	if (le16_to_cpu(el->l_tree_depth) == 0) {
3902dcd0538fSMark Fasheh 		ocfs2_insert_at_leaf(insert_rec, el, type, inode);
3903dcd0538fSMark Fasheh 		goto out_update_clusters;
3904dcd0538fSMark Fasheh 	}
3905dcd0538fSMark Fasheh 
3906ce1d9ea6SJoel Becker 	right_path = ocfs2_new_path(et->et_root_bh, et->et_root_el);
3907dcd0538fSMark Fasheh 	if (!right_path) {
3908dcd0538fSMark Fasheh 		ret = -ENOMEM;
3909dcd0538fSMark Fasheh 		mlog_errno(ret);
3910dcd0538fSMark Fasheh 		goto out;
3911dcd0538fSMark Fasheh 	}
3912dcd0538fSMark Fasheh 
3913dcd0538fSMark Fasheh 	/*
3914dcd0538fSMark Fasheh 	 * Determine the path to start with. Rotations need the
3915dcd0538fSMark Fasheh 	 * rightmost path, everything else can go directly to the
3916dcd0538fSMark Fasheh 	 * target leaf.
3917dcd0538fSMark Fasheh 	 */
3918dcd0538fSMark Fasheh 	cpos = le32_to_cpu(insert_rec->e_cpos);
3919dcd0538fSMark Fasheh 	if (type->ins_appending == APPEND_NONE &&
3920dcd0538fSMark Fasheh 	    type->ins_contig == CONTIG_NONE) {
3921dcd0538fSMark Fasheh 		rotate = 1;
3922dcd0538fSMark Fasheh 		cpos = UINT_MAX;
3923dcd0538fSMark Fasheh 	}
3924dcd0538fSMark Fasheh 
3925dcd0538fSMark Fasheh 	ret = ocfs2_find_path(inode, right_path, cpos);
3926dcd0538fSMark Fasheh 	if (ret) {
3927dcd0538fSMark Fasheh 		mlog_errno(ret);
3928dcd0538fSMark Fasheh 		goto out;
3929dcd0538fSMark Fasheh 	}
3930dcd0538fSMark Fasheh 
3931dcd0538fSMark Fasheh 	/*
3932dcd0538fSMark Fasheh 	 * Rotations and appends need special treatment - they modify
3933dcd0538fSMark Fasheh 	 * parts of the tree's above them.
3934dcd0538fSMark Fasheh 	 *
3935dcd0538fSMark Fasheh 	 * Both might pass back a path immediate to the left of the
3936dcd0538fSMark Fasheh 	 * one being inserted to. This will be cause
3937dcd0538fSMark Fasheh 	 * ocfs2_insert_path() to modify the rightmost records of
3938dcd0538fSMark Fasheh 	 * left_path to account for an edge insert.
3939dcd0538fSMark Fasheh 	 *
3940dcd0538fSMark Fasheh 	 * XXX: When modifying this code, keep in mind that an insert
3941dcd0538fSMark Fasheh 	 * can wind up skipping both of these two special cases...
3942dcd0538fSMark Fasheh 	 */
3943dcd0538fSMark Fasheh 	if (rotate) {
3944328d5752SMark Fasheh 		ret = ocfs2_rotate_tree_right(inode, handle, type->ins_split,
3945dcd0538fSMark Fasheh 					      le32_to_cpu(insert_rec->e_cpos),
3946dcd0538fSMark Fasheh 					      right_path, &left_path);
3947dcd0538fSMark Fasheh 		if (ret) {
3948dcd0538fSMark Fasheh 			mlog_errno(ret);
3949dcd0538fSMark Fasheh 			goto out;
3950dcd0538fSMark Fasheh 		}
3951e8aed345SMark Fasheh 
3952e8aed345SMark Fasheh 		/*
3953e8aed345SMark Fasheh 		 * ocfs2_rotate_tree_right() might have extended the
3954e8aed345SMark Fasheh 		 * transaction without re-journaling our tree root.
3955e8aed345SMark Fasheh 		 */
3956ce1d9ea6SJoel Becker 		ret = ocfs2_journal_access(handle, inode, et->et_root_bh,
3957e8aed345SMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
3958e8aed345SMark Fasheh 		if (ret) {
3959e8aed345SMark Fasheh 			mlog_errno(ret);
3960e8aed345SMark Fasheh 			goto out;
3961e8aed345SMark Fasheh 		}
3962dcd0538fSMark Fasheh 	} else if (type->ins_appending == APPEND_TAIL
3963dcd0538fSMark Fasheh 		   && type->ins_contig != CONTIG_LEFT) {
3964dcd0538fSMark Fasheh 		ret = ocfs2_append_rec_to_path(inode, handle, insert_rec,
3965dcd0538fSMark Fasheh 					       right_path, &left_path);
3966dcd0538fSMark Fasheh 		if (ret) {
3967dcd0538fSMark Fasheh 			mlog_errno(ret);
3968dcd0538fSMark Fasheh 			goto out;
3969dcd0538fSMark Fasheh 		}
3970dcd0538fSMark Fasheh 	}
3971dcd0538fSMark Fasheh 
3972dcd0538fSMark Fasheh 	ret = ocfs2_insert_path(inode, handle, left_path, right_path,
3973dcd0538fSMark Fasheh 				insert_rec, type);
3974dcd0538fSMark Fasheh 	if (ret) {
3975dcd0538fSMark Fasheh 		mlog_errno(ret);
3976dcd0538fSMark Fasheh 		goto out;
3977dcd0538fSMark Fasheh 	}
3978dcd0538fSMark Fasheh 
3979dcd0538fSMark Fasheh out_update_clusters:
3980328d5752SMark Fasheh 	if (type->ins_split == SPLIT_NONE)
398135dc0aa3SJoel Becker 		ocfs2_et_update_clusters(inode, et,
3982e48edee2SMark Fasheh 					 le16_to_cpu(insert_rec->e_leaf_clusters));
3983dcd0538fSMark Fasheh 
3984ce1d9ea6SJoel Becker 	ret = ocfs2_journal_dirty(handle, et->et_root_bh);
3985dcd0538fSMark Fasheh 	if (ret)
3986dcd0538fSMark Fasheh 		mlog_errno(ret);
3987dcd0538fSMark Fasheh 
3988dcd0538fSMark Fasheh out:
3989dcd0538fSMark Fasheh 	ocfs2_free_path(left_path);
3990dcd0538fSMark Fasheh 	ocfs2_free_path(right_path);
3991dcd0538fSMark Fasheh 
3992dcd0538fSMark Fasheh 	return ret;
3993dcd0538fSMark Fasheh }
3994dcd0538fSMark Fasheh 
3995328d5752SMark Fasheh static enum ocfs2_contig_type
3996ad5a4d70STao Ma ocfs2_figure_merge_contig_type(struct inode *inode, struct ocfs2_path *path,
3997328d5752SMark Fasheh 			       struct ocfs2_extent_list *el, int index,
3998328d5752SMark Fasheh 			       struct ocfs2_extent_rec *split_rec)
3999328d5752SMark Fasheh {
4000ad5a4d70STao Ma 	int status;
4001328d5752SMark Fasheh 	enum ocfs2_contig_type ret = CONTIG_NONE;
4002ad5a4d70STao Ma 	u32 left_cpos, right_cpos;
4003ad5a4d70STao Ma 	struct ocfs2_extent_rec *rec = NULL;
4004ad5a4d70STao Ma 	struct ocfs2_extent_list *new_el;
4005ad5a4d70STao Ma 	struct ocfs2_path *left_path = NULL, *right_path = NULL;
4006ad5a4d70STao Ma 	struct buffer_head *bh;
4007ad5a4d70STao Ma 	struct ocfs2_extent_block *eb;
4008ad5a4d70STao Ma 
4009ad5a4d70STao Ma 	if (index > 0) {
4010ad5a4d70STao Ma 		rec = &el->l_recs[index - 1];
4011ad5a4d70STao Ma 	} else if (path->p_tree_depth > 0) {
4012ad5a4d70STao Ma 		status = ocfs2_find_cpos_for_left_leaf(inode->i_sb,
4013ad5a4d70STao Ma 						       path, &left_cpos);
4014ad5a4d70STao Ma 		if (status)
4015ad5a4d70STao Ma 			goto out;
4016ad5a4d70STao Ma 
4017ad5a4d70STao Ma 		if (left_cpos != 0) {
4018ad5a4d70STao Ma 			left_path = ocfs2_new_path(path_root_bh(path),
4019ad5a4d70STao Ma 						   path_root_el(path));
4020ad5a4d70STao Ma 			if (!left_path)
4021ad5a4d70STao Ma 				goto out;
4022ad5a4d70STao Ma 
4023ad5a4d70STao Ma 			status = ocfs2_find_path(inode, left_path, left_cpos);
4024ad5a4d70STao Ma 			if (status)
4025ad5a4d70STao Ma 				goto out;
4026ad5a4d70STao Ma 
4027ad5a4d70STao Ma 			new_el = path_leaf_el(left_path);
4028ad5a4d70STao Ma 
4029ad5a4d70STao Ma 			if (le16_to_cpu(new_el->l_next_free_rec) !=
4030ad5a4d70STao Ma 			    le16_to_cpu(new_el->l_count)) {
4031ad5a4d70STao Ma 				bh = path_leaf_bh(left_path);
4032ad5a4d70STao Ma 				eb = (struct ocfs2_extent_block *)bh->b_data;
4033ad5a4d70STao Ma 				OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb,
4034ad5a4d70STao Ma 								 eb);
4035ad5a4d70STao Ma 				goto out;
4036ad5a4d70STao Ma 			}
4037ad5a4d70STao Ma 			rec = &new_el->l_recs[
4038ad5a4d70STao Ma 				le16_to_cpu(new_el->l_next_free_rec) - 1];
4039ad5a4d70STao Ma 		}
4040ad5a4d70STao Ma 	}
4041328d5752SMark Fasheh 
4042328d5752SMark Fasheh 	/*
4043328d5752SMark Fasheh 	 * We're careful to check for an empty extent record here -
4044328d5752SMark Fasheh 	 * the merge code will know what to do if it sees one.
4045328d5752SMark Fasheh 	 */
4046ad5a4d70STao Ma 	if (rec) {
4047328d5752SMark Fasheh 		if (index == 1 && ocfs2_is_empty_extent(rec)) {
4048328d5752SMark Fasheh 			if (split_rec->e_cpos == el->l_recs[index].e_cpos)
4049328d5752SMark Fasheh 				ret = CONTIG_RIGHT;
4050328d5752SMark Fasheh 		} else {
4051328d5752SMark Fasheh 			ret = ocfs2_extent_contig(inode, rec, split_rec);
4052328d5752SMark Fasheh 		}
4053328d5752SMark Fasheh 	}
4054328d5752SMark Fasheh 
4055ad5a4d70STao Ma 	rec = NULL;
4056ad5a4d70STao Ma 	if (index < (le16_to_cpu(el->l_next_free_rec) - 1))
4057ad5a4d70STao Ma 		rec = &el->l_recs[index + 1];
4058ad5a4d70STao Ma 	else if (le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count) &&
4059ad5a4d70STao Ma 		 path->p_tree_depth > 0) {
4060ad5a4d70STao Ma 		status = ocfs2_find_cpos_for_right_leaf(inode->i_sb,
4061ad5a4d70STao Ma 							path, &right_cpos);
4062ad5a4d70STao Ma 		if (status)
4063ad5a4d70STao Ma 			goto out;
4064ad5a4d70STao Ma 
4065ad5a4d70STao Ma 		if (right_cpos == 0)
4066ad5a4d70STao Ma 			goto out;
4067ad5a4d70STao Ma 
4068ad5a4d70STao Ma 		right_path = ocfs2_new_path(path_root_bh(path),
4069ad5a4d70STao Ma 					    path_root_el(path));
4070ad5a4d70STao Ma 		if (!right_path)
4071ad5a4d70STao Ma 			goto out;
4072ad5a4d70STao Ma 
4073ad5a4d70STao Ma 		status = ocfs2_find_path(inode, right_path, right_cpos);
4074ad5a4d70STao Ma 		if (status)
4075ad5a4d70STao Ma 			goto out;
4076ad5a4d70STao Ma 
4077ad5a4d70STao Ma 		new_el = path_leaf_el(right_path);
4078ad5a4d70STao Ma 		rec = &new_el->l_recs[0];
4079ad5a4d70STao Ma 		if (ocfs2_is_empty_extent(rec)) {
4080ad5a4d70STao Ma 			if (le16_to_cpu(new_el->l_next_free_rec) <= 1) {
4081ad5a4d70STao Ma 				bh = path_leaf_bh(right_path);
4082ad5a4d70STao Ma 				eb = (struct ocfs2_extent_block *)bh->b_data;
4083ad5a4d70STao Ma 				OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb,
4084ad5a4d70STao Ma 								 eb);
4085ad5a4d70STao Ma 				goto out;
4086ad5a4d70STao Ma 			}
4087ad5a4d70STao Ma 			rec = &new_el->l_recs[1];
4088ad5a4d70STao Ma 		}
4089ad5a4d70STao Ma 	}
4090ad5a4d70STao Ma 
4091ad5a4d70STao Ma 	if (rec) {
4092328d5752SMark Fasheh 		enum ocfs2_contig_type contig_type;
4093328d5752SMark Fasheh 
4094328d5752SMark Fasheh 		contig_type = ocfs2_extent_contig(inode, rec, split_rec);
4095328d5752SMark Fasheh 
4096328d5752SMark Fasheh 		if (contig_type == CONTIG_LEFT && ret == CONTIG_RIGHT)
4097328d5752SMark Fasheh 			ret = CONTIG_LEFTRIGHT;
4098328d5752SMark Fasheh 		else if (ret == CONTIG_NONE)
4099328d5752SMark Fasheh 			ret = contig_type;
4100328d5752SMark Fasheh 	}
4101328d5752SMark Fasheh 
4102ad5a4d70STao Ma out:
4103ad5a4d70STao Ma 	if (left_path)
4104ad5a4d70STao Ma 		ocfs2_free_path(left_path);
4105ad5a4d70STao Ma 	if (right_path)
4106ad5a4d70STao Ma 		ocfs2_free_path(right_path);
4107ad5a4d70STao Ma 
4108328d5752SMark Fasheh 	return ret;
4109328d5752SMark Fasheh }
4110328d5752SMark Fasheh 
4111dcd0538fSMark Fasheh static void ocfs2_figure_contig_type(struct inode *inode,
4112dcd0538fSMark Fasheh 				     struct ocfs2_insert_type *insert,
4113dcd0538fSMark Fasheh 				     struct ocfs2_extent_list *el,
4114ca12b7c4STao Ma 				     struct ocfs2_extent_rec *insert_rec,
4115ca12b7c4STao Ma 				     struct ocfs2_extent_tree *et)
4116dcd0538fSMark Fasheh {
4117dcd0538fSMark Fasheh 	int i;
4118dcd0538fSMark Fasheh 	enum ocfs2_contig_type contig_type = CONTIG_NONE;
4119dcd0538fSMark Fasheh 
4120e48edee2SMark Fasheh 	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4121e48edee2SMark Fasheh 
4122dcd0538fSMark Fasheh 	for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
4123dcd0538fSMark Fasheh 		contig_type = ocfs2_extent_contig(inode, &el->l_recs[i],
4124dcd0538fSMark Fasheh 						  insert_rec);
4125dcd0538fSMark Fasheh 		if (contig_type != CONTIG_NONE) {
4126dcd0538fSMark Fasheh 			insert->ins_contig_index = i;
4127dcd0538fSMark Fasheh 			break;
4128dcd0538fSMark Fasheh 		}
4129dcd0538fSMark Fasheh 	}
4130dcd0538fSMark Fasheh 	insert->ins_contig = contig_type;
4131ca12b7c4STao Ma 
4132ca12b7c4STao Ma 	if (insert->ins_contig != CONTIG_NONE) {
4133ca12b7c4STao Ma 		struct ocfs2_extent_rec *rec =
4134ca12b7c4STao Ma 				&el->l_recs[insert->ins_contig_index];
4135ca12b7c4STao Ma 		unsigned int len = le16_to_cpu(rec->e_leaf_clusters) +
4136ca12b7c4STao Ma 				   le16_to_cpu(insert_rec->e_leaf_clusters);
4137ca12b7c4STao Ma 
4138ca12b7c4STao Ma 		/*
4139ca12b7c4STao Ma 		 * Caller might want us to limit the size of extents, don't
4140ca12b7c4STao Ma 		 * calculate contiguousness if we might exceed that limit.
4141ca12b7c4STao Ma 		 */
4142ce1d9ea6SJoel Becker 		if (et->et_max_leaf_clusters &&
4143ce1d9ea6SJoel Becker 		    (len > et->et_max_leaf_clusters))
4144ca12b7c4STao Ma 			insert->ins_contig = CONTIG_NONE;
4145ca12b7c4STao Ma 	}
4146dcd0538fSMark Fasheh }
4147dcd0538fSMark Fasheh 
4148dcd0538fSMark Fasheh /*
4149dcd0538fSMark Fasheh  * This should only be called against the righmost leaf extent list.
4150dcd0538fSMark Fasheh  *
4151dcd0538fSMark Fasheh  * ocfs2_figure_appending_type() will figure out whether we'll have to
4152dcd0538fSMark Fasheh  * insert at the tail of the rightmost leaf.
4153dcd0538fSMark Fasheh  *
4154e7d4cb6bSTao Ma  * This should also work against the root extent list for tree's with 0
4155e7d4cb6bSTao Ma  * depth. If we consider the root extent list to be the rightmost leaf node
4156dcd0538fSMark Fasheh  * then the logic here makes sense.
4157dcd0538fSMark Fasheh  */
4158dcd0538fSMark Fasheh static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert,
4159dcd0538fSMark Fasheh 					struct ocfs2_extent_list *el,
4160dcd0538fSMark Fasheh 					struct ocfs2_extent_rec *insert_rec)
4161dcd0538fSMark Fasheh {
4162dcd0538fSMark Fasheh 	int i;
4163dcd0538fSMark Fasheh 	u32 cpos = le32_to_cpu(insert_rec->e_cpos);
4164dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *rec;
4165dcd0538fSMark Fasheh 
4166dcd0538fSMark Fasheh 	insert->ins_appending = APPEND_NONE;
4167dcd0538fSMark Fasheh 
4168e48edee2SMark Fasheh 	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4169dcd0538fSMark Fasheh 
4170dcd0538fSMark Fasheh 	if (!el->l_next_free_rec)
4171dcd0538fSMark Fasheh 		goto set_tail_append;
4172dcd0538fSMark Fasheh 
4173dcd0538fSMark Fasheh 	if (ocfs2_is_empty_extent(&el->l_recs[0])) {
4174dcd0538fSMark Fasheh 		/* Were all records empty? */
4175dcd0538fSMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) == 1)
4176dcd0538fSMark Fasheh 			goto set_tail_append;
4177dcd0538fSMark Fasheh 	}
4178dcd0538fSMark Fasheh 
4179dcd0538fSMark Fasheh 	i = le16_to_cpu(el->l_next_free_rec) - 1;
4180dcd0538fSMark Fasheh 	rec = &el->l_recs[i];
4181dcd0538fSMark Fasheh 
4182e48edee2SMark Fasheh 	if (cpos >=
4183e48edee2SMark Fasheh 	    (le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)))
4184dcd0538fSMark Fasheh 		goto set_tail_append;
4185dcd0538fSMark Fasheh 
4186dcd0538fSMark Fasheh 	return;
4187dcd0538fSMark Fasheh 
4188dcd0538fSMark Fasheh set_tail_append:
4189dcd0538fSMark Fasheh 	insert->ins_appending = APPEND_TAIL;
4190dcd0538fSMark Fasheh }
4191dcd0538fSMark Fasheh 
4192dcd0538fSMark Fasheh /*
4193dcd0538fSMark Fasheh  * Helper function called at the begining of an insert.
4194dcd0538fSMark Fasheh  *
4195dcd0538fSMark Fasheh  * This computes a few things that are commonly used in the process of
4196dcd0538fSMark Fasheh  * inserting into the btree:
4197dcd0538fSMark Fasheh  *   - Whether the new extent is contiguous with an existing one.
4198dcd0538fSMark Fasheh  *   - The current tree depth.
4199dcd0538fSMark Fasheh  *   - Whether the insert is an appending one.
4200dcd0538fSMark Fasheh  *   - The total # of free records in the tree.
4201dcd0538fSMark Fasheh  *
4202dcd0538fSMark Fasheh  * All of the information is stored on the ocfs2_insert_type
4203dcd0538fSMark Fasheh  * structure.
4204dcd0538fSMark Fasheh  */
4205dcd0538fSMark Fasheh static int ocfs2_figure_insert_type(struct inode *inode,
4206e7d4cb6bSTao Ma 				    struct ocfs2_extent_tree *et,
4207dcd0538fSMark Fasheh 				    struct buffer_head **last_eb_bh,
4208dcd0538fSMark Fasheh 				    struct ocfs2_extent_rec *insert_rec,
4209c77534f6STao Mao 				    int *free_records,
4210dcd0538fSMark Fasheh 				    struct ocfs2_insert_type *insert)
4211dcd0538fSMark Fasheh {
4212dcd0538fSMark Fasheh 	int ret;
4213dcd0538fSMark Fasheh 	struct ocfs2_extent_block *eb;
4214dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el;
4215dcd0538fSMark Fasheh 	struct ocfs2_path *path = NULL;
4216dcd0538fSMark Fasheh 	struct buffer_head *bh = NULL;
4217dcd0538fSMark Fasheh 
4218328d5752SMark Fasheh 	insert->ins_split = SPLIT_NONE;
4219328d5752SMark Fasheh 
4220ce1d9ea6SJoel Becker 	el = et->et_root_el;
4221dcd0538fSMark Fasheh 	insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth);
4222dcd0538fSMark Fasheh 
4223dcd0538fSMark Fasheh 	if (el->l_tree_depth) {
4224dcd0538fSMark Fasheh 		/*
4225dcd0538fSMark Fasheh 		 * If we have tree depth, we read in the
4226dcd0538fSMark Fasheh 		 * rightmost extent block ahead of time as
4227dcd0538fSMark Fasheh 		 * ocfs2_figure_insert_type() and ocfs2_add_branch()
4228dcd0538fSMark Fasheh 		 * may want it later.
4229dcd0538fSMark Fasheh 		 */
4230dcd0538fSMark Fasheh 		ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
423135dc0aa3SJoel Becker 				       ocfs2_et_get_last_eb_blk(et), &bh,
4232dcd0538fSMark Fasheh 				       OCFS2_BH_CACHED, inode);
4233dcd0538fSMark Fasheh 		if (ret) {
4234dcd0538fSMark Fasheh 			mlog_exit(ret);
4235dcd0538fSMark Fasheh 			goto out;
4236dcd0538fSMark Fasheh 		}
4237dcd0538fSMark Fasheh 		eb = (struct ocfs2_extent_block *) bh->b_data;
4238dcd0538fSMark Fasheh 		el = &eb->h_list;
4239dcd0538fSMark Fasheh 	}
4240dcd0538fSMark Fasheh 
4241dcd0538fSMark Fasheh 	/*
4242dcd0538fSMark Fasheh 	 * Unless we have a contiguous insert, we'll need to know if
4243dcd0538fSMark Fasheh 	 * there is room left in our allocation tree for another
4244dcd0538fSMark Fasheh 	 * extent record.
4245dcd0538fSMark Fasheh 	 *
4246dcd0538fSMark Fasheh 	 * XXX: This test is simplistic, we can search for empty
4247dcd0538fSMark Fasheh 	 * extent records too.
4248dcd0538fSMark Fasheh 	 */
4249c77534f6STao Mao 	*free_records = le16_to_cpu(el->l_count) -
4250dcd0538fSMark Fasheh 		le16_to_cpu(el->l_next_free_rec);
4251dcd0538fSMark Fasheh 
4252dcd0538fSMark Fasheh 	if (!insert->ins_tree_depth) {
4253ca12b7c4STao Ma 		ocfs2_figure_contig_type(inode, insert, el, insert_rec, et);
4254dcd0538fSMark Fasheh 		ocfs2_figure_appending_type(insert, el, insert_rec);
4255dcd0538fSMark Fasheh 		return 0;
4256dcd0538fSMark Fasheh 	}
4257dcd0538fSMark Fasheh 
4258ce1d9ea6SJoel Becker 	path = ocfs2_new_path(et->et_root_bh, et->et_root_el);
4259dcd0538fSMark Fasheh 	if (!path) {
4260dcd0538fSMark Fasheh 		ret = -ENOMEM;
4261dcd0538fSMark Fasheh 		mlog_errno(ret);
4262dcd0538fSMark Fasheh 		goto out;
4263dcd0538fSMark Fasheh 	}
4264dcd0538fSMark Fasheh 
4265dcd0538fSMark Fasheh 	/*
4266dcd0538fSMark Fasheh 	 * In the case that we're inserting past what the tree
4267dcd0538fSMark Fasheh 	 * currently accounts for, ocfs2_find_path() will return for
4268dcd0538fSMark Fasheh 	 * us the rightmost tree path. This is accounted for below in
4269dcd0538fSMark Fasheh 	 * the appending code.
4270dcd0538fSMark Fasheh 	 */
4271dcd0538fSMark Fasheh 	ret = ocfs2_find_path(inode, path, le32_to_cpu(insert_rec->e_cpos));
4272dcd0538fSMark Fasheh 	if (ret) {
4273dcd0538fSMark Fasheh 		mlog_errno(ret);
4274dcd0538fSMark Fasheh 		goto out;
4275dcd0538fSMark Fasheh 	}
4276dcd0538fSMark Fasheh 
4277dcd0538fSMark Fasheh 	el = path_leaf_el(path);
4278dcd0538fSMark Fasheh 
4279dcd0538fSMark Fasheh 	/*
4280dcd0538fSMark Fasheh 	 * Now that we have the path, there's two things we want to determine:
4281dcd0538fSMark Fasheh 	 * 1) Contiguousness (also set contig_index if this is so)
4282dcd0538fSMark Fasheh 	 *
4283dcd0538fSMark Fasheh 	 * 2) Are we doing an append? We can trivially break this up
4284dcd0538fSMark Fasheh          *     into two types of appends: simple record append, or a
4285dcd0538fSMark Fasheh          *     rotate inside the tail leaf.
4286dcd0538fSMark Fasheh 	 */
4287ca12b7c4STao Ma 	ocfs2_figure_contig_type(inode, insert, el, insert_rec, et);
4288dcd0538fSMark Fasheh 
4289dcd0538fSMark Fasheh 	/*
4290dcd0538fSMark Fasheh 	 * The insert code isn't quite ready to deal with all cases of
4291dcd0538fSMark Fasheh 	 * left contiguousness. Specifically, if it's an insert into
4292dcd0538fSMark Fasheh 	 * the 1st record in a leaf, it will require the adjustment of
4293e48edee2SMark Fasheh 	 * cluster count on the last record of the path directly to it's
4294dcd0538fSMark Fasheh 	 * left. For now, just catch that case and fool the layers
4295dcd0538fSMark Fasheh 	 * above us. This works just fine for tree_depth == 0, which
4296dcd0538fSMark Fasheh 	 * is why we allow that above.
4297dcd0538fSMark Fasheh 	 */
4298dcd0538fSMark Fasheh 	if (insert->ins_contig == CONTIG_LEFT &&
4299dcd0538fSMark Fasheh 	    insert->ins_contig_index == 0)
4300dcd0538fSMark Fasheh 		insert->ins_contig = CONTIG_NONE;
4301dcd0538fSMark Fasheh 
4302dcd0538fSMark Fasheh 	/*
4303dcd0538fSMark Fasheh 	 * Ok, so we can simply compare against last_eb to figure out
4304dcd0538fSMark Fasheh 	 * whether the path doesn't exist. This will only happen in
4305dcd0538fSMark Fasheh 	 * the case that we're doing a tail append, so maybe we can
4306dcd0538fSMark Fasheh 	 * take advantage of that information somehow.
4307dcd0538fSMark Fasheh 	 */
430835dc0aa3SJoel Becker 	if (ocfs2_et_get_last_eb_blk(et) ==
4309e7d4cb6bSTao Ma 	    path_leaf_bh(path)->b_blocknr) {
4310dcd0538fSMark Fasheh 		/*
4311dcd0538fSMark Fasheh 		 * Ok, ocfs2_find_path() returned us the rightmost
4312dcd0538fSMark Fasheh 		 * tree path. This might be an appending insert. There are
4313dcd0538fSMark Fasheh 		 * two cases:
4314dcd0538fSMark Fasheh 		 *    1) We're doing a true append at the tail:
4315dcd0538fSMark Fasheh 		 *	-This might even be off the end of the leaf
4316dcd0538fSMark Fasheh 		 *    2) We're "appending" by rotating in the tail
4317dcd0538fSMark Fasheh 		 */
4318dcd0538fSMark Fasheh 		ocfs2_figure_appending_type(insert, el, insert_rec);
4319dcd0538fSMark Fasheh 	}
4320dcd0538fSMark Fasheh 
4321dcd0538fSMark Fasheh out:
4322dcd0538fSMark Fasheh 	ocfs2_free_path(path);
4323dcd0538fSMark Fasheh 
4324dcd0538fSMark Fasheh 	if (ret == 0)
4325dcd0538fSMark Fasheh 		*last_eb_bh = bh;
4326dcd0538fSMark Fasheh 	else
4327dcd0538fSMark Fasheh 		brelse(bh);
4328dcd0538fSMark Fasheh 	return ret;
4329dcd0538fSMark Fasheh }
4330dcd0538fSMark Fasheh 
4331dcd0538fSMark Fasheh /*
4332dcd0538fSMark Fasheh  * Insert an extent into an inode btree.
4333dcd0538fSMark Fasheh  *
4334dcd0538fSMark Fasheh  * The caller needs to update fe->i_clusters
4335dcd0538fSMark Fasheh  */
4336f56654c4STao Ma static int ocfs2_insert_extent(struct ocfs2_super *osb,
43371fabe148SMark Fasheh 			       handle_t *handle,
4338ccd979bdSMark Fasheh 			       struct inode *inode,
4339e7d4cb6bSTao Ma 			       struct buffer_head *root_bh,
4340dcd0538fSMark Fasheh 			       u32 cpos,
4341ccd979bdSMark Fasheh 			       u64 start_blk,
4342ccd979bdSMark Fasheh 			       u32 new_clusters,
43432ae99a60SMark Fasheh 			       u8 flags,
4344e7d4cb6bSTao Ma 			       struct ocfs2_alloc_context *meta_ac,
4345f56654c4STao Ma 			       struct ocfs2_extent_tree *et)
4346ccd979bdSMark Fasheh {
4347c3afcbb3SMark Fasheh 	int status;
4348c77534f6STao Mao 	int uninitialized_var(free_records);
4349ccd979bdSMark Fasheh 	struct buffer_head *last_eb_bh = NULL;
4350dcd0538fSMark Fasheh 	struct ocfs2_insert_type insert = {0, };
4351dcd0538fSMark Fasheh 	struct ocfs2_extent_rec rec;
4352ccd979bdSMark Fasheh 
43531afc32b9SMark Fasheh 	BUG_ON(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL);
43541afc32b9SMark Fasheh 
4355dcd0538fSMark Fasheh 	mlog(0, "add %u clusters at position %u to inode %llu\n",
4356dcd0538fSMark Fasheh 	     new_clusters, cpos, (unsigned long long)OCFS2_I(inode)->ip_blkno);
4357ccd979bdSMark Fasheh 
4358dcd0538fSMark Fasheh 	mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) &&
4359dcd0538fSMark Fasheh 			(OCFS2_I(inode)->ip_clusters != cpos),
4360dcd0538fSMark Fasheh 			"Device %s, asking for sparse allocation: inode %llu, "
4361dcd0538fSMark Fasheh 			"cpos %u, clusters %u\n",
4362dcd0538fSMark Fasheh 			osb->dev_str,
4363dcd0538fSMark Fasheh 			(unsigned long long)OCFS2_I(inode)->ip_blkno, cpos,
4364dcd0538fSMark Fasheh 			OCFS2_I(inode)->ip_clusters);
4365ccd979bdSMark Fasheh 
4366e48edee2SMark Fasheh 	memset(&rec, 0, sizeof(rec));
4367dcd0538fSMark Fasheh 	rec.e_cpos = cpu_to_le32(cpos);
4368dcd0538fSMark Fasheh 	rec.e_blkno = cpu_to_le64(start_blk);
4369e48edee2SMark Fasheh 	rec.e_leaf_clusters = cpu_to_le16(new_clusters);
43702ae99a60SMark Fasheh 	rec.e_flags = flags;
4371ccd979bdSMark Fasheh 
4372e7d4cb6bSTao Ma 	status = ocfs2_figure_insert_type(inode, et, &last_eb_bh, &rec,
4373c77534f6STao Mao 					  &free_records, &insert);
4374ccd979bdSMark Fasheh 	if (status < 0) {
4375dcd0538fSMark Fasheh 		mlog_errno(status);
4376ccd979bdSMark Fasheh 		goto bail;
4377ccd979bdSMark Fasheh 	}
4378ccd979bdSMark Fasheh 
4379dcd0538fSMark Fasheh 	mlog(0, "Insert.appending: %u, Insert.Contig: %u, "
4380dcd0538fSMark Fasheh 	     "Insert.contig_index: %d, Insert.free_records: %d, "
4381dcd0538fSMark Fasheh 	     "Insert.tree_depth: %d\n",
4382dcd0538fSMark Fasheh 	     insert.ins_appending, insert.ins_contig, insert.ins_contig_index,
4383c77534f6STao Mao 	     free_records, insert.ins_tree_depth);
4384dcd0538fSMark Fasheh 
4385c77534f6STao Mao 	if (insert.ins_contig == CONTIG_NONE && free_records == 0) {
4386e7d4cb6bSTao Ma 		status = ocfs2_grow_tree(inode, handle, et,
4387328d5752SMark Fasheh 					 &insert.ins_tree_depth, &last_eb_bh,
4388ccd979bdSMark Fasheh 					 meta_ac);
4389c3afcbb3SMark Fasheh 		if (status) {
4390ccd979bdSMark Fasheh 			mlog_errno(status);
4391ccd979bdSMark Fasheh 			goto bail;
4392ccd979bdSMark Fasheh 		}
4393c3afcbb3SMark Fasheh 	}
4394ccd979bdSMark Fasheh 
4395dcd0538fSMark Fasheh 	/* Finally, we can add clusters. This might rotate the tree for us. */
4396e7d4cb6bSTao Ma 	status = ocfs2_do_insert_extent(inode, handle, et, &rec, &insert);
4397ccd979bdSMark Fasheh 	if (status < 0)
4398ccd979bdSMark Fasheh 		mlog_errno(status);
4399ce1d9ea6SJoel Becker 	else if (et->et_type == OCFS2_DINODE_EXTENT)
440083418978SMark Fasheh 		ocfs2_extent_map_insert_rec(inode, &rec);
4401ccd979bdSMark Fasheh 
4402ccd979bdSMark Fasheh bail:
4403ccd979bdSMark Fasheh 	if (last_eb_bh)
4404ccd979bdSMark Fasheh 		brelse(last_eb_bh);
4405ccd979bdSMark Fasheh 
4406f56654c4STao Ma 	mlog_exit(status);
4407f56654c4STao Ma 	return status;
4408f56654c4STao Ma }
4409f56654c4STao Ma 
4410f56654c4STao Ma int ocfs2_dinode_insert_extent(struct ocfs2_super *osb,
4411f56654c4STao Ma 			       handle_t *handle,
4412f56654c4STao Ma 			       struct inode *inode,
4413f56654c4STao Ma 			       struct buffer_head *root_bh,
4414f56654c4STao Ma 			       u32 cpos,
4415f56654c4STao Ma 			       u64 start_blk,
4416f56654c4STao Ma 			       u32 new_clusters,
4417f56654c4STao Ma 			       u8 flags,
4418f56654c4STao Ma 			       struct ocfs2_alloc_context *meta_ac)
4419f56654c4STao Ma {
4420f56654c4STao Ma 	int status;
4421dc0ce61aSJoel Becker 	struct ocfs2_extent_tree et;
4422f56654c4STao Ma 
4423dc0ce61aSJoel Becker 	ocfs2_get_extent_tree(&et, inode, root_bh, OCFS2_DINODE_EXTENT,
4424dc0ce61aSJoel Becker 			      NULL);
4425f56654c4STao Ma 	status = ocfs2_insert_extent(osb, handle, inode, root_bh,
4426f56654c4STao Ma 				     cpos, start_blk, new_clusters,
4427dc0ce61aSJoel Becker 				     flags, meta_ac, &et);
4428dc0ce61aSJoel Becker 	ocfs2_put_extent_tree(&et);
4429f56654c4STao Ma 
4430f56654c4STao Ma 	return status;
4431f56654c4STao Ma }
4432f56654c4STao Ma 
4433f56654c4STao Ma int ocfs2_xattr_value_insert_extent(struct ocfs2_super *osb,
4434f56654c4STao Ma 				    handle_t *handle,
4435f56654c4STao Ma 				    struct inode *inode,
4436f56654c4STao Ma 				    struct buffer_head *root_bh,
4437f56654c4STao Ma 				    u32 cpos,
4438f56654c4STao Ma 				    u64 start_blk,
4439f56654c4STao Ma 				    u32 new_clusters,
4440f56654c4STao Ma 				    u8 flags,
4441f56654c4STao Ma 				    struct ocfs2_alloc_context *meta_ac,
4442ea5efa15SJoel Becker 				    void *obj)
4443f56654c4STao Ma {
4444f56654c4STao Ma 	int status;
4445dc0ce61aSJoel Becker 	struct ocfs2_extent_tree et;
4446f56654c4STao Ma 
4447dc0ce61aSJoel Becker 	ocfs2_get_extent_tree(&et, inode, root_bh,
4448ea5efa15SJoel Becker 			      OCFS2_XATTR_VALUE_EXTENT, obj);
4449f56654c4STao Ma 	status = ocfs2_insert_extent(osb, handle, inode, root_bh,
4450f56654c4STao Ma 				     cpos, start_blk, new_clusters,
4451dc0ce61aSJoel Becker 				     flags, meta_ac, &et);
4452dc0ce61aSJoel Becker 	ocfs2_put_extent_tree(&et);
4453f56654c4STao Ma 
4454ccd979bdSMark Fasheh 	return status;
4455ccd979bdSMark Fasheh }
4456ccd979bdSMark Fasheh 
4457ba492615STao Ma int ocfs2_xattr_tree_insert_extent(struct ocfs2_super *osb,
4458ba492615STao Ma 				   handle_t *handle,
4459ba492615STao Ma 				   struct inode *inode,
4460ba492615STao Ma 				   struct buffer_head *root_bh,
4461ba492615STao Ma 				   u32 cpos,
4462ba492615STao Ma 				   u64 start_blk,
4463ba492615STao Ma 				   u32 new_clusters,
4464ba492615STao Ma 				   u8 flags,
4465ba492615STao Ma 				   struct ocfs2_alloc_context *meta_ac)
4466ba492615STao Ma {
4467ba492615STao Ma 	int status;
4468dc0ce61aSJoel Becker 	struct ocfs2_extent_tree et;
4469ba492615STao Ma 
4470dc0ce61aSJoel Becker 	ocfs2_get_extent_tree(&et, inode, root_bh, OCFS2_XATTR_TREE_EXTENT,
4471ca12b7c4STao Ma 			      NULL);
4472ba492615STao Ma 	status = ocfs2_insert_extent(osb, handle, inode, root_bh,
4473ba492615STao Ma 				     cpos, start_blk, new_clusters,
4474dc0ce61aSJoel Becker 				     flags, meta_ac, &et);
4475dc0ce61aSJoel Becker 	ocfs2_put_extent_tree(&et);
4476ba492615STao Ma 
4477ba492615STao Ma 	return status;
4478ba492615STao Ma }
4479ba492615STao Ma 
44800eb8d47eSTao Ma /*
44810eb8d47eSTao Ma  * Allcate and add clusters into the extent b-tree.
44820eb8d47eSTao Ma  * The new clusters(clusters_to_add) will be inserted at logical_offset.
44830eb8d47eSTao Ma  * The extent b-tree's root is root_el and it should be in root_bh, and
44840eb8d47eSTao Ma  * it is not limited to the file storage. Any extent tree can use this
44850eb8d47eSTao Ma  * function if it implements the proper ocfs2_extent_tree.
44860eb8d47eSTao Ma  */
44870eb8d47eSTao Ma int ocfs2_add_clusters_in_btree(struct ocfs2_super *osb,
44880eb8d47eSTao Ma 				struct inode *inode,
44890eb8d47eSTao Ma 				u32 *logical_offset,
44900eb8d47eSTao Ma 				u32 clusters_to_add,
44910eb8d47eSTao Ma 				int mark_unwritten,
44920eb8d47eSTao Ma 				struct buffer_head *root_bh,
44930eb8d47eSTao Ma 				struct ocfs2_extent_list *root_el,
44940eb8d47eSTao Ma 				handle_t *handle,
44950eb8d47eSTao Ma 				struct ocfs2_alloc_context *data_ac,
44960eb8d47eSTao Ma 				struct ocfs2_alloc_context *meta_ac,
44970eb8d47eSTao Ma 				enum ocfs2_alloc_restarted *reason_ret,
4498f56654c4STao Ma 				enum ocfs2_extent_tree_type type,
4499ea5efa15SJoel Becker 				void *obj)
45000eb8d47eSTao Ma {
45010eb8d47eSTao Ma 	int status = 0;
45020eb8d47eSTao Ma 	int free_extents;
45030eb8d47eSTao Ma 	enum ocfs2_alloc_restarted reason = RESTART_NONE;
45040eb8d47eSTao Ma 	u32 bit_off, num_bits;
45050eb8d47eSTao Ma 	u64 block;
45060eb8d47eSTao Ma 	u8 flags = 0;
45070eb8d47eSTao Ma 
45080eb8d47eSTao Ma 	BUG_ON(!clusters_to_add);
45090eb8d47eSTao Ma 
45100eb8d47eSTao Ma 	if (mark_unwritten)
45110eb8d47eSTao Ma 		flags = OCFS2_EXT_UNWRITTEN;
45120eb8d47eSTao Ma 
4513f56654c4STao Ma 	free_extents = ocfs2_num_free_extents(osb, inode, root_bh, type,
4514ea5efa15SJoel Becker 					      obj);
45150eb8d47eSTao Ma 	if (free_extents < 0) {
45160eb8d47eSTao Ma 		status = free_extents;
45170eb8d47eSTao Ma 		mlog_errno(status);
45180eb8d47eSTao Ma 		goto leave;
45190eb8d47eSTao Ma 	}
45200eb8d47eSTao Ma 
45210eb8d47eSTao Ma 	/* there are two cases which could cause us to EAGAIN in the
45220eb8d47eSTao Ma 	 * we-need-more-metadata case:
45230eb8d47eSTao Ma 	 * 1) we haven't reserved *any*
45240eb8d47eSTao Ma 	 * 2) we are so fragmented, we've needed to add metadata too
45250eb8d47eSTao Ma 	 *    many times. */
45260eb8d47eSTao Ma 	if (!free_extents && !meta_ac) {
45270eb8d47eSTao Ma 		mlog(0, "we haven't reserved any metadata!\n");
45280eb8d47eSTao Ma 		status = -EAGAIN;
45290eb8d47eSTao Ma 		reason = RESTART_META;
45300eb8d47eSTao Ma 		goto leave;
45310eb8d47eSTao Ma 	} else if ((!free_extents)
45320eb8d47eSTao Ma 		   && (ocfs2_alloc_context_bits_left(meta_ac)
45330eb8d47eSTao Ma 		       < ocfs2_extend_meta_needed(root_el))) {
45340eb8d47eSTao Ma 		mlog(0, "filesystem is really fragmented...\n");
45350eb8d47eSTao Ma 		status = -EAGAIN;
45360eb8d47eSTao Ma 		reason = RESTART_META;
45370eb8d47eSTao Ma 		goto leave;
45380eb8d47eSTao Ma 	}
45390eb8d47eSTao Ma 
45400eb8d47eSTao Ma 	status = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
45410eb8d47eSTao Ma 					clusters_to_add, &bit_off, &num_bits);
45420eb8d47eSTao Ma 	if (status < 0) {
45430eb8d47eSTao Ma 		if (status != -ENOSPC)
45440eb8d47eSTao Ma 			mlog_errno(status);
45450eb8d47eSTao Ma 		goto leave;
45460eb8d47eSTao Ma 	}
45470eb8d47eSTao Ma 
45480eb8d47eSTao Ma 	BUG_ON(num_bits > clusters_to_add);
45490eb8d47eSTao Ma 
45500eb8d47eSTao Ma 	/* reserve our write early -- insert_extent may update the inode */
45510eb8d47eSTao Ma 	status = ocfs2_journal_access(handle, inode, root_bh,
45520eb8d47eSTao Ma 				      OCFS2_JOURNAL_ACCESS_WRITE);
45530eb8d47eSTao Ma 	if (status < 0) {
45540eb8d47eSTao Ma 		mlog_errno(status);
45550eb8d47eSTao Ma 		goto leave;
45560eb8d47eSTao Ma 	}
45570eb8d47eSTao Ma 
45580eb8d47eSTao Ma 	block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
45590eb8d47eSTao Ma 	mlog(0, "Allocating %u clusters at block %u for inode %llu\n",
45600eb8d47eSTao Ma 	     num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
4561f56654c4STao Ma 	if (type == OCFS2_DINODE_EXTENT)
4562f56654c4STao Ma 		status = ocfs2_dinode_insert_extent(osb, handle, inode, root_bh,
4563f56654c4STao Ma 						    *logical_offset, block,
4564f56654c4STao Ma 						    num_bits, flags, meta_ac);
4565ba492615STao Ma 	else if (type == OCFS2_XATTR_TREE_EXTENT)
4566ba492615STao Ma 		status = ocfs2_xattr_tree_insert_extent(osb, handle,
4567ba492615STao Ma 							inode, root_bh,
4568ba492615STao Ma 							*logical_offset,
4569ba492615STao Ma 							block, num_bits, flags,
4570ba492615STao Ma 							meta_ac);
4571f56654c4STao Ma 	else
4572f56654c4STao Ma 		status = ocfs2_xattr_value_insert_extent(osb, handle,
4573f56654c4STao Ma 							 inode, root_bh,
4574f56654c4STao Ma 							 *logical_offset,
4575f56654c4STao Ma 							 block, num_bits, flags,
4576ea5efa15SJoel Becker 							 meta_ac, obj);
45770eb8d47eSTao Ma 	if (status < 0) {
45780eb8d47eSTao Ma 		mlog_errno(status);
45790eb8d47eSTao Ma 		goto leave;
45800eb8d47eSTao Ma 	}
45810eb8d47eSTao Ma 
45820eb8d47eSTao Ma 	status = ocfs2_journal_dirty(handle, root_bh);
45830eb8d47eSTao Ma 	if (status < 0) {
45840eb8d47eSTao Ma 		mlog_errno(status);
45850eb8d47eSTao Ma 		goto leave;
45860eb8d47eSTao Ma 	}
45870eb8d47eSTao Ma 
45880eb8d47eSTao Ma 	clusters_to_add -= num_bits;
45890eb8d47eSTao Ma 	*logical_offset += num_bits;
45900eb8d47eSTao Ma 
45910eb8d47eSTao Ma 	if (clusters_to_add) {
45920eb8d47eSTao Ma 		mlog(0, "need to alloc once more, wanted = %u\n",
45930eb8d47eSTao Ma 		     clusters_to_add);
45940eb8d47eSTao Ma 		status = -EAGAIN;
45950eb8d47eSTao Ma 		reason = RESTART_TRANS;
45960eb8d47eSTao Ma 	}
45970eb8d47eSTao Ma 
45980eb8d47eSTao Ma leave:
45990eb8d47eSTao Ma 	mlog_exit(status);
46000eb8d47eSTao Ma 	if (reason_ret)
46010eb8d47eSTao Ma 		*reason_ret = reason;
46020eb8d47eSTao Ma 	return status;
46030eb8d47eSTao Ma }
46040eb8d47eSTao Ma 
4605328d5752SMark Fasheh static void ocfs2_make_right_split_rec(struct super_block *sb,
4606328d5752SMark Fasheh 				       struct ocfs2_extent_rec *split_rec,
4607328d5752SMark Fasheh 				       u32 cpos,
4608328d5752SMark Fasheh 				       struct ocfs2_extent_rec *rec)
4609328d5752SMark Fasheh {
4610328d5752SMark Fasheh 	u32 rec_cpos = le32_to_cpu(rec->e_cpos);
4611328d5752SMark Fasheh 	u32 rec_range = rec_cpos + le16_to_cpu(rec->e_leaf_clusters);
4612328d5752SMark Fasheh 
4613328d5752SMark Fasheh 	memset(split_rec, 0, sizeof(struct ocfs2_extent_rec));
4614328d5752SMark Fasheh 
4615328d5752SMark Fasheh 	split_rec->e_cpos = cpu_to_le32(cpos);
4616328d5752SMark Fasheh 	split_rec->e_leaf_clusters = cpu_to_le16(rec_range - cpos);
4617328d5752SMark Fasheh 
4618328d5752SMark Fasheh 	split_rec->e_blkno = rec->e_blkno;
4619328d5752SMark Fasheh 	le64_add_cpu(&split_rec->e_blkno,
4620328d5752SMark Fasheh 		     ocfs2_clusters_to_blocks(sb, cpos - rec_cpos));
4621328d5752SMark Fasheh 
4622328d5752SMark Fasheh 	split_rec->e_flags = rec->e_flags;
4623328d5752SMark Fasheh }
4624328d5752SMark Fasheh 
4625328d5752SMark Fasheh static int ocfs2_split_and_insert(struct inode *inode,
4626328d5752SMark Fasheh 				  handle_t *handle,
4627328d5752SMark Fasheh 				  struct ocfs2_path *path,
4628e7d4cb6bSTao Ma 				  struct ocfs2_extent_tree *et,
4629328d5752SMark Fasheh 				  struct buffer_head **last_eb_bh,
4630328d5752SMark Fasheh 				  int split_index,
4631328d5752SMark Fasheh 				  struct ocfs2_extent_rec *orig_split_rec,
4632328d5752SMark Fasheh 				  struct ocfs2_alloc_context *meta_ac)
4633328d5752SMark Fasheh {
4634328d5752SMark Fasheh 	int ret = 0, depth;
4635328d5752SMark Fasheh 	unsigned int insert_range, rec_range, do_leftright = 0;
4636328d5752SMark Fasheh 	struct ocfs2_extent_rec tmprec;
4637328d5752SMark Fasheh 	struct ocfs2_extent_list *rightmost_el;
4638328d5752SMark Fasheh 	struct ocfs2_extent_rec rec;
4639328d5752SMark Fasheh 	struct ocfs2_extent_rec split_rec = *orig_split_rec;
4640328d5752SMark Fasheh 	struct ocfs2_insert_type insert;
4641328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
4642328d5752SMark Fasheh 
4643328d5752SMark Fasheh leftright:
4644328d5752SMark Fasheh 	/*
4645328d5752SMark Fasheh 	 * Store a copy of the record on the stack - it might move
4646328d5752SMark Fasheh 	 * around as the tree is manipulated below.
4647328d5752SMark Fasheh 	 */
4648328d5752SMark Fasheh 	rec = path_leaf_el(path)->l_recs[split_index];
4649328d5752SMark Fasheh 
4650ce1d9ea6SJoel Becker 	rightmost_el = et->et_root_el;
4651328d5752SMark Fasheh 
4652328d5752SMark Fasheh 	depth = le16_to_cpu(rightmost_el->l_tree_depth);
4653328d5752SMark Fasheh 	if (depth) {
4654328d5752SMark Fasheh 		BUG_ON(!(*last_eb_bh));
4655328d5752SMark Fasheh 		eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
4656328d5752SMark Fasheh 		rightmost_el = &eb->h_list;
4657328d5752SMark Fasheh 	}
4658328d5752SMark Fasheh 
4659328d5752SMark Fasheh 	if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
4660328d5752SMark Fasheh 	    le16_to_cpu(rightmost_el->l_count)) {
4661e7d4cb6bSTao Ma 		ret = ocfs2_grow_tree(inode, handle, et,
4662e7d4cb6bSTao Ma 				      &depth, last_eb_bh, meta_ac);
4663328d5752SMark Fasheh 		if (ret) {
4664328d5752SMark Fasheh 			mlog_errno(ret);
4665328d5752SMark Fasheh 			goto out;
4666328d5752SMark Fasheh 		}
4667328d5752SMark Fasheh 	}
4668328d5752SMark Fasheh 
4669328d5752SMark Fasheh 	memset(&insert, 0, sizeof(struct ocfs2_insert_type));
4670328d5752SMark Fasheh 	insert.ins_appending = APPEND_NONE;
4671328d5752SMark Fasheh 	insert.ins_contig = CONTIG_NONE;
4672328d5752SMark Fasheh 	insert.ins_tree_depth = depth;
4673328d5752SMark Fasheh 
4674328d5752SMark Fasheh 	insert_range = le32_to_cpu(split_rec.e_cpos) +
4675328d5752SMark Fasheh 		le16_to_cpu(split_rec.e_leaf_clusters);
4676328d5752SMark Fasheh 	rec_range = le32_to_cpu(rec.e_cpos) +
4677328d5752SMark Fasheh 		le16_to_cpu(rec.e_leaf_clusters);
4678328d5752SMark Fasheh 
4679328d5752SMark Fasheh 	if (split_rec.e_cpos == rec.e_cpos) {
4680328d5752SMark Fasheh 		insert.ins_split = SPLIT_LEFT;
4681328d5752SMark Fasheh 	} else if (insert_range == rec_range) {
4682328d5752SMark Fasheh 		insert.ins_split = SPLIT_RIGHT;
4683328d5752SMark Fasheh 	} else {
4684328d5752SMark Fasheh 		/*
4685328d5752SMark Fasheh 		 * Left/right split. We fake this as a right split
4686328d5752SMark Fasheh 		 * first and then make a second pass as a left split.
4687328d5752SMark Fasheh 		 */
4688328d5752SMark Fasheh 		insert.ins_split = SPLIT_RIGHT;
4689328d5752SMark Fasheh 
4690328d5752SMark Fasheh 		ocfs2_make_right_split_rec(inode->i_sb, &tmprec, insert_range,
4691328d5752SMark Fasheh 					   &rec);
4692328d5752SMark Fasheh 
4693328d5752SMark Fasheh 		split_rec = tmprec;
4694328d5752SMark Fasheh 
4695328d5752SMark Fasheh 		BUG_ON(do_leftright);
4696328d5752SMark Fasheh 		do_leftright = 1;
4697328d5752SMark Fasheh 	}
4698328d5752SMark Fasheh 
4699e7d4cb6bSTao Ma 	ret = ocfs2_do_insert_extent(inode, handle, et, &split_rec, &insert);
4700328d5752SMark Fasheh 	if (ret) {
4701328d5752SMark Fasheh 		mlog_errno(ret);
4702328d5752SMark Fasheh 		goto out;
4703328d5752SMark Fasheh 	}
4704328d5752SMark Fasheh 
4705328d5752SMark Fasheh 	if (do_leftright == 1) {
4706328d5752SMark Fasheh 		u32 cpos;
4707328d5752SMark Fasheh 		struct ocfs2_extent_list *el;
4708328d5752SMark Fasheh 
4709328d5752SMark Fasheh 		do_leftright++;
4710328d5752SMark Fasheh 		split_rec = *orig_split_rec;
4711328d5752SMark Fasheh 
4712328d5752SMark Fasheh 		ocfs2_reinit_path(path, 1);
4713328d5752SMark Fasheh 
4714328d5752SMark Fasheh 		cpos = le32_to_cpu(split_rec.e_cpos);
4715328d5752SMark Fasheh 		ret = ocfs2_find_path(inode, path, cpos);
4716328d5752SMark Fasheh 		if (ret) {
4717328d5752SMark Fasheh 			mlog_errno(ret);
4718328d5752SMark Fasheh 			goto out;
4719328d5752SMark Fasheh 		}
4720328d5752SMark Fasheh 
4721328d5752SMark Fasheh 		el = path_leaf_el(path);
4722328d5752SMark Fasheh 		split_index = ocfs2_search_extent_list(el, cpos);
4723328d5752SMark Fasheh 		goto leftright;
4724328d5752SMark Fasheh 	}
4725328d5752SMark Fasheh out:
4726328d5752SMark Fasheh 
4727328d5752SMark Fasheh 	return ret;
4728328d5752SMark Fasheh }
4729328d5752SMark Fasheh 
4730328d5752SMark Fasheh /*
4731328d5752SMark Fasheh  * Mark part or all of the extent record at split_index in the leaf
4732328d5752SMark Fasheh  * pointed to by path as written. This removes the unwritten
4733328d5752SMark Fasheh  * extent flag.
4734328d5752SMark Fasheh  *
4735328d5752SMark Fasheh  * Care is taken to handle contiguousness so as to not grow the tree.
4736328d5752SMark Fasheh  *
4737328d5752SMark Fasheh  * meta_ac is not strictly necessary - we only truly need it if growth
4738328d5752SMark Fasheh  * of the tree is required. All other cases will degrade into a less
4739328d5752SMark Fasheh  * optimal tree layout.
4740328d5752SMark Fasheh  *
4741e7d4cb6bSTao Ma  * last_eb_bh should be the rightmost leaf block for any extent
4742e7d4cb6bSTao Ma  * btree. Since a split may grow the tree or a merge might shrink it,
4743e7d4cb6bSTao Ma  * the caller cannot trust the contents of that buffer after this call.
4744328d5752SMark Fasheh  *
4745328d5752SMark Fasheh  * This code is optimized for readability - several passes might be
4746328d5752SMark Fasheh  * made over certain portions of the tree. All of those blocks will
4747328d5752SMark Fasheh  * have been brought into cache (and pinned via the journal), so the
4748328d5752SMark Fasheh  * extra overhead is not expressed in terms of disk reads.
4749328d5752SMark Fasheh  */
4750328d5752SMark Fasheh static int __ocfs2_mark_extent_written(struct inode *inode,
4751e7d4cb6bSTao Ma 				       struct ocfs2_extent_tree *et,
4752328d5752SMark Fasheh 				       handle_t *handle,
4753328d5752SMark Fasheh 				       struct ocfs2_path *path,
4754328d5752SMark Fasheh 				       int split_index,
4755328d5752SMark Fasheh 				       struct ocfs2_extent_rec *split_rec,
4756328d5752SMark Fasheh 				       struct ocfs2_alloc_context *meta_ac,
4757328d5752SMark Fasheh 				       struct ocfs2_cached_dealloc_ctxt *dealloc)
4758328d5752SMark Fasheh {
4759328d5752SMark Fasheh 	int ret = 0;
4760328d5752SMark Fasheh 	struct ocfs2_extent_list *el = path_leaf_el(path);
4761e8aed345SMark Fasheh 	struct buffer_head *last_eb_bh = NULL;
4762328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
4763328d5752SMark Fasheh 	struct ocfs2_merge_ctxt ctxt;
4764328d5752SMark Fasheh 	struct ocfs2_extent_list *rightmost_el;
4765328d5752SMark Fasheh 
47663cf0c507SRoel Kluin 	if (!(rec->e_flags & OCFS2_EXT_UNWRITTEN)) {
4767328d5752SMark Fasheh 		ret = -EIO;
4768328d5752SMark Fasheh 		mlog_errno(ret);
4769328d5752SMark Fasheh 		goto out;
4770328d5752SMark Fasheh 	}
4771328d5752SMark Fasheh 
4772328d5752SMark Fasheh 	if (le32_to_cpu(rec->e_cpos) > le32_to_cpu(split_rec->e_cpos) ||
4773328d5752SMark Fasheh 	    ((le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)) <
4774328d5752SMark Fasheh 	     (le32_to_cpu(split_rec->e_cpos) + le16_to_cpu(split_rec->e_leaf_clusters)))) {
4775328d5752SMark Fasheh 		ret = -EIO;
4776328d5752SMark Fasheh 		mlog_errno(ret);
4777328d5752SMark Fasheh 		goto out;
4778328d5752SMark Fasheh 	}
4779328d5752SMark Fasheh 
4780ad5a4d70STao Ma 	ctxt.c_contig_type = ocfs2_figure_merge_contig_type(inode, path, el,
4781328d5752SMark Fasheh 							    split_index,
4782328d5752SMark Fasheh 							    split_rec);
4783328d5752SMark Fasheh 
4784328d5752SMark Fasheh 	/*
4785328d5752SMark Fasheh 	 * The core merge / split code wants to know how much room is
4786328d5752SMark Fasheh 	 * left in this inodes allocation tree, so we pass the
4787328d5752SMark Fasheh 	 * rightmost extent list.
4788328d5752SMark Fasheh 	 */
4789328d5752SMark Fasheh 	if (path->p_tree_depth) {
4790328d5752SMark Fasheh 		struct ocfs2_extent_block *eb;
4791328d5752SMark Fasheh 
4792328d5752SMark Fasheh 		ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
479335dc0aa3SJoel Becker 				       ocfs2_et_get_last_eb_blk(et),
4794328d5752SMark Fasheh 				       &last_eb_bh, OCFS2_BH_CACHED, inode);
4795328d5752SMark Fasheh 		if (ret) {
4796328d5752SMark Fasheh 			mlog_exit(ret);
4797328d5752SMark Fasheh 			goto out;
4798328d5752SMark Fasheh 		}
4799328d5752SMark Fasheh 
4800328d5752SMark Fasheh 		eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
4801328d5752SMark Fasheh 		if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
4802328d5752SMark Fasheh 			OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
4803328d5752SMark Fasheh 			ret = -EROFS;
4804328d5752SMark Fasheh 			goto out;
4805328d5752SMark Fasheh 		}
4806328d5752SMark Fasheh 
4807328d5752SMark Fasheh 		rightmost_el = &eb->h_list;
4808328d5752SMark Fasheh 	} else
4809328d5752SMark Fasheh 		rightmost_el = path_root_el(path);
4810328d5752SMark Fasheh 
4811328d5752SMark Fasheh 	if (rec->e_cpos == split_rec->e_cpos &&
4812328d5752SMark Fasheh 	    rec->e_leaf_clusters == split_rec->e_leaf_clusters)
4813328d5752SMark Fasheh 		ctxt.c_split_covers_rec = 1;
4814328d5752SMark Fasheh 	else
4815328d5752SMark Fasheh 		ctxt.c_split_covers_rec = 0;
4816328d5752SMark Fasheh 
4817328d5752SMark Fasheh 	ctxt.c_has_empty_extent = ocfs2_is_empty_extent(&el->l_recs[0]);
4818328d5752SMark Fasheh 
4819015452b1SMark Fasheh 	mlog(0, "index: %d, contig: %u, has_empty: %u, split_covers: %u\n",
4820015452b1SMark Fasheh 	     split_index, ctxt.c_contig_type, ctxt.c_has_empty_extent,
4821015452b1SMark Fasheh 	     ctxt.c_split_covers_rec);
4822328d5752SMark Fasheh 
4823328d5752SMark Fasheh 	if (ctxt.c_contig_type == CONTIG_NONE) {
4824328d5752SMark Fasheh 		if (ctxt.c_split_covers_rec)
4825328d5752SMark Fasheh 			el->l_recs[split_index] = *split_rec;
4826328d5752SMark Fasheh 		else
4827e7d4cb6bSTao Ma 			ret = ocfs2_split_and_insert(inode, handle, path, et,
4828328d5752SMark Fasheh 						     &last_eb_bh, split_index,
4829328d5752SMark Fasheh 						     split_rec, meta_ac);
4830328d5752SMark Fasheh 		if (ret)
4831328d5752SMark Fasheh 			mlog_errno(ret);
4832328d5752SMark Fasheh 	} else {
4833328d5752SMark Fasheh 		ret = ocfs2_try_to_merge_extent(inode, handle, path,
4834328d5752SMark Fasheh 						split_index, split_rec,
4835e7d4cb6bSTao Ma 						dealloc, &ctxt, et);
4836328d5752SMark Fasheh 		if (ret)
4837328d5752SMark Fasheh 			mlog_errno(ret);
4838328d5752SMark Fasheh 	}
4839328d5752SMark Fasheh 
4840328d5752SMark Fasheh out:
4841328d5752SMark Fasheh 	brelse(last_eb_bh);
4842328d5752SMark Fasheh 	return ret;
4843328d5752SMark Fasheh }
4844328d5752SMark Fasheh 
4845328d5752SMark Fasheh /*
4846328d5752SMark Fasheh  * Mark the already-existing extent at cpos as written for len clusters.
4847328d5752SMark Fasheh  *
4848328d5752SMark Fasheh  * If the existing extent is larger than the request, initiate a
4849328d5752SMark Fasheh  * split. An attempt will be made at merging with adjacent extents.
4850328d5752SMark Fasheh  *
4851328d5752SMark Fasheh  * The caller is responsible for passing down meta_ac if we'll need it.
4852328d5752SMark Fasheh  */
4853e7d4cb6bSTao Ma int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *root_bh,
4854328d5752SMark Fasheh 			      handle_t *handle, u32 cpos, u32 len, u32 phys,
4855328d5752SMark Fasheh 			      struct ocfs2_alloc_context *meta_ac,
4856e7d4cb6bSTao Ma 			      struct ocfs2_cached_dealloc_ctxt *dealloc,
4857f56654c4STao Ma 			      enum ocfs2_extent_tree_type et_type,
4858ea5efa15SJoel Becker 			      void *obj)
4859328d5752SMark Fasheh {
4860328d5752SMark Fasheh 	int ret, index;
4861328d5752SMark Fasheh 	u64 start_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys);
4862328d5752SMark Fasheh 	struct ocfs2_extent_rec split_rec;
4863328d5752SMark Fasheh 	struct ocfs2_path *left_path = NULL;
4864328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
4865dc0ce61aSJoel Becker 	struct ocfs2_extent_tree et;
4866328d5752SMark Fasheh 
4867328d5752SMark Fasheh 	mlog(0, "Inode %lu cpos %u, len %u, phys %u (%llu)\n",
4868328d5752SMark Fasheh 	     inode->i_ino, cpos, len, phys, (unsigned long long)start_blkno);
4869328d5752SMark Fasheh 
4870ea5efa15SJoel Becker 	ocfs2_get_extent_tree(&et, inode, root_bh, et_type, obj);
4871dc0ce61aSJoel Becker 
4872328d5752SMark Fasheh 	if (!ocfs2_writes_unwritten_extents(OCFS2_SB(inode->i_sb))) {
4873328d5752SMark Fasheh 		ocfs2_error(inode->i_sb, "Inode %llu has unwritten extents "
4874328d5752SMark Fasheh 			    "that are being written to, but the feature bit "
4875328d5752SMark Fasheh 			    "is not set in the super block.",
4876328d5752SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno);
4877328d5752SMark Fasheh 		ret = -EROFS;
4878328d5752SMark Fasheh 		goto out;
4879328d5752SMark Fasheh 	}
4880328d5752SMark Fasheh 
4881328d5752SMark Fasheh 	/*
4882328d5752SMark Fasheh 	 * XXX: This should be fixed up so that we just re-insert the
4883328d5752SMark Fasheh 	 * next extent records.
4884328d5752SMark Fasheh 	 */
4885e7d4cb6bSTao Ma 	if (et_type == OCFS2_DINODE_EXTENT)
4886328d5752SMark Fasheh 		ocfs2_extent_map_trunc(inode, 0);
4887328d5752SMark Fasheh 
4888dc0ce61aSJoel Becker 	left_path = ocfs2_new_path(et.et_root_bh, et.et_root_el);
4889328d5752SMark Fasheh 	if (!left_path) {
4890328d5752SMark Fasheh 		ret = -ENOMEM;
4891328d5752SMark Fasheh 		mlog_errno(ret);
4892328d5752SMark Fasheh 		goto out;
4893328d5752SMark Fasheh 	}
4894328d5752SMark Fasheh 
4895328d5752SMark Fasheh 	ret = ocfs2_find_path(inode, left_path, cpos);
4896328d5752SMark Fasheh 	if (ret) {
4897328d5752SMark Fasheh 		mlog_errno(ret);
4898328d5752SMark Fasheh 		goto out;
4899328d5752SMark Fasheh 	}
4900328d5752SMark Fasheh 	el = path_leaf_el(left_path);
4901328d5752SMark Fasheh 
4902328d5752SMark Fasheh 	index = ocfs2_search_extent_list(el, cpos);
4903328d5752SMark Fasheh 	if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
4904328d5752SMark Fasheh 		ocfs2_error(inode->i_sb,
4905328d5752SMark Fasheh 			    "Inode %llu has an extent at cpos %u which can no "
4906328d5752SMark Fasheh 			    "longer be found.\n",
4907328d5752SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos);
4908328d5752SMark Fasheh 		ret = -EROFS;
4909328d5752SMark Fasheh 		goto out;
4910328d5752SMark Fasheh 	}
4911328d5752SMark Fasheh 
4912328d5752SMark Fasheh 	memset(&split_rec, 0, sizeof(struct ocfs2_extent_rec));
4913328d5752SMark Fasheh 	split_rec.e_cpos = cpu_to_le32(cpos);
4914328d5752SMark Fasheh 	split_rec.e_leaf_clusters = cpu_to_le16(len);
4915328d5752SMark Fasheh 	split_rec.e_blkno = cpu_to_le64(start_blkno);
4916328d5752SMark Fasheh 	split_rec.e_flags = path_leaf_el(left_path)->l_recs[index].e_flags;
4917328d5752SMark Fasheh 	split_rec.e_flags &= ~OCFS2_EXT_UNWRITTEN;
4918328d5752SMark Fasheh 
4919dc0ce61aSJoel Becker 	ret = __ocfs2_mark_extent_written(inode, &et, handle, left_path,
4920e7d4cb6bSTao Ma 					  index, &split_rec, meta_ac,
4921e7d4cb6bSTao Ma 					  dealloc);
4922328d5752SMark Fasheh 	if (ret)
4923328d5752SMark Fasheh 		mlog_errno(ret);
4924328d5752SMark Fasheh 
4925328d5752SMark Fasheh out:
4926328d5752SMark Fasheh 	ocfs2_free_path(left_path);
4927dc0ce61aSJoel Becker 	ocfs2_put_extent_tree(&et);
4928328d5752SMark Fasheh 	return ret;
4929328d5752SMark Fasheh }
4930328d5752SMark Fasheh 
4931e7d4cb6bSTao Ma static int ocfs2_split_tree(struct inode *inode, struct ocfs2_extent_tree *et,
4932d0c7d708SMark Fasheh 			    handle_t *handle, struct ocfs2_path *path,
4933d0c7d708SMark Fasheh 			    int index, u32 new_range,
4934d0c7d708SMark Fasheh 			    struct ocfs2_alloc_context *meta_ac)
4935d0c7d708SMark Fasheh {
4936d0c7d708SMark Fasheh 	int ret, depth, credits = handle->h_buffer_credits;
4937d0c7d708SMark Fasheh 	struct buffer_head *last_eb_bh = NULL;
4938d0c7d708SMark Fasheh 	struct ocfs2_extent_block *eb;
4939d0c7d708SMark Fasheh 	struct ocfs2_extent_list *rightmost_el, *el;
4940d0c7d708SMark Fasheh 	struct ocfs2_extent_rec split_rec;
4941d0c7d708SMark Fasheh 	struct ocfs2_extent_rec *rec;
4942d0c7d708SMark Fasheh 	struct ocfs2_insert_type insert;
4943d0c7d708SMark Fasheh 
4944d0c7d708SMark Fasheh 	/*
4945d0c7d708SMark Fasheh 	 * Setup the record to split before we grow the tree.
4946d0c7d708SMark Fasheh 	 */
4947d0c7d708SMark Fasheh 	el = path_leaf_el(path);
4948d0c7d708SMark Fasheh 	rec = &el->l_recs[index];
4949d0c7d708SMark Fasheh 	ocfs2_make_right_split_rec(inode->i_sb, &split_rec, new_range, rec);
4950d0c7d708SMark Fasheh 
4951d0c7d708SMark Fasheh 	depth = path->p_tree_depth;
4952d0c7d708SMark Fasheh 	if (depth > 0) {
4953d0c7d708SMark Fasheh 		ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
495435dc0aa3SJoel Becker 				       ocfs2_et_get_last_eb_blk(et),
4955d0c7d708SMark Fasheh 				       &last_eb_bh, OCFS2_BH_CACHED, inode);
4956d0c7d708SMark Fasheh 		if (ret < 0) {
4957d0c7d708SMark Fasheh 			mlog_errno(ret);
4958d0c7d708SMark Fasheh 			goto out;
4959d0c7d708SMark Fasheh 		}
4960d0c7d708SMark Fasheh 
4961d0c7d708SMark Fasheh 		eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
4962d0c7d708SMark Fasheh 		rightmost_el = &eb->h_list;
4963d0c7d708SMark Fasheh 	} else
4964d0c7d708SMark Fasheh 		rightmost_el = path_leaf_el(path);
4965d0c7d708SMark Fasheh 
4966811f933dSTao Ma 	credits += path->p_tree_depth +
4967ce1d9ea6SJoel Becker 		   ocfs2_extend_meta_needed(et->et_root_el);
4968d0c7d708SMark Fasheh 	ret = ocfs2_extend_trans(handle, credits);
4969d0c7d708SMark Fasheh 	if (ret) {
4970d0c7d708SMark Fasheh 		mlog_errno(ret);
4971d0c7d708SMark Fasheh 		goto out;
4972d0c7d708SMark Fasheh 	}
4973d0c7d708SMark Fasheh 
4974d0c7d708SMark Fasheh 	if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
4975d0c7d708SMark Fasheh 	    le16_to_cpu(rightmost_el->l_count)) {
4976e7d4cb6bSTao Ma 		ret = ocfs2_grow_tree(inode, handle, et, &depth, &last_eb_bh,
4977d0c7d708SMark Fasheh 				      meta_ac);
4978d0c7d708SMark Fasheh 		if (ret) {
4979d0c7d708SMark Fasheh 			mlog_errno(ret);
4980d0c7d708SMark Fasheh 			goto out;
4981d0c7d708SMark Fasheh 		}
4982d0c7d708SMark Fasheh 	}
4983d0c7d708SMark Fasheh 
4984d0c7d708SMark Fasheh 	memset(&insert, 0, sizeof(struct ocfs2_insert_type));
4985d0c7d708SMark Fasheh 	insert.ins_appending = APPEND_NONE;
4986d0c7d708SMark Fasheh 	insert.ins_contig = CONTIG_NONE;
4987d0c7d708SMark Fasheh 	insert.ins_split = SPLIT_RIGHT;
4988d0c7d708SMark Fasheh 	insert.ins_tree_depth = depth;
4989d0c7d708SMark Fasheh 
4990e7d4cb6bSTao Ma 	ret = ocfs2_do_insert_extent(inode, handle, et, &split_rec, &insert);
4991d0c7d708SMark Fasheh 	if (ret)
4992d0c7d708SMark Fasheh 		mlog_errno(ret);
4993d0c7d708SMark Fasheh 
4994d0c7d708SMark Fasheh out:
4995d0c7d708SMark Fasheh 	brelse(last_eb_bh);
4996d0c7d708SMark Fasheh 	return ret;
4997d0c7d708SMark Fasheh }
4998d0c7d708SMark Fasheh 
4999d0c7d708SMark Fasheh static int ocfs2_truncate_rec(struct inode *inode, handle_t *handle,
5000d0c7d708SMark Fasheh 			      struct ocfs2_path *path, int index,
5001d0c7d708SMark Fasheh 			      struct ocfs2_cached_dealloc_ctxt *dealloc,
5002e7d4cb6bSTao Ma 			      u32 cpos, u32 len,
5003e7d4cb6bSTao Ma 			      struct ocfs2_extent_tree *et)
5004d0c7d708SMark Fasheh {
5005d0c7d708SMark Fasheh 	int ret;
5006d0c7d708SMark Fasheh 	u32 left_cpos, rec_range, trunc_range;
5007d0c7d708SMark Fasheh 	int wants_rotate = 0, is_rightmost_tree_rec = 0;
5008d0c7d708SMark Fasheh 	struct super_block *sb = inode->i_sb;
5009d0c7d708SMark Fasheh 	struct ocfs2_path *left_path = NULL;
5010d0c7d708SMark Fasheh 	struct ocfs2_extent_list *el = path_leaf_el(path);
5011d0c7d708SMark Fasheh 	struct ocfs2_extent_rec *rec;
5012d0c7d708SMark Fasheh 	struct ocfs2_extent_block *eb;
5013d0c7d708SMark Fasheh 
5014d0c7d708SMark Fasheh 	if (ocfs2_is_empty_extent(&el->l_recs[0]) && index > 0) {
5015e7d4cb6bSTao Ma 		ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc, et);
5016d0c7d708SMark Fasheh 		if (ret) {
5017d0c7d708SMark Fasheh 			mlog_errno(ret);
5018d0c7d708SMark Fasheh 			goto out;
5019d0c7d708SMark Fasheh 		}
5020d0c7d708SMark Fasheh 
5021d0c7d708SMark Fasheh 		index--;
5022d0c7d708SMark Fasheh 	}
5023d0c7d708SMark Fasheh 
5024d0c7d708SMark Fasheh 	if (index == (le16_to_cpu(el->l_next_free_rec) - 1) &&
5025d0c7d708SMark Fasheh 	    path->p_tree_depth) {
5026d0c7d708SMark Fasheh 		/*
5027d0c7d708SMark Fasheh 		 * Check whether this is the rightmost tree record. If
5028d0c7d708SMark Fasheh 		 * we remove all of this record or part of its right
5029d0c7d708SMark Fasheh 		 * edge then an update of the record lengths above it
5030d0c7d708SMark Fasheh 		 * will be required.
5031d0c7d708SMark Fasheh 		 */
5032d0c7d708SMark Fasheh 		eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
5033d0c7d708SMark Fasheh 		if (eb->h_next_leaf_blk == 0)
5034d0c7d708SMark Fasheh 			is_rightmost_tree_rec = 1;
5035d0c7d708SMark Fasheh 	}
5036d0c7d708SMark Fasheh 
5037d0c7d708SMark Fasheh 	rec = &el->l_recs[index];
5038d0c7d708SMark Fasheh 	if (index == 0 && path->p_tree_depth &&
5039d0c7d708SMark Fasheh 	    le32_to_cpu(rec->e_cpos) == cpos) {
5040d0c7d708SMark Fasheh 		/*
5041d0c7d708SMark Fasheh 		 * Changing the leftmost offset (via partial or whole
5042d0c7d708SMark Fasheh 		 * record truncate) of an interior (or rightmost) path
5043d0c7d708SMark Fasheh 		 * means we have to update the subtree that is formed
5044d0c7d708SMark Fasheh 		 * by this leaf and the one to it's left.
5045d0c7d708SMark Fasheh 		 *
5046d0c7d708SMark Fasheh 		 * There are two cases we can skip:
5047d0c7d708SMark Fasheh 		 *   1) Path is the leftmost one in our inode tree.
5048d0c7d708SMark Fasheh 		 *   2) The leaf is rightmost and will be empty after
5049d0c7d708SMark Fasheh 		 *      we remove the extent record - the rotate code
5050d0c7d708SMark Fasheh 		 *      knows how to update the newly formed edge.
5051d0c7d708SMark Fasheh 		 */
5052d0c7d708SMark Fasheh 
5053d0c7d708SMark Fasheh 		ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path,
5054d0c7d708SMark Fasheh 						    &left_cpos);
5055d0c7d708SMark Fasheh 		if (ret) {
5056d0c7d708SMark Fasheh 			mlog_errno(ret);
5057d0c7d708SMark Fasheh 			goto out;
5058d0c7d708SMark Fasheh 		}
5059d0c7d708SMark Fasheh 
5060d0c7d708SMark Fasheh 		if (left_cpos && le16_to_cpu(el->l_next_free_rec) > 1) {
5061d0c7d708SMark Fasheh 			left_path = ocfs2_new_path(path_root_bh(path),
5062d0c7d708SMark Fasheh 						   path_root_el(path));
5063d0c7d708SMark Fasheh 			if (!left_path) {
5064d0c7d708SMark Fasheh 				ret = -ENOMEM;
5065d0c7d708SMark Fasheh 				mlog_errno(ret);
5066d0c7d708SMark Fasheh 				goto out;
5067d0c7d708SMark Fasheh 			}
5068d0c7d708SMark Fasheh 
5069d0c7d708SMark Fasheh 			ret = ocfs2_find_path(inode, left_path, left_cpos);
5070d0c7d708SMark Fasheh 			if (ret) {
5071d0c7d708SMark Fasheh 				mlog_errno(ret);
5072d0c7d708SMark Fasheh 				goto out;
5073d0c7d708SMark Fasheh 			}
5074d0c7d708SMark Fasheh 		}
5075d0c7d708SMark Fasheh 	}
5076d0c7d708SMark Fasheh 
5077d0c7d708SMark Fasheh 	ret = ocfs2_extend_rotate_transaction(handle, 0,
5078d0c7d708SMark Fasheh 					      handle->h_buffer_credits,
5079d0c7d708SMark Fasheh 					      path);
5080d0c7d708SMark Fasheh 	if (ret) {
5081d0c7d708SMark Fasheh 		mlog_errno(ret);
5082d0c7d708SMark Fasheh 		goto out;
5083d0c7d708SMark Fasheh 	}
5084d0c7d708SMark Fasheh 
5085d0c7d708SMark Fasheh 	ret = ocfs2_journal_access_path(inode, handle, path);
5086d0c7d708SMark Fasheh 	if (ret) {
5087d0c7d708SMark Fasheh 		mlog_errno(ret);
5088d0c7d708SMark Fasheh 		goto out;
5089d0c7d708SMark Fasheh 	}
5090d0c7d708SMark Fasheh 
5091d0c7d708SMark Fasheh 	ret = ocfs2_journal_access_path(inode, handle, left_path);
5092d0c7d708SMark Fasheh 	if (ret) {
5093d0c7d708SMark Fasheh 		mlog_errno(ret);
5094d0c7d708SMark Fasheh 		goto out;
5095d0c7d708SMark Fasheh 	}
5096d0c7d708SMark Fasheh 
5097d0c7d708SMark Fasheh 	rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5098d0c7d708SMark Fasheh 	trunc_range = cpos + len;
5099d0c7d708SMark Fasheh 
5100d0c7d708SMark Fasheh 	if (le32_to_cpu(rec->e_cpos) == cpos && rec_range == trunc_range) {
5101d0c7d708SMark Fasheh 		int next_free;
5102d0c7d708SMark Fasheh 
5103d0c7d708SMark Fasheh 		memset(rec, 0, sizeof(*rec));
5104d0c7d708SMark Fasheh 		ocfs2_cleanup_merge(el, index);
5105d0c7d708SMark Fasheh 		wants_rotate = 1;
5106d0c7d708SMark Fasheh 
5107d0c7d708SMark Fasheh 		next_free = le16_to_cpu(el->l_next_free_rec);
5108d0c7d708SMark Fasheh 		if (is_rightmost_tree_rec && next_free > 1) {
5109d0c7d708SMark Fasheh 			/*
5110d0c7d708SMark Fasheh 			 * We skip the edge update if this path will
5111d0c7d708SMark Fasheh 			 * be deleted by the rotate code.
5112d0c7d708SMark Fasheh 			 */
5113d0c7d708SMark Fasheh 			rec = &el->l_recs[next_free - 1];
5114d0c7d708SMark Fasheh 			ocfs2_adjust_rightmost_records(inode, handle, path,
5115d0c7d708SMark Fasheh 						       rec);
5116d0c7d708SMark Fasheh 		}
5117d0c7d708SMark Fasheh 	} else if (le32_to_cpu(rec->e_cpos) == cpos) {
5118d0c7d708SMark Fasheh 		/* Remove leftmost portion of the record. */
5119d0c7d708SMark Fasheh 		le32_add_cpu(&rec->e_cpos, len);
5120d0c7d708SMark Fasheh 		le64_add_cpu(&rec->e_blkno, ocfs2_clusters_to_blocks(sb, len));
5121d0c7d708SMark Fasheh 		le16_add_cpu(&rec->e_leaf_clusters, -len);
5122d0c7d708SMark Fasheh 	} else if (rec_range == trunc_range) {
5123d0c7d708SMark Fasheh 		/* Remove rightmost portion of the record */
5124d0c7d708SMark Fasheh 		le16_add_cpu(&rec->e_leaf_clusters, -len);
5125d0c7d708SMark Fasheh 		if (is_rightmost_tree_rec)
5126d0c7d708SMark Fasheh 			ocfs2_adjust_rightmost_records(inode, handle, path, rec);
5127d0c7d708SMark Fasheh 	} else {
5128d0c7d708SMark Fasheh 		/* Caller should have trapped this. */
5129d0c7d708SMark Fasheh 		mlog(ML_ERROR, "Inode %llu: Invalid record truncate: (%u, %u) "
5130d0c7d708SMark Fasheh 		     "(%u, %u)\n", (unsigned long long)OCFS2_I(inode)->ip_blkno,
5131d0c7d708SMark Fasheh 		     le32_to_cpu(rec->e_cpos),
5132d0c7d708SMark Fasheh 		     le16_to_cpu(rec->e_leaf_clusters), cpos, len);
5133d0c7d708SMark Fasheh 		BUG();
5134d0c7d708SMark Fasheh 	}
5135d0c7d708SMark Fasheh 
5136d0c7d708SMark Fasheh 	if (left_path) {
5137d0c7d708SMark Fasheh 		int subtree_index;
5138d0c7d708SMark Fasheh 
5139d0c7d708SMark Fasheh 		subtree_index = ocfs2_find_subtree_root(inode, left_path, path);
5140d0c7d708SMark Fasheh 		ocfs2_complete_edge_insert(inode, handle, left_path, path,
5141d0c7d708SMark Fasheh 					   subtree_index);
5142d0c7d708SMark Fasheh 	}
5143d0c7d708SMark Fasheh 
5144d0c7d708SMark Fasheh 	ocfs2_journal_dirty(handle, path_leaf_bh(path));
5145d0c7d708SMark Fasheh 
5146e7d4cb6bSTao Ma 	ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc, et);
5147d0c7d708SMark Fasheh 	if (ret) {
5148d0c7d708SMark Fasheh 		mlog_errno(ret);
5149d0c7d708SMark Fasheh 		goto out;
5150d0c7d708SMark Fasheh 	}
5151d0c7d708SMark Fasheh 
5152d0c7d708SMark Fasheh out:
5153d0c7d708SMark Fasheh 	ocfs2_free_path(left_path);
5154d0c7d708SMark Fasheh 	return ret;
5155d0c7d708SMark Fasheh }
5156d0c7d708SMark Fasheh 
5157e7d4cb6bSTao Ma int ocfs2_remove_extent(struct inode *inode, struct buffer_head *root_bh,
5158d0c7d708SMark Fasheh 			u32 cpos, u32 len, handle_t *handle,
5159d0c7d708SMark Fasheh 			struct ocfs2_alloc_context *meta_ac,
5160e7d4cb6bSTao Ma 			struct ocfs2_cached_dealloc_ctxt *dealloc,
5161f56654c4STao Ma 			enum ocfs2_extent_tree_type et_type,
5162ea5efa15SJoel Becker 			void *obj)
5163d0c7d708SMark Fasheh {
5164d0c7d708SMark Fasheh 	int ret, index;
5165d0c7d708SMark Fasheh 	u32 rec_range, trunc_range;
5166d0c7d708SMark Fasheh 	struct ocfs2_extent_rec *rec;
5167d0c7d708SMark Fasheh 	struct ocfs2_extent_list *el;
5168e7d4cb6bSTao Ma 	struct ocfs2_path *path = NULL;
5169dc0ce61aSJoel Becker 	struct ocfs2_extent_tree et;
5170e7d4cb6bSTao Ma 
5171ea5efa15SJoel Becker 	ocfs2_get_extent_tree(&et, inode, root_bh, et_type, obj);
5172d0c7d708SMark Fasheh 
5173d0c7d708SMark Fasheh 	ocfs2_extent_map_trunc(inode, 0);
5174d0c7d708SMark Fasheh 
5175dc0ce61aSJoel Becker 	path = ocfs2_new_path(et.et_root_bh, et.et_root_el);
5176d0c7d708SMark Fasheh 	if (!path) {
5177d0c7d708SMark Fasheh 		ret = -ENOMEM;
5178d0c7d708SMark Fasheh 		mlog_errno(ret);
5179d0c7d708SMark Fasheh 		goto out;
5180d0c7d708SMark Fasheh 	}
5181d0c7d708SMark Fasheh 
5182d0c7d708SMark Fasheh 	ret = ocfs2_find_path(inode, path, cpos);
5183d0c7d708SMark Fasheh 	if (ret) {
5184d0c7d708SMark Fasheh 		mlog_errno(ret);
5185d0c7d708SMark Fasheh 		goto out;
5186d0c7d708SMark Fasheh 	}
5187d0c7d708SMark Fasheh 
5188d0c7d708SMark Fasheh 	el = path_leaf_el(path);
5189d0c7d708SMark Fasheh 	index = ocfs2_search_extent_list(el, cpos);
5190d0c7d708SMark Fasheh 	if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
5191d0c7d708SMark Fasheh 		ocfs2_error(inode->i_sb,
5192d0c7d708SMark Fasheh 			    "Inode %llu has an extent at cpos %u which can no "
5193d0c7d708SMark Fasheh 			    "longer be found.\n",
5194d0c7d708SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos);
5195d0c7d708SMark Fasheh 		ret = -EROFS;
5196d0c7d708SMark Fasheh 		goto out;
5197d0c7d708SMark Fasheh 	}
5198d0c7d708SMark Fasheh 
5199d0c7d708SMark Fasheh 	/*
5200d0c7d708SMark Fasheh 	 * We have 3 cases of extent removal:
5201d0c7d708SMark Fasheh 	 *   1) Range covers the entire extent rec
5202d0c7d708SMark Fasheh 	 *   2) Range begins or ends on one edge of the extent rec
5203d0c7d708SMark Fasheh 	 *   3) Range is in the middle of the extent rec (no shared edges)
5204d0c7d708SMark Fasheh 	 *
5205d0c7d708SMark Fasheh 	 * For case 1 we remove the extent rec and left rotate to
5206d0c7d708SMark Fasheh 	 * fill the hole.
5207d0c7d708SMark Fasheh 	 *
5208d0c7d708SMark Fasheh 	 * For case 2 we just shrink the existing extent rec, with a
5209d0c7d708SMark Fasheh 	 * tree update if the shrinking edge is also the edge of an
5210d0c7d708SMark Fasheh 	 * extent block.
5211d0c7d708SMark Fasheh 	 *
5212d0c7d708SMark Fasheh 	 * For case 3 we do a right split to turn the extent rec into
5213d0c7d708SMark Fasheh 	 * something case 2 can handle.
5214d0c7d708SMark Fasheh 	 */
5215d0c7d708SMark Fasheh 	rec = &el->l_recs[index];
5216d0c7d708SMark Fasheh 	rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5217d0c7d708SMark Fasheh 	trunc_range = cpos + len;
5218d0c7d708SMark Fasheh 
5219d0c7d708SMark Fasheh 	BUG_ON(cpos < le32_to_cpu(rec->e_cpos) || trunc_range > rec_range);
5220d0c7d708SMark Fasheh 
5221d0c7d708SMark Fasheh 	mlog(0, "Inode %llu, remove (cpos %u, len %u). Existing index %d "
5222d0c7d708SMark Fasheh 	     "(cpos %u, len %u)\n",
5223d0c7d708SMark Fasheh 	     (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos, len, index,
5224d0c7d708SMark Fasheh 	     le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec));
5225d0c7d708SMark Fasheh 
5226d0c7d708SMark Fasheh 	if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) {
5227d0c7d708SMark Fasheh 		ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc,
5228dc0ce61aSJoel Becker 					 cpos, len, &et);
5229d0c7d708SMark Fasheh 		if (ret) {
5230d0c7d708SMark Fasheh 			mlog_errno(ret);
5231d0c7d708SMark Fasheh 			goto out;
5232d0c7d708SMark Fasheh 		}
5233d0c7d708SMark Fasheh 	} else {
5234dc0ce61aSJoel Becker 		ret = ocfs2_split_tree(inode, &et, handle, path, index,
5235d0c7d708SMark Fasheh 				       trunc_range, meta_ac);
5236d0c7d708SMark Fasheh 		if (ret) {
5237d0c7d708SMark Fasheh 			mlog_errno(ret);
5238d0c7d708SMark Fasheh 			goto out;
5239d0c7d708SMark Fasheh 		}
5240d0c7d708SMark Fasheh 
5241d0c7d708SMark Fasheh 		/*
5242d0c7d708SMark Fasheh 		 * The split could have manipulated the tree enough to
5243d0c7d708SMark Fasheh 		 * move the record location, so we have to look for it again.
5244d0c7d708SMark Fasheh 		 */
5245d0c7d708SMark Fasheh 		ocfs2_reinit_path(path, 1);
5246d0c7d708SMark Fasheh 
5247d0c7d708SMark Fasheh 		ret = ocfs2_find_path(inode, path, cpos);
5248d0c7d708SMark Fasheh 		if (ret) {
5249d0c7d708SMark Fasheh 			mlog_errno(ret);
5250d0c7d708SMark Fasheh 			goto out;
5251d0c7d708SMark Fasheh 		}
5252d0c7d708SMark Fasheh 
5253d0c7d708SMark Fasheh 		el = path_leaf_el(path);
5254d0c7d708SMark Fasheh 		index = ocfs2_search_extent_list(el, cpos);
5255d0c7d708SMark Fasheh 		if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
5256d0c7d708SMark Fasheh 			ocfs2_error(inode->i_sb,
5257d0c7d708SMark Fasheh 				    "Inode %llu: split at cpos %u lost record.",
5258d0c7d708SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno,
5259d0c7d708SMark Fasheh 				    cpos);
5260d0c7d708SMark Fasheh 			ret = -EROFS;
5261d0c7d708SMark Fasheh 			goto out;
5262d0c7d708SMark Fasheh 		}
5263d0c7d708SMark Fasheh 
5264d0c7d708SMark Fasheh 		/*
5265d0c7d708SMark Fasheh 		 * Double check our values here. If anything is fishy,
5266d0c7d708SMark Fasheh 		 * it's easier to catch it at the top level.
5267d0c7d708SMark Fasheh 		 */
5268d0c7d708SMark Fasheh 		rec = &el->l_recs[index];
5269d0c7d708SMark Fasheh 		rec_range = le32_to_cpu(rec->e_cpos) +
5270d0c7d708SMark Fasheh 			ocfs2_rec_clusters(el, rec);
5271d0c7d708SMark Fasheh 		if (rec_range != trunc_range) {
5272d0c7d708SMark Fasheh 			ocfs2_error(inode->i_sb,
5273d0c7d708SMark Fasheh 				    "Inode %llu: error after split at cpos %u"
5274d0c7d708SMark Fasheh 				    "trunc len %u, existing record is (%u,%u)",
5275d0c7d708SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno,
5276d0c7d708SMark Fasheh 				    cpos, len, le32_to_cpu(rec->e_cpos),
5277d0c7d708SMark Fasheh 				    ocfs2_rec_clusters(el, rec));
5278d0c7d708SMark Fasheh 			ret = -EROFS;
5279d0c7d708SMark Fasheh 			goto out;
5280d0c7d708SMark Fasheh 		}
5281d0c7d708SMark Fasheh 
5282d0c7d708SMark Fasheh 		ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc,
5283dc0ce61aSJoel Becker 					 cpos, len, &et);
5284d0c7d708SMark Fasheh 		if (ret) {
5285d0c7d708SMark Fasheh 			mlog_errno(ret);
5286d0c7d708SMark Fasheh 			goto out;
5287d0c7d708SMark Fasheh 		}
5288d0c7d708SMark Fasheh 	}
5289d0c7d708SMark Fasheh 
5290d0c7d708SMark Fasheh out:
5291d0c7d708SMark Fasheh 	ocfs2_free_path(path);
5292dc0ce61aSJoel Becker 	ocfs2_put_extent_tree(&et);
5293d0c7d708SMark Fasheh 	return ret;
5294d0c7d708SMark Fasheh }
5295d0c7d708SMark Fasheh 
5296063c4561SMark Fasheh int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb)
5297ccd979bdSMark Fasheh {
5298ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = osb->osb_tl_bh;
5299ccd979bdSMark Fasheh 	struct ocfs2_dinode *di;
5300ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
5301ccd979bdSMark Fasheh 
5302ccd979bdSMark Fasheh 	di = (struct ocfs2_dinode *) tl_bh->b_data;
5303ccd979bdSMark Fasheh 	tl = &di->id2.i_dealloc;
5304ccd979bdSMark Fasheh 
5305ccd979bdSMark Fasheh 	mlog_bug_on_msg(le16_to_cpu(tl->tl_used) > le16_to_cpu(tl->tl_count),
5306ccd979bdSMark Fasheh 			"slot %d, invalid truncate log parameters: used = "
5307ccd979bdSMark Fasheh 			"%u, count = %u\n", osb->slot_num,
5308ccd979bdSMark Fasheh 			le16_to_cpu(tl->tl_used), le16_to_cpu(tl->tl_count));
5309ccd979bdSMark Fasheh 	return le16_to_cpu(tl->tl_used) == le16_to_cpu(tl->tl_count);
5310ccd979bdSMark Fasheh }
5311ccd979bdSMark Fasheh 
5312ccd979bdSMark Fasheh static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl,
5313ccd979bdSMark Fasheh 					   unsigned int new_start)
5314ccd979bdSMark Fasheh {
5315ccd979bdSMark Fasheh 	unsigned int tail_index;
5316ccd979bdSMark Fasheh 	unsigned int current_tail;
5317ccd979bdSMark Fasheh 
5318ccd979bdSMark Fasheh 	/* No records, nothing to coalesce */
5319ccd979bdSMark Fasheh 	if (!le16_to_cpu(tl->tl_used))
5320ccd979bdSMark Fasheh 		return 0;
5321ccd979bdSMark Fasheh 
5322ccd979bdSMark Fasheh 	tail_index = le16_to_cpu(tl->tl_used) - 1;
5323ccd979bdSMark Fasheh 	current_tail = le32_to_cpu(tl->tl_recs[tail_index].t_start);
5324ccd979bdSMark Fasheh 	current_tail += le32_to_cpu(tl->tl_recs[tail_index].t_clusters);
5325ccd979bdSMark Fasheh 
5326ccd979bdSMark Fasheh 	return current_tail == new_start;
5327ccd979bdSMark Fasheh }
5328ccd979bdSMark Fasheh 
5329063c4561SMark Fasheh int ocfs2_truncate_log_append(struct ocfs2_super *osb,
53301fabe148SMark Fasheh 			      handle_t *handle,
5331ccd979bdSMark Fasheh 			      u64 start_blk,
5332ccd979bdSMark Fasheh 			      unsigned int num_clusters)
5333ccd979bdSMark Fasheh {
5334ccd979bdSMark Fasheh 	int status, index;
5335ccd979bdSMark Fasheh 	unsigned int start_cluster, tl_count;
5336ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
5337ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = osb->osb_tl_bh;
5338ccd979bdSMark Fasheh 	struct ocfs2_dinode *di;
5339ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
5340ccd979bdSMark Fasheh 
5341b0697053SMark Fasheh 	mlog_entry("start_blk = %llu, num_clusters = %u\n",
5342b0697053SMark Fasheh 		   (unsigned long long)start_blk, num_clusters);
5343ccd979bdSMark Fasheh 
53441b1dcc1bSJes Sorensen 	BUG_ON(mutex_trylock(&tl_inode->i_mutex));
5345ccd979bdSMark Fasheh 
5346ccd979bdSMark Fasheh 	start_cluster = ocfs2_blocks_to_clusters(osb->sb, start_blk);
5347ccd979bdSMark Fasheh 
5348ccd979bdSMark Fasheh 	di = (struct ocfs2_dinode *) tl_bh->b_data;
5349ccd979bdSMark Fasheh 	tl = &di->id2.i_dealloc;
5350ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_DINODE(di)) {
5351ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_DINODE(osb->sb, di);
5352ccd979bdSMark Fasheh 		status = -EIO;
5353ccd979bdSMark Fasheh 		goto bail;
5354ccd979bdSMark Fasheh 	}
5355ccd979bdSMark Fasheh 
5356ccd979bdSMark Fasheh 	tl_count = le16_to_cpu(tl->tl_count);
5357ccd979bdSMark Fasheh 	mlog_bug_on_msg(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) ||
5358ccd979bdSMark Fasheh 			tl_count == 0,
5359b0697053SMark Fasheh 			"Truncate record count on #%llu invalid "
5360b0697053SMark Fasheh 			"wanted %u, actual %u\n",
5361b0697053SMark Fasheh 			(unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5362ccd979bdSMark Fasheh 			ocfs2_truncate_recs_per_inode(osb->sb),
5363ccd979bdSMark Fasheh 			le16_to_cpu(tl->tl_count));
5364ccd979bdSMark Fasheh 
5365ccd979bdSMark Fasheh 	/* Caller should have known to flush before calling us. */
5366ccd979bdSMark Fasheh 	index = le16_to_cpu(tl->tl_used);
5367ccd979bdSMark Fasheh 	if (index >= tl_count) {
5368ccd979bdSMark Fasheh 		status = -ENOSPC;
5369ccd979bdSMark Fasheh 		mlog_errno(status);
5370ccd979bdSMark Fasheh 		goto bail;
5371ccd979bdSMark Fasheh 	}
5372ccd979bdSMark Fasheh 
5373ccd979bdSMark Fasheh 	status = ocfs2_journal_access(handle, tl_inode, tl_bh,
5374ccd979bdSMark Fasheh 				      OCFS2_JOURNAL_ACCESS_WRITE);
5375ccd979bdSMark Fasheh 	if (status < 0) {
5376ccd979bdSMark Fasheh 		mlog_errno(status);
5377ccd979bdSMark Fasheh 		goto bail;
5378ccd979bdSMark Fasheh 	}
5379ccd979bdSMark Fasheh 
5380ccd979bdSMark Fasheh 	mlog(0, "Log truncate of %u clusters starting at cluster %u to "
5381b0697053SMark Fasheh 	     "%llu (index = %d)\n", num_clusters, start_cluster,
5382b0697053SMark Fasheh 	     (unsigned long long)OCFS2_I(tl_inode)->ip_blkno, index);
5383ccd979bdSMark Fasheh 
5384ccd979bdSMark Fasheh 	if (ocfs2_truncate_log_can_coalesce(tl, start_cluster)) {
5385ccd979bdSMark Fasheh 		/*
5386ccd979bdSMark Fasheh 		 * Move index back to the record we are coalescing with.
5387ccd979bdSMark Fasheh 		 * ocfs2_truncate_log_can_coalesce() guarantees nonzero
5388ccd979bdSMark Fasheh 		 */
5389ccd979bdSMark Fasheh 		index--;
5390ccd979bdSMark Fasheh 
5391ccd979bdSMark Fasheh 		num_clusters += le32_to_cpu(tl->tl_recs[index].t_clusters);
5392ccd979bdSMark Fasheh 		mlog(0, "Coalesce with index %u (start = %u, clusters = %u)\n",
5393ccd979bdSMark Fasheh 		     index, le32_to_cpu(tl->tl_recs[index].t_start),
5394ccd979bdSMark Fasheh 		     num_clusters);
5395ccd979bdSMark Fasheh 	} else {
5396ccd979bdSMark Fasheh 		tl->tl_recs[index].t_start = cpu_to_le32(start_cluster);
5397ccd979bdSMark Fasheh 		tl->tl_used = cpu_to_le16(index + 1);
5398ccd979bdSMark Fasheh 	}
5399ccd979bdSMark Fasheh 	tl->tl_recs[index].t_clusters = cpu_to_le32(num_clusters);
5400ccd979bdSMark Fasheh 
5401ccd979bdSMark Fasheh 	status = ocfs2_journal_dirty(handle, tl_bh);
5402ccd979bdSMark Fasheh 	if (status < 0) {
5403ccd979bdSMark Fasheh 		mlog_errno(status);
5404ccd979bdSMark Fasheh 		goto bail;
5405ccd979bdSMark Fasheh 	}
5406ccd979bdSMark Fasheh 
5407ccd979bdSMark Fasheh bail:
5408ccd979bdSMark Fasheh 	mlog_exit(status);
5409ccd979bdSMark Fasheh 	return status;
5410ccd979bdSMark Fasheh }
5411ccd979bdSMark Fasheh 
5412ccd979bdSMark Fasheh static int ocfs2_replay_truncate_records(struct ocfs2_super *osb,
54131fabe148SMark Fasheh 					 handle_t *handle,
5414ccd979bdSMark Fasheh 					 struct inode *data_alloc_inode,
5415ccd979bdSMark Fasheh 					 struct buffer_head *data_alloc_bh)
5416ccd979bdSMark Fasheh {
5417ccd979bdSMark Fasheh 	int status = 0;
5418ccd979bdSMark Fasheh 	int i;
5419ccd979bdSMark Fasheh 	unsigned int num_clusters;
5420ccd979bdSMark Fasheh 	u64 start_blk;
5421ccd979bdSMark Fasheh 	struct ocfs2_truncate_rec rec;
5422ccd979bdSMark Fasheh 	struct ocfs2_dinode *di;
5423ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
5424ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
5425ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = osb->osb_tl_bh;
5426ccd979bdSMark Fasheh 
5427ccd979bdSMark Fasheh 	mlog_entry_void();
5428ccd979bdSMark Fasheh 
5429ccd979bdSMark Fasheh 	di = (struct ocfs2_dinode *) tl_bh->b_data;
5430ccd979bdSMark Fasheh 	tl = &di->id2.i_dealloc;
5431ccd979bdSMark Fasheh 	i = le16_to_cpu(tl->tl_used) - 1;
5432ccd979bdSMark Fasheh 	while (i >= 0) {
5433ccd979bdSMark Fasheh 		/* Caller has given us at least enough credits to
5434ccd979bdSMark Fasheh 		 * update the truncate log dinode */
5435ccd979bdSMark Fasheh 		status = ocfs2_journal_access(handle, tl_inode, tl_bh,
5436ccd979bdSMark Fasheh 					      OCFS2_JOURNAL_ACCESS_WRITE);
5437ccd979bdSMark Fasheh 		if (status < 0) {
5438ccd979bdSMark Fasheh 			mlog_errno(status);
5439ccd979bdSMark Fasheh 			goto bail;
5440ccd979bdSMark Fasheh 		}
5441ccd979bdSMark Fasheh 
5442ccd979bdSMark Fasheh 		tl->tl_used = cpu_to_le16(i);
5443ccd979bdSMark Fasheh 
5444ccd979bdSMark Fasheh 		status = ocfs2_journal_dirty(handle, tl_bh);
5445ccd979bdSMark Fasheh 		if (status < 0) {
5446ccd979bdSMark Fasheh 			mlog_errno(status);
5447ccd979bdSMark Fasheh 			goto bail;
5448ccd979bdSMark Fasheh 		}
5449ccd979bdSMark Fasheh 
5450ccd979bdSMark Fasheh 		/* TODO: Perhaps we can calculate the bulk of the
5451ccd979bdSMark Fasheh 		 * credits up front rather than extending like
5452ccd979bdSMark Fasheh 		 * this. */
5453ccd979bdSMark Fasheh 		status = ocfs2_extend_trans(handle,
5454ccd979bdSMark Fasheh 					    OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC);
5455ccd979bdSMark Fasheh 		if (status < 0) {
5456ccd979bdSMark Fasheh 			mlog_errno(status);
5457ccd979bdSMark Fasheh 			goto bail;
5458ccd979bdSMark Fasheh 		}
5459ccd979bdSMark Fasheh 
5460ccd979bdSMark Fasheh 		rec = tl->tl_recs[i];
5461ccd979bdSMark Fasheh 		start_blk = ocfs2_clusters_to_blocks(data_alloc_inode->i_sb,
5462ccd979bdSMark Fasheh 						    le32_to_cpu(rec.t_start));
5463ccd979bdSMark Fasheh 		num_clusters = le32_to_cpu(rec.t_clusters);
5464ccd979bdSMark Fasheh 
5465ccd979bdSMark Fasheh 		/* if start_blk is not set, we ignore the record as
5466ccd979bdSMark Fasheh 		 * invalid. */
5467ccd979bdSMark Fasheh 		if (start_blk) {
5468ccd979bdSMark Fasheh 			mlog(0, "free record %d, start = %u, clusters = %u\n",
5469ccd979bdSMark Fasheh 			     i, le32_to_cpu(rec.t_start), num_clusters);
5470ccd979bdSMark Fasheh 
5471ccd979bdSMark Fasheh 			status = ocfs2_free_clusters(handle, data_alloc_inode,
5472ccd979bdSMark Fasheh 						     data_alloc_bh, start_blk,
5473ccd979bdSMark Fasheh 						     num_clusters);
5474ccd979bdSMark Fasheh 			if (status < 0) {
5475ccd979bdSMark Fasheh 				mlog_errno(status);
5476ccd979bdSMark Fasheh 				goto bail;
5477ccd979bdSMark Fasheh 			}
5478ccd979bdSMark Fasheh 		}
5479ccd979bdSMark Fasheh 		i--;
5480ccd979bdSMark Fasheh 	}
5481ccd979bdSMark Fasheh 
5482ccd979bdSMark Fasheh bail:
5483ccd979bdSMark Fasheh 	mlog_exit(status);
5484ccd979bdSMark Fasheh 	return status;
5485ccd979bdSMark Fasheh }
5486ccd979bdSMark Fasheh 
54871b1dcc1bSJes Sorensen /* Expects you to already be holding tl_inode->i_mutex */
5488063c4561SMark Fasheh int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
5489ccd979bdSMark Fasheh {
5490ccd979bdSMark Fasheh 	int status;
5491ccd979bdSMark Fasheh 	unsigned int num_to_flush;
54921fabe148SMark Fasheh 	handle_t *handle;
5493ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
5494ccd979bdSMark Fasheh 	struct inode *data_alloc_inode = NULL;
5495ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = osb->osb_tl_bh;
5496ccd979bdSMark Fasheh 	struct buffer_head *data_alloc_bh = NULL;
5497ccd979bdSMark Fasheh 	struct ocfs2_dinode *di;
5498ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
5499ccd979bdSMark Fasheh 
5500ccd979bdSMark Fasheh 	mlog_entry_void();
5501ccd979bdSMark Fasheh 
55021b1dcc1bSJes Sorensen 	BUG_ON(mutex_trylock(&tl_inode->i_mutex));
5503ccd979bdSMark Fasheh 
5504ccd979bdSMark Fasheh 	di = (struct ocfs2_dinode *) tl_bh->b_data;
5505ccd979bdSMark Fasheh 	tl = &di->id2.i_dealloc;
5506ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_DINODE(di)) {
5507ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_DINODE(osb->sb, di);
5508ccd979bdSMark Fasheh 		status = -EIO;
5509e08dc8b9SMark Fasheh 		goto out;
5510ccd979bdSMark Fasheh 	}
5511ccd979bdSMark Fasheh 
5512ccd979bdSMark Fasheh 	num_to_flush = le16_to_cpu(tl->tl_used);
5513b0697053SMark Fasheh 	mlog(0, "Flush %u records from truncate log #%llu\n",
5514b0697053SMark Fasheh 	     num_to_flush, (unsigned long long)OCFS2_I(tl_inode)->ip_blkno);
5515ccd979bdSMark Fasheh 	if (!num_to_flush) {
5516ccd979bdSMark Fasheh 		status = 0;
5517e08dc8b9SMark Fasheh 		goto out;
5518ccd979bdSMark Fasheh 	}
5519ccd979bdSMark Fasheh 
5520ccd979bdSMark Fasheh 	data_alloc_inode = ocfs2_get_system_file_inode(osb,
5521ccd979bdSMark Fasheh 						       GLOBAL_BITMAP_SYSTEM_INODE,
5522ccd979bdSMark Fasheh 						       OCFS2_INVALID_SLOT);
5523ccd979bdSMark Fasheh 	if (!data_alloc_inode) {
5524ccd979bdSMark Fasheh 		status = -EINVAL;
5525ccd979bdSMark Fasheh 		mlog(ML_ERROR, "Could not get bitmap inode!\n");
5526e08dc8b9SMark Fasheh 		goto out;
5527ccd979bdSMark Fasheh 	}
5528ccd979bdSMark Fasheh 
5529e08dc8b9SMark Fasheh 	mutex_lock(&data_alloc_inode->i_mutex);
5530e08dc8b9SMark Fasheh 
5531e63aecb6SMark Fasheh 	status = ocfs2_inode_lock(data_alloc_inode, &data_alloc_bh, 1);
5532ccd979bdSMark Fasheh 	if (status < 0) {
5533ccd979bdSMark Fasheh 		mlog_errno(status);
5534e08dc8b9SMark Fasheh 		goto out_mutex;
5535ccd979bdSMark Fasheh 	}
5536ccd979bdSMark Fasheh 
553765eff9ccSMark Fasheh 	handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
5538ccd979bdSMark Fasheh 	if (IS_ERR(handle)) {
5539ccd979bdSMark Fasheh 		status = PTR_ERR(handle);
5540ccd979bdSMark Fasheh 		mlog_errno(status);
5541e08dc8b9SMark Fasheh 		goto out_unlock;
5542ccd979bdSMark Fasheh 	}
5543ccd979bdSMark Fasheh 
5544ccd979bdSMark Fasheh 	status = ocfs2_replay_truncate_records(osb, handle, data_alloc_inode,
5545ccd979bdSMark Fasheh 					       data_alloc_bh);
5546e08dc8b9SMark Fasheh 	if (status < 0)
5547ccd979bdSMark Fasheh 		mlog_errno(status);
5548ccd979bdSMark Fasheh 
554902dc1af4SMark Fasheh 	ocfs2_commit_trans(osb, handle);
5550ccd979bdSMark Fasheh 
5551e08dc8b9SMark Fasheh out_unlock:
5552e08dc8b9SMark Fasheh 	brelse(data_alloc_bh);
5553e63aecb6SMark Fasheh 	ocfs2_inode_unlock(data_alloc_inode, 1);
5554e08dc8b9SMark Fasheh 
5555e08dc8b9SMark Fasheh out_mutex:
5556e08dc8b9SMark Fasheh 	mutex_unlock(&data_alloc_inode->i_mutex);
5557ccd979bdSMark Fasheh 	iput(data_alloc_inode);
5558ccd979bdSMark Fasheh 
5559e08dc8b9SMark Fasheh out:
5560ccd979bdSMark Fasheh 	mlog_exit(status);
5561ccd979bdSMark Fasheh 	return status;
5562ccd979bdSMark Fasheh }
5563ccd979bdSMark Fasheh 
5564ccd979bdSMark Fasheh int ocfs2_flush_truncate_log(struct ocfs2_super *osb)
5565ccd979bdSMark Fasheh {
5566ccd979bdSMark Fasheh 	int status;
5567ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
5568ccd979bdSMark Fasheh 
55691b1dcc1bSJes Sorensen 	mutex_lock(&tl_inode->i_mutex);
5570ccd979bdSMark Fasheh 	status = __ocfs2_flush_truncate_log(osb);
55711b1dcc1bSJes Sorensen 	mutex_unlock(&tl_inode->i_mutex);
5572ccd979bdSMark Fasheh 
5573ccd979bdSMark Fasheh 	return status;
5574ccd979bdSMark Fasheh }
5575ccd979bdSMark Fasheh 
5576c4028958SDavid Howells static void ocfs2_truncate_log_worker(struct work_struct *work)
5577ccd979bdSMark Fasheh {
5578ccd979bdSMark Fasheh 	int status;
5579c4028958SDavid Howells 	struct ocfs2_super *osb =
5580c4028958SDavid Howells 		container_of(work, struct ocfs2_super,
5581c4028958SDavid Howells 			     osb_truncate_log_wq.work);
5582ccd979bdSMark Fasheh 
5583ccd979bdSMark Fasheh 	mlog_entry_void();
5584ccd979bdSMark Fasheh 
5585ccd979bdSMark Fasheh 	status = ocfs2_flush_truncate_log(osb);
5586ccd979bdSMark Fasheh 	if (status < 0)
5587ccd979bdSMark Fasheh 		mlog_errno(status);
55884d0ddb2cSTao Ma 	else
55894d0ddb2cSTao Ma 		ocfs2_init_inode_steal_slot(osb);
5590ccd979bdSMark Fasheh 
5591ccd979bdSMark Fasheh 	mlog_exit(status);
5592ccd979bdSMark Fasheh }
5593ccd979bdSMark Fasheh 
5594ccd979bdSMark Fasheh #define OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL (2 * HZ)
5595ccd979bdSMark Fasheh void ocfs2_schedule_truncate_log_flush(struct ocfs2_super *osb,
5596ccd979bdSMark Fasheh 				       int cancel)
5597ccd979bdSMark Fasheh {
5598ccd979bdSMark Fasheh 	if (osb->osb_tl_inode) {
5599ccd979bdSMark Fasheh 		/* We want to push off log flushes while truncates are
5600ccd979bdSMark Fasheh 		 * still running. */
5601ccd979bdSMark Fasheh 		if (cancel)
5602ccd979bdSMark Fasheh 			cancel_delayed_work(&osb->osb_truncate_log_wq);
5603ccd979bdSMark Fasheh 
5604ccd979bdSMark Fasheh 		queue_delayed_work(ocfs2_wq, &osb->osb_truncate_log_wq,
5605ccd979bdSMark Fasheh 				   OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL);
5606ccd979bdSMark Fasheh 	}
5607ccd979bdSMark Fasheh }
5608ccd979bdSMark Fasheh 
5609ccd979bdSMark Fasheh static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb,
5610ccd979bdSMark Fasheh 				       int slot_num,
5611ccd979bdSMark Fasheh 				       struct inode **tl_inode,
5612ccd979bdSMark Fasheh 				       struct buffer_head **tl_bh)
5613ccd979bdSMark Fasheh {
5614ccd979bdSMark Fasheh 	int status;
5615ccd979bdSMark Fasheh 	struct inode *inode = NULL;
5616ccd979bdSMark Fasheh 	struct buffer_head *bh = NULL;
5617ccd979bdSMark Fasheh 
5618ccd979bdSMark Fasheh 	inode = ocfs2_get_system_file_inode(osb,
5619ccd979bdSMark Fasheh 					   TRUNCATE_LOG_SYSTEM_INODE,
5620ccd979bdSMark Fasheh 					   slot_num);
5621ccd979bdSMark Fasheh 	if (!inode) {
5622ccd979bdSMark Fasheh 		status = -EINVAL;
5623ccd979bdSMark Fasheh 		mlog(ML_ERROR, "Could not get load truncate log inode!\n");
5624ccd979bdSMark Fasheh 		goto bail;
5625ccd979bdSMark Fasheh 	}
5626ccd979bdSMark Fasheh 
5627ccd979bdSMark Fasheh 	status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &bh,
5628ccd979bdSMark Fasheh 				  OCFS2_BH_CACHED, inode);
5629ccd979bdSMark Fasheh 	if (status < 0) {
5630ccd979bdSMark Fasheh 		iput(inode);
5631ccd979bdSMark Fasheh 		mlog_errno(status);
5632ccd979bdSMark Fasheh 		goto bail;
5633ccd979bdSMark Fasheh 	}
5634ccd979bdSMark Fasheh 
5635ccd979bdSMark Fasheh 	*tl_inode = inode;
5636ccd979bdSMark Fasheh 	*tl_bh    = bh;
5637ccd979bdSMark Fasheh bail:
5638ccd979bdSMark Fasheh 	mlog_exit(status);
5639ccd979bdSMark Fasheh 	return status;
5640ccd979bdSMark Fasheh }
5641ccd979bdSMark Fasheh 
5642ccd979bdSMark Fasheh /* called during the 1st stage of node recovery. we stamp a clean
5643ccd979bdSMark Fasheh  * truncate log and pass back a copy for processing later. if the
5644ccd979bdSMark Fasheh  * truncate log does not require processing, a *tl_copy is set to
5645ccd979bdSMark Fasheh  * NULL. */
5646ccd979bdSMark Fasheh int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
5647ccd979bdSMark Fasheh 				      int slot_num,
5648ccd979bdSMark Fasheh 				      struct ocfs2_dinode **tl_copy)
5649ccd979bdSMark Fasheh {
5650ccd979bdSMark Fasheh 	int status;
5651ccd979bdSMark Fasheh 	struct inode *tl_inode = NULL;
5652ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = NULL;
5653ccd979bdSMark Fasheh 	struct ocfs2_dinode *di;
5654ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
5655ccd979bdSMark Fasheh 
5656ccd979bdSMark Fasheh 	*tl_copy = NULL;
5657ccd979bdSMark Fasheh 
5658ccd979bdSMark Fasheh 	mlog(0, "recover truncate log from slot %d\n", slot_num);
5659ccd979bdSMark Fasheh 
5660ccd979bdSMark Fasheh 	status = ocfs2_get_truncate_log_info(osb, slot_num, &tl_inode, &tl_bh);
5661ccd979bdSMark Fasheh 	if (status < 0) {
5662ccd979bdSMark Fasheh 		mlog_errno(status);
5663ccd979bdSMark Fasheh 		goto bail;
5664ccd979bdSMark Fasheh 	}
5665ccd979bdSMark Fasheh 
5666ccd979bdSMark Fasheh 	di = (struct ocfs2_dinode *) tl_bh->b_data;
5667ccd979bdSMark Fasheh 	tl = &di->id2.i_dealloc;
5668ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_DINODE(di)) {
5669ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_DINODE(tl_inode->i_sb, di);
5670ccd979bdSMark Fasheh 		status = -EIO;
5671ccd979bdSMark Fasheh 		goto bail;
5672ccd979bdSMark Fasheh 	}
5673ccd979bdSMark Fasheh 
5674ccd979bdSMark Fasheh 	if (le16_to_cpu(tl->tl_used)) {
5675ccd979bdSMark Fasheh 		mlog(0, "We'll have %u logs to recover\n",
5676ccd979bdSMark Fasheh 		     le16_to_cpu(tl->tl_used));
5677ccd979bdSMark Fasheh 
5678ccd979bdSMark Fasheh 		*tl_copy = kmalloc(tl_bh->b_size, GFP_KERNEL);
5679ccd979bdSMark Fasheh 		if (!(*tl_copy)) {
5680ccd979bdSMark Fasheh 			status = -ENOMEM;
5681ccd979bdSMark Fasheh 			mlog_errno(status);
5682ccd979bdSMark Fasheh 			goto bail;
5683ccd979bdSMark Fasheh 		}
5684ccd979bdSMark Fasheh 
5685ccd979bdSMark Fasheh 		/* Assuming the write-out below goes well, this copy
5686ccd979bdSMark Fasheh 		 * will be passed back to recovery for processing. */
5687ccd979bdSMark Fasheh 		memcpy(*tl_copy, tl_bh->b_data, tl_bh->b_size);
5688ccd979bdSMark Fasheh 
5689ccd979bdSMark Fasheh 		/* All we need to do to clear the truncate log is set
5690ccd979bdSMark Fasheh 		 * tl_used. */
5691ccd979bdSMark Fasheh 		tl->tl_used = 0;
5692ccd979bdSMark Fasheh 
5693ccd979bdSMark Fasheh 		status = ocfs2_write_block(osb, tl_bh, tl_inode);
5694ccd979bdSMark Fasheh 		if (status < 0) {
5695ccd979bdSMark Fasheh 			mlog_errno(status);
5696ccd979bdSMark Fasheh 			goto bail;
5697ccd979bdSMark Fasheh 		}
5698ccd979bdSMark Fasheh 	}
5699ccd979bdSMark Fasheh 
5700ccd979bdSMark Fasheh bail:
5701ccd979bdSMark Fasheh 	if (tl_inode)
5702ccd979bdSMark Fasheh 		iput(tl_inode);
5703ccd979bdSMark Fasheh 	if (tl_bh)
5704ccd979bdSMark Fasheh 		brelse(tl_bh);
5705ccd979bdSMark Fasheh 
5706ccd979bdSMark Fasheh 	if (status < 0 && (*tl_copy)) {
5707ccd979bdSMark Fasheh 		kfree(*tl_copy);
5708ccd979bdSMark Fasheh 		*tl_copy = NULL;
5709ccd979bdSMark Fasheh 	}
5710ccd979bdSMark Fasheh 
5711ccd979bdSMark Fasheh 	mlog_exit(status);
5712ccd979bdSMark Fasheh 	return status;
5713ccd979bdSMark Fasheh }
5714ccd979bdSMark Fasheh 
5715ccd979bdSMark Fasheh int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
5716ccd979bdSMark Fasheh 					 struct ocfs2_dinode *tl_copy)
5717ccd979bdSMark Fasheh {
5718ccd979bdSMark Fasheh 	int status = 0;
5719ccd979bdSMark Fasheh 	int i;
5720ccd979bdSMark Fasheh 	unsigned int clusters, num_recs, start_cluster;
5721ccd979bdSMark Fasheh 	u64 start_blk;
57221fabe148SMark Fasheh 	handle_t *handle;
5723ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
5724ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
5725ccd979bdSMark Fasheh 
5726ccd979bdSMark Fasheh 	mlog_entry_void();
5727ccd979bdSMark Fasheh 
5728ccd979bdSMark Fasheh 	if (OCFS2_I(tl_inode)->ip_blkno == le64_to_cpu(tl_copy->i_blkno)) {
5729ccd979bdSMark Fasheh 		mlog(ML_ERROR, "Asked to recover my own truncate log!\n");
5730ccd979bdSMark Fasheh 		return -EINVAL;
5731ccd979bdSMark Fasheh 	}
5732ccd979bdSMark Fasheh 
5733ccd979bdSMark Fasheh 	tl = &tl_copy->id2.i_dealloc;
5734ccd979bdSMark Fasheh 	num_recs = le16_to_cpu(tl->tl_used);
5735b0697053SMark Fasheh 	mlog(0, "cleanup %u records from %llu\n", num_recs,
57361ca1a111SMark Fasheh 	     (unsigned long long)le64_to_cpu(tl_copy->i_blkno));
5737ccd979bdSMark Fasheh 
57381b1dcc1bSJes Sorensen 	mutex_lock(&tl_inode->i_mutex);
5739ccd979bdSMark Fasheh 	for(i = 0; i < num_recs; i++) {
5740ccd979bdSMark Fasheh 		if (ocfs2_truncate_log_needs_flush(osb)) {
5741ccd979bdSMark Fasheh 			status = __ocfs2_flush_truncate_log(osb);
5742ccd979bdSMark Fasheh 			if (status < 0) {
5743ccd979bdSMark Fasheh 				mlog_errno(status);
5744ccd979bdSMark Fasheh 				goto bail_up;
5745ccd979bdSMark Fasheh 			}
5746ccd979bdSMark Fasheh 		}
5747ccd979bdSMark Fasheh 
574865eff9ccSMark Fasheh 		handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
5749ccd979bdSMark Fasheh 		if (IS_ERR(handle)) {
5750ccd979bdSMark Fasheh 			status = PTR_ERR(handle);
5751ccd979bdSMark Fasheh 			mlog_errno(status);
5752ccd979bdSMark Fasheh 			goto bail_up;
5753ccd979bdSMark Fasheh 		}
5754ccd979bdSMark Fasheh 
5755ccd979bdSMark Fasheh 		clusters = le32_to_cpu(tl->tl_recs[i].t_clusters);
5756ccd979bdSMark Fasheh 		start_cluster = le32_to_cpu(tl->tl_recs[i].t_start);
5757ccd979bdSMark Fasheh 		start_blk = ocfs2_clusters_to_blocks(osb->sb, start_cluster);
5758ccd979bdSMark Fasheh 
5759ccd979bdSMark Fasheh 		status = ocfs2_truncate_log_append(osb, handle,
5760ccd979bdSMark Fasheh 						   start_blk, clusters);
576102dc1af4SMark Fasheh 		ocfs2_commit_trans(osb, handle);
5762ccd979bdSMark Fasheh 		if (status < 0) {
5763ccd979bdSMark Fasheh 			mlog_errno(status);
5764ccd979bdSMark Fasheh 			goto bail_up;
5765ccd979bdSMark Fasheh 		}
5766ccd979bdSMark Fasheh 	}
5767ccd979bdSMark Fasheh 
5768ccd979bdSMark Fasheh bail_up:
57691b1dcc1bSJes Sorensen 	mutex_unlock(&tl_inode->i_mutex);
5770ccd979bdSMark Fasheh 
5771ccd979bdSMark Fasheh 	mlog_exit(status);
5772ccd979bdSMark Fasheh 	return status;
5773ccd979bdSMark Fasheh }
5774ccd979bdSMark Fasheh 
5775ccd979bdSMark Fasheh void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb)
5776ccd979bdSMark Fasheh {
5777ccd979bdSMark Fasheh 	int status;
5778ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
5779ccd979bdSMark Fasheh 
5780ccd979bdSMark Fasheh 	mlog_entry_void();
5781ccd979bdSMark Fasheh 
5782ccd979bdSMark Fasheh 	if (tl_inode) {
5783ccd979bdSMark Fasheh 		cancel_delayed_work(&osb->osb_truncate_log_wq);
5784ccd979bdSMark Fasheh 		flush_workqueue(ocfs2_wq);
5785ccd979bdSMark Fasheh 
5786ccd979bdSMark Fasheh 		status = ocfs2_flush_truncate_log(osb);
5787ccd979bdSMark Fasheh 		if (status < 0)
5788ccd979bdSMark Fasheh 			mlog_errno(status);
5789ccd979bdSMark Fasheh 
5790ccd979bdSMark Fasheh 		brelse(osb->osb_tl_bh);
5791ccd979bdSMark Fasheh 		iput(osb->osb_tl_inode);
5792ccd979bdSMark Fasheh 	}
5793ccd979bdSMark Fasheh 
5794ccd979bdSMark Fasheh 	mlog_exit_void();
5795ccd979bdSMark Fasheh }
5796ccd979bdSMark Fasheh 
5797ccd979bdSMark Fasheh int ocfs2_truncate_log_init(struct ocfs2_super *osb)
5798ccd979bdSMark Fasheh {
5799ccd979bdSMark Fasheh 	int status;
5800ccd979bdSMark Fasheh 	struct inode *tl_inode = NULL;
5801ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = NULL;
5802ccd979bdSMark Fasheh 
5803ccd979bdSMark Fasheh 	mlog_entry_void();
5804ccd979bdSMark Fasheh 
5805ccd979bdSMark Fasheh 	status = ocfs2_get_truncate_log_info(osb,
5806ccd979bdSMark Fasheh 					     osb->slot_num,
5807ccd979bdSMark Fasheh 					     &tl_inode,
5808ccd979bdSMark Fasheh 					     &tl_bh);
5809ccd979bdSMark Fasheh 	if (status < 0)
5810ccd979bdSMark Fasheh 		mlog_errno(status);
5811ccd979bdSMark Fasheh 
5812ccd979bdSMark Fasheh 	/* ocfs2_truncate_log_shutdown keys on the existence of
5813ccd979bdSMark Fasheh 	 * osb->osb_tl_inode so we don't set any of the osb variables
5814ccd979bdSMark Fasheh 	 * until we're sure all is well. */
5815c4028958SDavid Howells 	INIT_DELAYED_WORK(&osb->osb_truncate_log_wq,
5816c4028958SDavid Howells 			  ocfs2_truncate_log_worker);
5817ccd979bdSMark Fasheh 	osb->osb_tl_bh    = tl_bh;
5818ccd979bdSMark Fasheh 	osb->osb_tl_inode = tl_inode;
5819ccd979bdSMark Fasheh 
5820ccd979bdSMark Fasheh 	mlog_exit(status);
5821ccd979bdSMark Fasheh 	return status;
5822ccd979bdSMark Fasheh }
5823ccd979bdSMark Fasheh 
58242b604351SMark Fasheh /*
58252b604351SMark Fasheh  * Delayed de-allocation of suballocator blocks.
58262b604351SMark Fasheh  *
58272b604351SMark Fasheh  * Some sets of block de-allocations might involve multiple suballocator inodes.
58282b604351SMark Fasheh  *
58292b604351SMark Fasheh  * The locking for this can get extremely complicated, especially when
58302b604351SMark Fasheh  * the suballocator inodes to delete from aren't known until deep
58312b604351SMark Fasheh  * within an unrelated codepath.
58322b604351SMark Fasheh  *
58332b604351SMark Fasheh  * ocfs2_extent_block structures are a good example of this - an inode
58342b604351SMark Fasheh  * btree could have been grown by any number of nodes each allocating
58352b604351SMark Fasheh  * out of their own suballoc inode.
58362b604351SMark Fasheh  *
58372b604351SMark Fasheh  * These structures allow the delay of block de-allocation until a
58382b604351SMark Fasheh  * later time, when locking of multiple cluster inodes won't cause
58392b604351SMark Fasheh  * deadlock.
58402b604351SMark Fasheh  */
58412b604351SMark Fasheh 
58422b604351SMark Fasheh /*
58432b604351SMark Fasheh  * Describes a single block free from a suballocator
58442b604351SMark Fasheh  */
58452b604351SMark Fasheh struct ocfs2_cached_block_free {
58462b604351SMark Fasheh 	struct ocfs2_cached_block_free		*free_next;
58472b604351SMark Fasheh 	u64					free_blk;
58482b604351SMark Fasheh 	unsigned int				free_bit;
58492b604351SMark Fasheh };
58502b604351SMark Fasheh 
58512b604351SMark Fasheh struct ocfs2_per_slot_free_list {
58522b604351SMark Fasheh 	struct ocfs2_per_slot_free_list		*f_next_suballocator;
58532b604351SMark Fasheh 	int					f_inode_type;
58542b604351SMark Fasheh 	int					f_slot;
58552b604351SMark Fasheh 	struct ocfs2_cached_block_free		*f_first;
58562b604351SMark Fasheh };
58572b604351SMark Fasheh 
58582b604351SMark Fasheh static int ocfs2_free_cached_items(struct ocfs2_super *osb,
58592b604351SMark Fasheh 				   int sysfile_type,
58602b604351SMark Fasheh 				   int slot,
58612b604351SMark Fasheh 				   struct ocfs2_cached_block_free *head)
58622b604351SMark Fasheh {
58632b604351SMark Fasheh 	int ret;
58642b604351SMark Fasheh 	u64 bg_blkno;
58652b604351SMark Fasheh 	handle_t *handle;
58662b604351SMark Fasheh 	struct inode *inode;
58672b604351SMark Fasheh 	struct buffer_head *di_bh = NULL;
58682b604351SMark Fasheh 	struct ocfs2_cached_block_free *tmp;
58692b604351SMark Fasheh 
58702b604351SMark Fasheh 	inode = ocfs2_get_system_file_inode(osb, sysfile_type, slot);
58712b604351SMark Fasheh 	if (!inode) {
58722b604351SMark Fasheh 		ret = -EINVAL;
58732b604351SMark Fasheh 		mlog_errno(ret);
58742b604351SMark Fasheh 		goto out;
58752b604351SMark Fasheh 	}
58762b604351SMark Fasheh 
58772b604351SMark Fasheh 	mutex_lock(&inode->i_mutex);
58782b604351SMark Fasheh 
5879e63aecb6SMark Fasheh 	ret = ocfs2_inode_lock(inode, &di_bh, 1);
58802b604351SMark Fasheh 	if (ret) {
58812b604351SMark Fasheh 		mlog_errno(ret);
58822b604351SMark Fasheh 		goto out_mutex;
58832b604351SMark Fasheh 	}
58842b604351SMark Fasheh 
58852b604351SMark Fasheh 	handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
58862b604351SMark Fasheh 	if (IS_ERR(handle)) {
58872b604351SMark Fasheh 		ret = PTR_ERR(handle);
58882b604351SMark Fasheh 		mlog_errno(ret);
58892b604351SMark Fasheh 		goto out_unlock;
58902b604351SMark Fasheh 	}
58912b604351SMark Fasheh 
58922b604351SMark Fasheh 	while (head) {
58932b604351SMark Fasheh 		bg_blkno = ocfs2_which_suballoc_group(head->free_blk,
58942b604351SMark Fasheh 						      head->free_bit);
58952b604351SMark Fasheh 		mlog(0, "Free bit: (bit %u, blkno %llu)\n",
58962b604351SMark Fasheh 		     head->free_bit, (unsigned long long)head->free_blk);
58972b604351SMark Fasheh 
58982b604351SMark Fasheh 		ret = ocfs2_free_suballoc_bits(handle, inode, di_bh,
58992b604351SMark Fasheh 					       head->free_bit, bg_blkno, 1);
59002b604351SMark Fasheh 		if (ret) {
59012b604351SMark Fasheh 			mlog_errno(ret);
59022b604351SMark Fasheh 			goto out_journal;
59032b604351SMark Fasheh 		}
59042b604351SMark Fasheh 
59052b604351SMark Fasheh 		ret = ocfs2_extend_trans(handle, OCFS2_SUBALLOC_FREE);
59062b604351SMark Fasheh 		if (ret) {
59072b604351SMark Fasheh 			mlog_errno(ret);
59082b604351SMark Fasheh 			goto out_journal;
59092b604351SMark Fasheh 		}
59102b604351SMark Fasheh 
59112b604351SMark Fasheh 		tmp = head;
59122b604351SMark Fasheh 		head = head->free_next;
59132b604351SMark Fasheh 		kfree(tmp);
59142b604351SMark Fasheh 	}
59152b604351SMark Fasheh 
59162b604351SMark Fasheh out_journal:
59172b604351SMark Fasheh 	ocfs2_commit_trans(osb, handle);
59182b604351SMark Fasheh 
59192b604351SMark Fasheh out_unlock:
5920e63aecb6SMark Fasheh 	ocfs2_inode_unlock(inode, 1);
59212b604351SMark Fasheh 	brelse(di_bh);
59222b604351SMark Fasheh out_mutex:
59232b604351SMark Fasheh 	mutex_unlock(&inode->i_mutex);
59242b604351SMark Fasheh 	iput(inode);
59252b604351SMark Fasheh out:
59262b604351SMark Fasheh 	while(head) {
59272b604351SMark Fasheh 		/* Premature exit may have left some dangling items. */
59282b604351SMark Fasheh 		tmp = head;
59292b604351SMark Fasheh 		head = head->free_next;
59302b604351SMark Fasheh 		kfree(tmp);
59312b604351SMark Fasheh 	}
59322b604351SMark Fasheh 
59332b604351SMark Fasheh 	return ret;
59342b604351SMark Fasheh }
59352b604351SMark Fasheh 
59362b604351SMark Fasheh int ocfs2_run_deallocs(struct ocfs2_super *osb,
59372b604351SMark Fasheh 		       struct ocfs2_cached_dealloc_ctxt *ctxt)
59382b604351SMark Fasheh {
59392b604351SMark Fasheh 	int ret = 0, ret2;
59402b604351SMark Fasheh 	struct ocfs2_per_slot_free_list *fl;
59412b604351SMark Fasheh 
59422b604351SMark Fasheh 	if (!ctxt)
59432b604351SMark Fasheh 		return 0;
59442b604351SMark Fasheh 
59452b604351SMark Fasheh 	while (ctxt->c_first_suballocator) {
59462b604351SMark Fasheh 		fl = ctxt->c_first_suballocator;
59472b604351SMark Fasheh 
59482b604351SMark Fasheh 		if (fl->f_first) {
59492b604351SMark Fasheh 			mlog(0, "Free items: (type %u, slot %d)\n",
59502b604351SMark Fasheh 			     fl->f_inode_type, fl->f_slot);
59512b604351SMark Fasheh 			ret2 = ocfs2_free_cached_items(osb, fl->f_inode_type,
59522b604351SMark Fasheh 						       fl->f_slot, fl->f_first);
59532b604351SMark Fasheh 			if (ret2)
59542b604351SMark Fasheh 				mlog_errno(ret2);
59552b604351SMark Fasheh 			if (!ret)
59562b604351SMark Fasheh 				ret = ret2;
59572b604351SMark Fasheh 		}
59582b604351SMark Fasheh 
59592b604351SMark Fasheh 		ctxt->c_first_suballocator = fl->f_next_suballocator;
59602b604351SMark Fasheh 		kfree(fl);
59612b604351SMark Fasheh 	}
59622b604351SMark Fasheh 
59632b604351SMark Fasheh 	return ret;
59642b604351SMark Fasheh }
59652b604351SMark Fasheh 
59662b604351SMark Fasheh static struct ocfs2_per_slot_free_list *
59672b604351SMark Fasheh ocfs2_find_per_slot_free_list(int type,
59682b604351SMark Fasheh 			      int slot,
59692b604351SMark Fasheh 			      struct ocfs2_cached_dealloc_ctxt *ctxt)
59702b604351SMark Fasheh {
59712b604351SMark Fasheh 	struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
59722b604351SMark Fasheh 
59732b604351SMark Fasheh 	while (fl) {
59742b604351SMark Fasheh 		if (fl->f_inode_type == type && fl->f_slot == slot)
59752b604351SMark Fasheh 			return fl;
59762b604351SMark Fasheh 
59772b604351SMark Fasheh 		fl = fl->f_next_suballocator;
59782b604351SMark Fasheh 	}
59792b604351SMark Fasheh 
59802b604351SMark Fasheh 	fl = kmalloc(sizeof(*fl), GFP_NOFS);
59812b604351SMark Fasheh 	if (fl) {
59822b604351SMark Fasheh 		fl->f_inode_type = type;
59832b604351SMark Fasheh 		fl->f_slot = slot;
59842b604351SMark Fasheh 		fl->f_first = NULL;
59852b604351SMark Fasheh 		fl->f_next_suballocator = ctxt->c_first_suballocator;
59862b604351SMark Fasheh 
59872b604351SMark Fasheh 		ctxt->c_first_suballocator = fl;
59882b604351SMark Fasheh 	}
59892b604351SMark Fasheh 	return fl;
59902b604351SMark Fasheh }
59912b604351SMark Fasheh 
59922b604351SMark Fasheh static int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
59932b604351SMark Fasheh 				     int type, int slot, u64 blkno,
59942b604351SMark Fasheh 				     unsigned int bit)
59952b604351SMark Fasheh {
59962b604351SMark Fasheh 	int ret;
59972b604351SMark Fasheh 	struct ocfs2_per_slot_free_list *fl;
59982b604351SMark Fasheh 	struct ocfs2_cached_block_free *item;
59992b604351SMark Fasheh 
60002b604351SMark Fasheh 	fl = ocfs2_find_per_slot_free_list(type, slot, ctxt);
60012b604351SMark Fasheh 	if (fl == NULL) {
60022b604351SMark Fasheh 		ret = -ENOMEM;
60032b604351SMark Fasheh 		mlog_errno(ret);
60042b604351SMark Fasheh 		goto out;
60052b604351SMark Fasheh 	}
60062b604351SMark Fasheh 
60072b604351SMark Fasheh 	item = kmalloc(sizeof(*item), GFP_NOFS);
60082b604351SMark Fasheh 	if (item == NULL) {
60092b604351SMark Fasheh 		ret = -ENOMEM;
60102b604351SMark Fasheh 		mlog_errno(ret);
60112b604351SMark Fasheh 		goto out;
60122b604351SMark Fasheh 	}
60132b604351SMark Fasheh 
60142b604351SMark Fasheh 	mlog(0, "Insert: (type %d, slot %u, bit %u, blk %llu)\n",
60152b604351SMark Fasheh 	     type, slot, bit, (unsigned long long)blkno);
60162b604351SMark Fasheh 
60172b604351SMark Fasheh 	item->free_blk = blkno;
60182b604351SMark Fasheh 	item->free_bit = bit;
60192b604351SMark Fasheh 	item->free_next = fl->f_first;
60202b604351SMark Fasheh 
60212b604351SMark Fasheh 	fl->f_first = item;
60222b604351SMark Fasheh 
60232b604351SMark Fasheh 	ret = 0;
60242b604351SMark Fasheh out:
60252b604351SMark Fasheh 	return ret;
60262b604351SMark Fasheh }
60272b604351SMark Fasheh 
602859a5e416SMark Fasheh static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
602959a5e416SMark Fasheh 					 struct ocfs2_extent_block *eb)
603059a5e416SMark Fasheh {
603159a5e416SMark Fasheh 	return ocfs2_cache_block_dealloc(ctxt, EXTENT_ALLOC_SYSTEM_INODE,
603259a5e416SMark Fasheh 					 le16_to_cpu(eb->h_suballoc_slot),
603359a5e416SMark Fasheh 					 le64_to_cpu(eb->h_blkno),
603459a5e416SMark Fasheh 					 le16_to_cpu(eb->h_suballoc_bit));
603559a5e416SMark Fasheh }
603659a5e416SMark Fasheh 
6037ccd979bdSMark Fasheh /* This function will figure out whether the currently last extent
6038ccd979bdSMark Fasheh  * block will be deleted, and if it will, what the new last extent
6039ccd979bdSMark Fasheh  * block will be so we can update his h_next_leaf_blk field, as well
6040ccd979bdSMark Fasheh  * as the dinodes i_last_eb_blk */
6041dcd0538fSMark Fasheh static int ocfs2_find_new_last_ext_blk(struct inode *inode,
60423a0782d0SMark Fasheh 				       unsigned int clusters_to_del,
6043dcd0538fSMark Fasheh 				       struct ocfs2_path *path,
6044ccd979bdSMark Fasheh 				       struct buffer_head **new_last_eb)
6045ccd979bdSMark Fasheh {
60463a0782d0SMark Fasheh 	int next_free, ret = 0;
6047dcd0538fSMark Fasheh 	u32 cpos;
60483a0782d0SMark Fasheh 	struct ocfs2_extent_rec *rec;
6049ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
6050ccd979bdSMark Fasheh 	struct ocfs2_extent_list *el;
6051ccd979bdSMark Fasheh 	struct buffer_head *bh = NULL;
6052ccd979bdSMark Fasheh 
6053ccd979bdSMark Fasheh 	*new_last_eb = NULL;
6054ccd979bdSMark Fasheh 
6055ccd979bdSMark Fasheh 	/* we have no tree, so of course, no last_eb. */
6056dcd0538fSMark Fasheh 	if (!path->p_tree_depth)
6057dcd0538fSMark Fasheh 		goto out;
6058ccd979bdSMark Fasheh 
6059ccd979bdSMark Fasheh 	/* trunc to zero special case - this makes tree_depth = 0
6060ccd979bdSMark Fasheh 	 * regardless of what it is.  */
60613a0782d0SMark Fasheh 	if (OCFS2_I(inode)->ip_clusters == clusters_to_del)
6062dcd0538fSMark Fasheh 		goto out;
6063ccd979bdSMark Fasheh 
6064dcd0538fSMark Fasheh 	el = path_leaf_el(path);
6065ccd979bdSMark Fasheh 	BUG_ON(!el->l_next_free_rec);
6066ccd979bdSMark Fasheh 
60673a0782d0SMark Fasheh 	/*
60683a0782d0SMark Fasheh 	 * Make sure that this extent list will actually be empty
60693a0782d0SMark Fasheh 	 * after we clear away the data. We can shortcut out if
60703a0782d0SMark Fasheh 	 * there's more than one non-empty extent in the
60713a0782d0SMark Fasheh 	 * list. Otherwise, a check of the remaining extent is
60723a0782d0SMark Fasheh 	 * necessary.
60733a0782d0SMark Fasheh 	 */
60743a0782d0SMark Fasheh 	next_free = le16_to_cpu(el->l_next_free_rec);
60753a0782d0SMark Fasheh 	rec = NULL;
6076dcd0538fSMark Fasheh 	if (ocfs2_is_empty_extent(&el->l_recs[0])) {
60773a0782d0SMark Fasheh 		if (next_free > 2)
6078dcd0538fSMark Fasheh 			goto out;
60793a0782d0SMark Fasheh 
60803a0782d0SMark Fasheh 		/* We may have a valid extent in index 1, check it. */
60813a0782d0SMark Fasheh 		if (next_free == 2)
60823a0782d0SMark Fasheh 			rec = &el->l_recs[1];
60833a0782d0SMark Fasheh 
60843a0782d0SMark Fasheh 		/*
60853a0782d0SMark Fasheh 		 * Fall through - no more nonempty extents, so we want
60863a0782d0SMark Fasheh 		 * to delete this leaf.
60873a0782d0SMark Fasheh 		 */
60883a0782d0SMark Fasheh 	} else {
60893a0782d0SMark Fasheh 		if (next_free > 1)
6090dcd0538fSMark Fasheh 			goto out;
6091ccd979bdSMark Fasheh 
60923a0782d0SMark Fasheh 		rec = &el->l_recs[0];
60933a0782d0SMark Fasheh 	}
60943a0782d0SMark Fasheh 
60953a0782d0SMark Fasheh 	if (rec) {
60963a0782d0SMark Fasheh 		/*
60973a0782d0SMark Fasheh 		 * Check it we'll only be trimming off the end of this
60983a0782d0SMark Fasheh 		 * cluster.
60993a0782d0SMark Fasheh 		 */
6100e48edee2SMark Fasheh 		if (le16_to_cpu(rec->e_leaf_clusters) > clusters_to_del)
61013a0782d0SMark Fasheh 			goto out;
61023a0782d0SMark Fasheh 	}
61033a0782d0SMark Fasheh 
6104dcd0538fSMark Fasheh 	ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, &cpos);
6105dcd0538fSMark Fasheh 	if (ret) {
6106dcd0538fSMark Fasheh 		mlog_errno(ret);
6107dcd0538fSMark Fasheh 		goto out;
6108ccd979bdSMark Fasheh 	}
6109ccd979bdSMark Fasheh 
6110dcd0538fSMark Fasheh 	ret = ocfs2_find_leaf(inode, path_root_el(path), cpos, &bh);
6111dcd0538fSMark Fasheh 	if (ret) {
6112dcd0538fSMark Fasheh 		mlog_errno(ret);
6113dcd0538fSMark Fasheh 		goto out;
6114ccd979bdSMark Fasheh 	}
6115dcd0538fSMark Fasheh 
6116ccd979bdSMark Fasheh 	eb = (struct ocfs2_extent_block *) bh->b_data;
6117ccd979bdSMark Fasheh 	el = &eb->h_list;
6118ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
6119ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
6120dcd0538fSMark Fasheh 		ret = -EROFS;
6121dcd0538fSMark Fasheh 		goto out;
6122ccd979bdSMark Fasheh 	}
6123ccd979bdSMark Fasheh 
6124ccd979bdSMark Fasheh 	*new_last_eb = bh;
6125ccd979bdSMark Fasheh 	get_bh(*new_last_eb);
6126dcd0538fSMark Fasheh 	mlog(0, "returning block %llu, (cpos: %u)\n",
6127dcd0538fSMark Fasheh 	     (unsigned long long)le64_to_cpu(eb->h_blkno), cpos);
6128dcd0538fSMark Fasheh out:
6129ccd979bdSMark Fasheh 	brelse(bh);
6130ccd979bdSMark Fasheh 
6131dcd0538fSMark Fasheh 	return ret;
6132ccd979bdSMark Fasheh }
6133ccd979bdSMark Fasheh 
61343a0782d0SMark Fasheh /*
61353a0782d0SMark Fasheh  * Trim some clusters off the rightmost edge of a tree. Only called
61363a0782d0SMark Fasheh  * during truncate.
61373a0782d0SMark Fasheh  *
61383a0782d0SMark Fasheh  * The caller needs to:
61393a0782d0SMark Fasheh  *   - start journaling of each path component.
61403a0782d0SMark Fasheh  *   - compute and fully set up any new last ext block
61413a0782d0SMark Fasheh  */
61423a0782d0SMark Fasheh static int ocfs2_trim_tree(struct inode *inode, struct ocfs2_path *path,
61433a0782d0SMark Fasheh 			   handle_t *handle, struct ocfs2_truncate_context *tc,
61443a0782d0SMark Fasheh 			   u32 clusters_to_del, u64 *delete_start)
61453a0782d0SMark Fasheh {
61463a0782d0SMark Fasheh 	int ret, i, index = path->p_tree_depth;
61473a0782d0SMark Fasheh 	u32 new_edge = 0;
61483a0782d0SMark Fasheh 	u64 deleted_eb = 0;
61493a0782d0SMark Fasheh 	struct buffer_head *bh;
61503a0782d0SMark Fasheh 	struct ocfs2_extent_list *el;
61513a0782d0SMark Fasheh 	struct ocfs2_extent_rec *rec;
61523a0782d0SMark Fasheh 
61533a0782d0SMark Fasheh 	*delete_start = 0;
61543a0782d0SMark Fasheh 
61553a0782d0SMark Fasheh 	while (index >= 0) {
61563a0782d0SMark Fasheh 		bh = path->p_node[index].bh;
61573a0782d0SMark Fasheh 		el = path->p_node[index].el;
61583a0782d0SMark Fasheh 
61593a0782d0SMark Fasheh 		mlog(0, "traveling tree (index = %d, block = %llu)\n",
61603a0782d0SMark Fasheh 		     index,  (unsigned long long)bh->b_blocknr);
61613a0782d0SMark Fasheh 
61623a0782d0SMark Fasheh 		BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
61633a0782d0SMark Fasheh 
61643a0782d0SMark Fasheh 		if (index !=
61653a0782d0SMark Fasheh 		    (path->p_tree_depth - le16_to_cpu(el->l_tree_depth))) {
61663a0782d0SMark Fasheh 			ocfs2_error(inode->i_sb,
61673a0782d0SMark Fasheh 				    "Inode %lu has invalid ext. block %llu",
61683a0782d0SMark Fasheh 				    inode->i_ino,
61693a0782d0SMark Fasheh 				    (unsigned long long)bh->b_blocknr);
61703a0782d0SMark Fasheh 			ret = -EROFS;
61713a0782d0SMark Fasheh 			goto out;
61723a0782d0SMark Fasheh 		}
61733a0782d0SMark Fasheh 
61743a0782d0SMark Fasheh find_tail_record:
61753a0782d0SMark Fasheh 		i = le16_to_cpu(el->l_next_free_rec) - 1;
61763a0782d0SMark Fasheh 		rec = &el->l_recs[i];
61773a0782d0SMark Fasheh 
61783a0782d0SMark Fasheh 		mlog(0, "Extent list before: record %d: (%u, %u, %llu), "
61793a0782d0SMark Fasheh 		     "next = %u\n", i, le32_to_cpu(rec->e_cpos),
6180e48edee2SMark Fasheh 		     ocfs2_rec_clusters(el, rec),
61813a0782d0SMark Fasheh 		     (unsigned long long)le64_to_cpu(rec->e_blkno),
61823a0782d0SMark Fasheh 		     le16_to_cpu(el->l_next_free_rec));
61833a0782d0SMark Fasheh 
6184e48edee2SMark Fasheh 		BUG_ON(ocfs2_rec_clusters(el, rec) < clusters_to_del);
61853a0782d0SMark Fasheh 
61863a0782d0SMark Fasheh 		if (le16_to_cpu(el->l_tree_depth) == 0) {
61873a0782d0SMark Fasheh 			/*
61883a0782d0SMark Fasheh 			 * If the leaf block contains a single empty
61893a0782d0SMark Fasheh 			 * extent and no records, we can just remove
61903a0782d0SMark Fasheh 			 * the block.
61913a0782d0SMark Fasheh 			 */
61923a0782d0SMark Fasheh 			if (i == 0 && ocfs2_is_empty_extent(rec)) {
61933a0782d0SMark Fasheh 				memset(rec, 0,
61943a0782d0SMark Fasheh 				       sizeof(struct ocfs2_extent_rec));
61953a0782d0SMark Fasheh 				el->l_next_free_rec = cpu_to_le16(0);
61963a0782d0SMark Fasheh 
61973a0782d0SMark Fasheh 				goto delete;
61983a0782d0SMark Fasheh 			}
61993a0782d0SMark Fasheh 
62003a0782d0SMark Fasheh 			/*
62013a0782d0SMark Fasheh 			 * Remove any empty extents by shifting things
62023a0782d0SMark Fasheh 			 * left. That should make life much easier on
62033a0782d0SMark Fasheh 			 * the code below. This condition is rare
62043a0782d0SMark Fasheh 			 * enough that we shouldn't see a performance
62053a0782d0SMark Fasheh 			 * hit.
62063a0782d0SMark Fasheh 			 */
62073a0782d0SMark Fasheh 			if (ocfs2_is_empty_extent(&el->l_recs[0])) {
62083a0782d0SMark Fasheh 				le16_add_cpu(&el->l_next_free_rec, -1);
62093a0782d0SMark Fasheh 
62103a0782d0SMark Fasheh 				for(i = 0;
62113a0782d0SMark Fasheh 				    i < le16_to_cpu(el->l_next_free_rec); i++)
62123a0782d0SMark Fasheh 					el->l_recs[i] = el->l_recs[i + 1];
62133a0782d0SMark Fasheh 
62143a0782d0SMark Fasheh 				memset(&el->l_recs[i], 0,
62153a0782d0SMark Fasheh 				       sizeof(struct ocfs2_extent_rec));
62163a0782d0SMark Fasheh 
62173a0782d0SMark Fasheh 				/*
62183a0782d0SMark Fasheh 				 * We've modified our extent list. The
62193a0782d0SMark Fasheh 				 * simplest way to handle this change
62203a0782d0SMark Fasheh 				 * is to being the search from the
62213a0782d0SMark Fasheh 				 * start again.
62223a0782d0SMark Fasheh 				 */
62233a0782d0SMark Fasheh 				goto find_tail_record;
62243a0782d0SMark Fasheh 			}
62253a0782d0SMark Fasheh 
6226e48edee2SMark Fasheh 			le16_add_cpu(&rec->e_leaf_clusters, -clusters_to_del);
62273a0782d0SMark Fasheh 
62283a0782d0SMark Fasheh 			/*
62293a0782d0SMark Fasheh 			 * We'll use "new_edge" on our way back up the
62303a0782d0SMark Fasheh 			 * tree to know what our rightmost cpos is.
62313a0782d0SMark Fasheh 			 */
6232e48edee2SMark Fasheh 			new_edge = le16_to_cpu(rec->e_leaf_clusters);
62333a0782d0SMark Fasheh 			new_edge += le32_to_cpu(rec->e_cpos);
62343a0782d0SMark Fasheh 
62353a0782d0SMark Fasheh 			/*
62363a0782d0SMark Fasheh 			 * The caller will use this to delete data blocks.
62373a0782d0SMark Fasheh 			 */
62383a0782d0SMark Fasheh 			*delete_start = le64_to_cpu(rec->e_blkno)
62393a0782d0SMark Fasheh 				+ ocfs2_clusters_to_blocks(inode->i_sb,
6240e48edee2SMark Fasheh 					le16_to_cpu(rec->e_leaf_clusters));
62413a0782d0SMark Fasheh 
62423a0782d0SMark Fasheh 			/*
62433a0782d0SMark Fasheh 			 * If it's now empty, remove this record.
62443a0782d0SMark Fasheh 			 */
6245e48edee2SMark Fasheh 			if (le16_to_cpu(rec->e_leaf_clusters) == 0) {
62463a0782d0SMark Fasheh 				memset(rec, 0,
62473a0782d0SMark Fasheh 				       sizeof(struct ocfs2_extent_rec));
62483a0782d0SMark Fasheh 				le16_add_cpu(&el->l_next_free_rec, -1);
62493a0782d0SMark Fasheh 			}
62503a0782d0SMark Fasheh 		} else {
62513a0782d0SMark Fasheh 			if (le64_to_cpu(rec->e_blkno) == deleted_eb) {
62523a0782d0SMark Fasheh 				memset(rec, 0,
62533a0782d0SMark Fasheh 				       sizeof(struct ocfs2_extent_rec));
62543a0782d0SMark Fasheh 				le16_add_cpu(&el->l_next_free_rec, -1);
62553a0782d0SMark Fasheh 
62563a0782d0SMark Fasheh 				goto delete;
62573a0782d0SMark Fasheh 			}
62583a0782d0SMark Fasheh 
62593a0782d0SMark Fasheh 			/* Can this actually happen? */
62603a0782d0SMark Fasheh 			if (le16_to_cpu(el->l_next_free_rec) == 0)
62613a0782d0SMark Fasheh 				goto delete;
62623a0782d0SMark Fasheh 
62633a0782d0SMark Fasheh 			/*
62643a0782d0SMark Fasheh 			 * We never actually deleted any clusters
62653a0782d0SMark Fasheh 			 * because our leaf was empty. There's no
62663a0782d0SMark Fasheh 			 * reason to adjust the rightmost edge then.
62673a0782d0SMark Fasheh 			 */
62683a0782d0SMark Fasheh 			if (new_edge == 0)
62693a0782d0SMark Fasheh 				goto delete;
62703a0782d0SMark Fasheh 
6271e48edee2SMark Fasheh 			rec->e_int_clusters = cpu_to_le32(new_edge);
6272e48edee2SMark Fasheh 			le32_add_cpu(&rec->e_int_clusters,
62733a0782d0SMark Fasheh 				     -le32_to_cpu(rec->e_cpos));
62743a0782d0SMark Fasheh 
62753a0782d0SMark Fasheh 			 /*
62763a0782d0SMark Fasheh 			  * A deleted child record should have been
62773a0782d0SMark Fasheh 			  * caught above.
62783a0782d0SMark Fasheh 			  */
6279e48edee2SMark Fasheh 			 BUG_ON(le32_to_cpu(rec->e_int_clusters) == 0);
62803a0782d0SMark Fasheh 		}
62813a0782d0SMark Fasheh 
62823a0782d0SMark Fasheh delete:
62833a0782d0SMark Fasheh 		ret = ocfs2_journal_dirty(handle, bh);
62843a0782d0SMark Fasheh 		if (ret) {
62853a0782d0SMark Fasheh 			mlog_errno(ret);
62863a0782d0SMark Fasheh 			goto out;
62873a0782d0SMark Fasheh 		}
62883a0782d0SMark Fasheh 
62893a0782d0SMark Fasheh 		mlog(0, "extent list container %llu, after: record %d: "
62903a0782d0SMark Fasheh 		     "(%u, %u, %llu), next = %u.\n",
62913a0782d0SMark Fasheh 		     (unsigned long long)bh->b_blocknr, i,
6292e48edee2SMark Fasheh 		     le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec),
62933a0782d0SMark Fasheh 		     (unsigned long long)le64_to_cpu(rec->e_blkno),
62943a0782d0SMark Fasheh 		     le16_to_cpu(el->l_next_free_rec));
62953a0782d0SMark Fasheh 
62963a0782d0SMark Fasheh 		/*
62973a0782d0SMark Fasheh 		 * We must be careful to only attempt delete of an
62983a0782d0SMark Fasheh 		 * extent block (and not the root inode block).
62993a0782d0SMark Fasheh 		 */
63003a0782d0SMark Fasheh 		if (index > 0 && le16_to_cpu(el->l_next_free_rec) == 0) {
63013a0782d0SMark Fasheh 			struct ocfs2_extent_block *eb =
63023a0782d0SMark Fasheh 				(struct ocfs2_extent_block *)bh->b_data;
63033a0782d0SMark Fasheh 
63043a0782d0SMark Fasheh 			/*
63053a0782d0SMark Fasheh 			 * Save this for use when processing the
63063a0782d0SMark Fasheh 			 * parent block.
63073a0782d0SMark Fasheh 			 */
63083a0782d0SMark Fasheh 			deleted_eb = le64_to_cpu(eb->h_blkno);
63093a0782d0SMark Fasheh 
63103a0782d0SMark Fasheh 			mlog(0, "deleting this extent block.\n");
63113a0782d0SMark Fasheh 
63123a0782d0SMark Fasheh 			ocfs2_remove_from_cache(inode, bh);
63133a0782d0SMark Fasheh 
6314e48edee2SMark Fasheh 			BUG_ON(ocfs2_rec_clusters(el, &el->l_recs[0]));
63153a0782d0SMark Fasheh 			BUG_ON(le32_to_cpu(el->l_recs[0].e_cpos));
63163a0782d0SMark Fasheh 			BUG_ON(le64_to_cpu(el->l_recs[0].e_blkno));
63173a0782d0SMark Fasheh 
631859a5e416SMark Fasheh 			ret = ocfs2_cache_extent_block_free(&tc->tc_dealloc, eb);
63193a0782d0SMark Fasheh 			/* An error here is not fatal. */
63203a0782d0SMark Fasheh 			if (ret < 0)
63213a0782d0SMark Fasheh 				mlog_errno(ret);
63223a0782d0SMark Fasheh 		} else {
63233a0782d0SMark Fasheh 			deleted_eb = 0;
63243a0782d0SMark Fasheh 		}
63253a0782d0SMark Fasheh 
63263a0782d0SMark Fasheh 		index--;
63273a0782d0SMark Fasheh 	}
63283a0782d0SMark Fasheh 
63293a0782d0SMark Fasheh 	ret = 0;
63303a0782d0SMark Fasheh out:
63313a0782d0SMark Fasheh 	return ret;
63323a0782d0SMark Fasheh }
63333a0782d0SMark Fasheh 
6334ccd979bdSMark Fasheh static int ocfs2_do_truncate(struct ocfs2_super *osb,
6335ccd979bdSMark Fasheh 			     unsigned int clusters_to_del,
6336ccd979bdSMark Fasheh 			     struct inode *inode,
6337ccd979bdSMark Fasheh 			     struct buffer_head *fe_bh,
63381fabe148SMark Fasheh 			     handle_t *handle,
6339dcd0538fSMark Fasheh 			     struct ocfs2_truncate_context *tc,
6340dcd0538fSMark Fasheh 			     struct ocfs2_path *path)
6341ccd979bdSMark Fasheh {
63423a0782d0SMark Fasheh 	int status;
6343ccd979bdSMark Fasheh 	struct ocfs2_dinode *fe;
6344ccd979bdSMark Fasheh 	struct ocfs2_extent_block *last_eb = NULL;
6345ccd979bdSMark Fasheh 	struct ocfs2_extent_list *el;
6346ccd979bdSMark Fasheh 	struct buffer_head *last_eb_bh = NULL;
6347ccd979bdSMark Fasheh 	u64 delete_blk = 0;
6348ccd979bdSMark Fasheh 
6349ccd979bdSMark Fasheh 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
6350ccd979bdSMark Fasheh 
63513a0782d0SMark Fasheh 	status = ocfs2_find_new_last_ext_blk(inode, clusters_to_del,
6352dcd0538fSMark Fasheh 					     path, &last_eb_bh);
6353ccd979bdSMark Fasheh 	if (status < 0) {
6354ccd979bdSMark Fasheh 		mlog_errno(status);
6355ccd979bdSMark Fasheh 		goto bail;
6356ccd979bdSMark Fasheh 	}
6357ccd979bdSMark Fasheh 
6358dcd0538fSMark Fasheh 	/*
6359dcd0538fSMark Fasheh 	 * Each component will be touched, so we might as well journal
6360dcd0538fSMark Fasheh 	 * here to avoid having to handle errors later.
6361dcd0538fSMark Fasheh 	 */
63623a0782d0SMark Fasheh 	status = ocfs2_journal_access_path(inode, handle, path);
6363ccd979bdSMark Fasheh 	if (status < 0) {
6364ccd979bdSMark Fasheh 		mlog_errno(status);
6365ccd979bdSMark Fasheh 		goto bail;
6366ccd979bdSMark Fasheh 	}
6367dcd0538fSMark Fasheh 
6368dcd0538fSMark Fasheh 	if (last_eb_bh) {
6369dcd0538fSMark Fasheh 		status = ocfs2_journal_access(handle, inode, last_eb_bh,
6370dcd0538fSMark Fasheh 					      OCFS2_JOURNAL_ACCESS_WRITE);
6371dcd0538fSMark Fasheh 		if (status < 0) {
6372dcd0538fSMark Fasheh 			mlog_errno(status);
6373dcd0538fSMark Fasheh 			goto bail;
6374dcd0538fSMark Fasheh 		}
6375dcd0538fSMark Fasheh 
6376dcd0538fSMark Fasheh 		last_eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
6377dcd0538fSMark Fasheh 	}
6378dcd0538fSMark Fasheh 
6379ccd979bdSMark Fasheh 	el = &(fe->id2.i_list);
6380ccd979bdSMark Fasheh 
6381dcd0538fSMark Fasheh 	/*
6382dcd0538fSMark Fasheh 	 * Lower levels depend on this never happening, but it's best
6383dcd0538fSMark Fasheh 	 * to check it up here before changing the tree.
6384dcd0538fSMark Fasheh 	 */
6385e48edee2SMark Fasheh 	if (el->l_tree_depth && el->l_recs[0].e_int_clusters == 0) {
6386dcd0538fSMark Fasheh 		ocfs2_error(inode->i_sb,
6387dcd0538fSMark Fasheh 			    "Inode %lu has an empty extent record, depth %u\n",
6388dcd0538fSMark Fasheh 			    inode->i_ino, le16_to_cpu(el->l_tree_depth));
63893a0782d0SMark Fasheh 		status = -EROFS;
6390dcd0538fSMark Fasheh 		goto bail;
6391dcd0538fSMark Fasheh 	}
6392dcd0538fSMark Fasheh 
6393ccd979bdSMark Fasheh 	spin_lock(&OCFS2_I(inode)->ip_lock);
6394ccd979bdSMark Fasheh 	OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters) -
6395ccd979bdSMark Fasheh 				      clusters_to_del;
6396ccd979bdSMark Fasheh 	spin_unlock(&OCFS2_I(inode)->ip_lock);
6397ccd979bdSMark Fasheh 	le32_add_cpu(&fe->i_clusters, -clusters_to_del);
6398e535e2efSMark Fasheh 	inode->i_blocks = ocfs2_inode_sector_count(inode);
6399ccd979bdSMark Fasheh 
64003a0782d0SMark Fasheh 	status = ocfs2_trim_tree(inode, path, handle, tc,
64013a0782d0SMark Fasheh 				 clusters_to_del, &delete_blk);
64023a0782d0SMark Fasheh 	if (status) {
64033a0782d0SMark Fasheh 		mlog_errno(status);
64043a0782d0SMark Fasheh 		goto bail;
6405ccd979bdSMark Fasheh 	}
6406ccd979bdSMark Fasheh 
6407dcd0538fSMark Fasheh 	if (le32_to_cpu(fe->i_clusters) == 0) {
6408ccd979bdSMark Fasheh 		/* trunc to zero is a special case. */
6409ccd979bdSMark Fasheh 		el->l_tree_depth = 0;
6410ccd979bdSMark Fasheh 		fe->i_last_eb_blk = 0;
6411ccd979bdSMark Fasheh 	} else if (last_eb)
6412ccd979bdSMark Fasheh 		fe->i_last_eb_blk = last_eb->h_blkno;
6413ccd979bdSMark Fasheh 
6414ccd979bdSMark Fasheh 	status = ocfs2_journal_dirty(handle, fe_bh);
6415ccd979bdSMark Fasheh 	if (status < 0) {
6416ccd979bdSMark Fasheh 		mlog_errno(status);
6417ccd979bdSMark Fasheh 		goto bail;
6418ccd979bdSMark Fasheh 	}
6419ccd979bdSMark Fasheh 
6420ccd979bdSMark Fasheh 	if (last_eb) {
6421ccd979bdSMark Fasheh 		/* If there will be a new last extent block, then by
6422ccd979bdSMark Fasheh 		 * definition, there cannot be any leaves to the right of
6423ccd979bdSMark Fasheh 		 * him. */
6424ccd979bdSMark Fasheh 		last_eb->h_next_leaf_blk = 0;
6425ccd979bdSMark Fasheh 		status = ocfs2_journal_dirty(handle, last_eb_bh);
6426ccd979bdSMark Fasheh 		if (status < 0) {
6427ccd979bdSMark Fasheh 			mlog_errno(status);
6428ccd979bdSMark Fasheh 			goto bail;
6429ccd979bdSMark Fasheh 		}
6430ccd979bdSMark Fasheh 	}
6431ccd979bdSMark Fasheh 
64323a0782d0SMark Fasheh 	if (delete_blk) {
6433ccd979bdSMark Fasheh 		status = ocfs2_truncate_log_append(osb, handle, delete_blk,
6434ccd979bdSMark Fasheh 						   clusters_to_del);
6435ccd979bdSMark Fasheh 		if (status < 0) {
6436ccd979bdSMark Fasheh 			mlog_errno(status);
6437ccd979bdSMark Fasheh 			goto bail;
6438ccd979bdSMark Fasheh 		}
64393a0782d0SMark Fasheh 	}
6440ccd979bdSMark Fasheh 	status = 0;
6441ccd979bdSMark Fasheh bail:
6442dcd0538fSMark Fasheh 
6443ccd979bdSMark Fasheh 	mlog_exit(status);
6444ccd979bdSMark Fasheh 	return status;
6445ccd979bdSMark Fasheh }
6446ccd979bdSMark Fasheh 
644760b11392SMark Fasheh static int ocfs2_writeback_zero_func(handle_t *handle, struct buffer_head *bh)
644860b11392SMark Fasheh {
644960b11392SMark Fasheh 	set_buffer_uptodate(bh);
645060b11392SMark Fasheh 	mark_buffer_dirty(bh);
645160b11392SMark Fasheh 	return 0;
645260b11392SMark Fasheh }
645360b11392SMark Fasheh 
645460b11392SMark Fasheh static int ocfs2_ordered_zero_func(handle_t *handle, struct buffer_head *bh)
645560b11392SMark Fasheh {
645660b11392SMark Fasheh 	set_buffer_uptodate(bh);
645760b11392SMark Fasheh 	mark_buffer_dirty(bh);
645860b11392SMark Fasheh 	return ocfs2_journal_dirty_data(handle, bh);
645960b11392SMark Fasheh }
646060b11392SMark Fasheh 
64611d410a6eSMark Fasheh static void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle,
64621d410a6eSMark Fasheh 				     unsigned int from, unsigned int to,
64631d410a6eSMark Fasheh 				     struct page *page, int zero, u64 *phys)
646460b11392SMark Fasheh {
64651d410a6eSMark Fasheh 	int ret, partial = 0;
646660b11392SMark Fasheh 
64671d410a6eSMark Fasheh 	ret = ocfs2_map_page_blocks(page, phys, inode, from, to, 0);
646860b11392SMark Fasheh 	if (ret)
646960b11392SMark Fasheh 		mlog_errno(ret);
647060b11392SMark Fasheh 
64711d410a6eSMark Fasheh 	if (zero)
6472eebd2aa3SChristoph Lameter 		zero_user_segment(page, from, to);
647360b11392SMark Fasheh 
647460b11392SMark Fasheh 	/*
647560b11392SMark Fasheh 	 * Need to set the buffers we zero'd into uptodate
647660b11392SMark Fasheh 	 * here if they aren't - ocfs2_map_page_blocks()
647760b11392SMark Fasheh 	 * might've skipped some
647860b11392SMark Fasheh 	 */
647960b11392SMark Fasheh 	if (ocfs2_should_order_data(inode)) {
648060b11392SMark Fasheh 		ret = walk_page_buffers(handle,
648160b11392SMark Fasheh 					page_buffers(page),
648260b11392SMark Fasheh 					from, to, &partial,
648360b11392SMark Fasheh 					ocfs2_ordered_zero_func);
648460b11392SMark Fasheh 		if (ret < 0)
648560b11392SMark Fasheh 			mlog_errno(ret);
648660b11392SMark Fasheh 	} else {
648760b11392SMark Fasheh 		ret = walk_page_buffers(handle, page_buffers(page),
648860b11392SMark Fasheh 					from, to, &partial,
648960b11392SMark Fasheh 					ocfs2_writeback_zero_func);
649060b11392SMark Fasheh 		if (ret < 0)
649160b11392SMark Fasheh 			mlog_errno(ret);
649260b11392SMark Fasheh 	}
649360b11392SMark Fasheh 
649460b11392SMark Fasheh 	if (!partial)
649560b11392SMark Fasheh 		SetPageUptodate(page);
649660b11392SMark Fasheh 
649760b11392SMark Fasheh 	flush_dcache_page(page);
64981d410a6eSMark Fasheh }
64991d410a6eSMark Fasheh 
65001d410a6eSMark Fasheh static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t start,
65011d410a6eSMark Fasheh 				     loff_t end, struct page **pages,
65021d410a6eSMark Fasheh 				     int numpages, u64 phys, handle_t *handle)
65031d410a6eSMark Fasheh {
65041d410a6eSMark Fasheh 	int i;
65051d410a6eSMark Fasheh 	struct page *page;
65061d410a6eSMark Fasheh 	unsigned int from, to = PAGE_CACHE_SIZE;
65071d410a6eSMark Fasheh 	struct super_block *sb = inode->i_sb;
65081d410a6eSMark Fasheh 
65091d410a6eSMark Fasheh 	BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(sb)));
65101d410a6eSMark Fasheh 
65111d410a6eSMark Fasheh 	if (numpages == 0)
65121d410a6eSMark Fasheh 		goto out;
65131d410a6eSMark Fasheh 
65141d410a6eSMark Fasheh 	to = PAGE_CACHE_SIZE;
65151d410a6eSMark Fasheh 	for(i = 0; i < numpages; i++) {
65161d410a6eSMark Fasheh 		page = pages[i];
65171d410a6eSMark Fasheh 
65181d410a6eSMark Fasheh 		from = start & (PAGE_CACHE_SIZE - 1);
65191d410a6eSMark Fasheh 		if ((end >> PAGE_CACHE_SHIFT) == page->index)
65201d410a6eSMark Fasheh 			to = end & (PAGE_CACHE_SIZE - 1);
65211d410a6eSMark Fasheh 
65221d410a6eSMark Fasheh 		BUG_ON(from > PAGE_CACHE_SIZE);
65231d410a6eSMark Fasheh 		BUG_ON(to > PAGE_CACHE_SIZE);
65241d410a6eSMark Fasheh 
65251d410a6eSMark Fasheh 		ocfs2_map_and_dirty_page(inode, handle, from, to, page, 1,
65261d410a6eSMark Fasheh 					 &phys);
652760b11392SMark Fasheh 
652835edec1dSMark Fasheh 		start = (page->index + 1) << PAGE_CACHE_SHIFT;
652960b11392SMark Fasheh 	}
653060b11392SMark Fasheh out:
65311d410a6eSMark Fasheh 	if (pages)
65321d410a6eSMark Fasheh 		ocfs2_unlock_and_free_pages(pages, numpages);
653360b11392SMark Fasheh }
653460b11392SMark Fasheh 
653535edec1dSMark Fasheh static int ocfs2_grab_eof_pages(struct inode *inode, loff_t start, loff_t end,
65361d410a6eSMark Fasheh 				struct page **pages, int *num)
653760b11392SMark Fasheh {
65381d410a6eSMark Fasheh 	int numpages, ret = 0;
653960b11392SMark Fasheh 	struct super_block *sb = inode->i_sb;
654060b11392SMark Fasheh 	struct address_space *mapping = inode->i_mapping;
654160b11392SMark Fasheh 	unsigned long index;
654235edec1dSMark Fasheh 	loff_t last_page_bytes;
654360b11392SMark Fasheh 
654435edec1dSMark Fasheh 	BUG_ON(start > end);
654560b11392SMark Fasheh 
654635edec1dSMark Fasheh 	BUG_ON(start >> OCFS2_SB(sb)->s_clustersize_bits !=
654735edec1dSMark Fasheh 	       (end - 1) >> OCFS2_SB(sb)->s_clustersize_bits);
654835edec1dSMark Fasheh 
65491d410a6eSMark Fasheh 	numpages = 0;
655035edec1dSMark Fasheh 	last_page_bytes = PAGE_ALIGN(end);
655135edec1dSMark Fasheh 	index = start >> PAGE_CACHE_SHIFT;
655260b11392SMark Fasheh 	do {
655360b11392SMark Fasheh 		pages[numpages] = grab_cache_page(mapping, index);
655460b11392SMark Fasheh 		if (!pages[numpages]) {
655560b11392SMark Fasheh 			ret = -ENOMEM;
655660b11392SMark Fasheh 			mlog_errno(ret);
655760b11392SMark Fasheh 			goto out;
655860b11392SMark Fasheh 		}
655960b11392SMark Fasheh 
656060b11392SMark Fasheh 		numpages++;
656160b11392SMark Fasheh 		index++;
656235edec1dSMark Fasheh 	} while (index < (last_page_bytes >> PAGE_CACHE_SHIFT));
656360b11392SMark Fasheh 
656460b11392SMark Fasheh out:
656560b11392SMark Fasheh 	if (ret != 0) {
65661d410a6eSMark Fasheh 		if (pages)
65671d410a6eSMark Fasheh 			ocfs2_unlock_and_free_pages(pages, numpages);
656860b11392SMark Fasheh 		numpages = 0;
656960b11392SMark Fasheh 	}
657060b11392SMark Fasheh 
657160b11392SMark Fasheh 	*num = numpages;
657260b11392SMark Fasheh 
657360b11392SMark Fasheh 	return ret;
657460b11392SMark Fasheh }
657560b11392SMark Fasheh 
657660b11392SMark Fasheh /*
657760b11392SMark Fasheh  * Zero the area past i_size but still within an allocated
657860b11392SMark Fasheh  * cluster. This avoids exposing nonzero data on subsequent file
657960b11392SMark Fasheh  * extends.
658060b11392SMark Fasheh  *
658160b11392SMark Fasheh  * We need to call this before i_size is updated on the inode because
658260b11392SMark Fasheh  * otherwise block_write_full_page() will skip writeout of pages past
658360b11392SMark Fasheh  * i_size. The new_i_size parameter is passed for this reason.
658460b11392SMark Fasheh  */
658535edec1dSMark Fasheh int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle,
658635edec1dSMark Fasheh 				  u64 range_start, u64 range_end)
658760b11392SMark Fasheh {
65881d410a6eSMark Fasheh 	int ret = 0, numpages;
658960b11392SMark Fasheh 	struct page **pages = NULL;
659060b11392SMark Fasheh 	u64 phys;
65911d410a6eSMark Fasheh 	unsigned int ext_flags;
65921d410a6eSMark Fasheh 	struct super_block *sb = inode->i_sb;
659360b11392SMark Fasheh 
659460b11392SMark Fasheh 	/*
659560b11392SMark Fasheh 	 * File systems which don't support sparse files zero on every
659660b11392SMark Fasheh 	 * extend.
659760b11392SMark Fasheh 	 */
65981d410a6eSMark Fasheh 	if (!ocfs2_sparse_alloc(OCFS2_SB(sb)))
659960b11392SMark Fasheh 		return 0;
660060b11392SMark Fasheh 
66011d410a6eSMark Fasheh 	pages = kcalloc(ocfs2_pages_per_cluster(sb),
660260b11392SMark Fasheh 			sizeof(struct page *), GFP_NOFS);
660360b11392SMark Fasheh 	if (pages == NULL) {
660460b11392SMark Fasheh 		ret = -ENOMEM;
660560b11392SMark Fasheh 		mlog_errno(ret);
660660b11392SMark Fasheh 		goto out;
660760b11392SMark Fasheh 	}
660860b11392SMark Fasheh 
66091d410a6eSMark Fasheh 	if (range_start == range_end)
66101d410a6eSMark Fasheh 		goto out;
66111d410a6eSMark Fasheh 
66121d410a6eSMark Fasheh 	ret = ocfs2_extent_map_get_blocks(inode,
66131d410a6eSMark Fasheh 					  range_start >> sb->s_blocksize_bits,
66141d410a6eSMark Fasheh 					  &phys, NULL, &ext_flags);
661560b11392SMark Fasheh 	if (ret) {
661660b11392SMark Fasheh 		mlog_errno(ret);
661760b11392SMark Fasheh 		goto out;
661860b11392SMark Fasheh 	}
661960b11392SMark Fasheh 
66201d410a6eSMark Fasheh 	/*
66211d410a6eSMark Fasheh 	 * Tail is a hole, or is marked unwritten. In either case, we
66221d410a6eSMark Fasheh 	 * can count on read and write to return/push zero's.
66231d410a6eSMark Fasheh 	 */
66241d410a6eSMark Fasheh 	if (phys == 0 || ext_flags & OCFS2_EXT_UNWRITTEN)
662560b11392SMark Fasheh 		goto out;
662660b11392SMark Fasheh 
66271d410a6eSMark Fasheh 	ret = ocfs2_grab_eof_pages(inode, range_start, range_end, pages,
66281d410a6eSMark Fasheh 				   &numpages);
66291d410a6eSMark Fasheh 	if (ret) {
66301d410a6eSMark Fasheh 		mlog_errno(ret);
66311d410a6eSMark Fasheh 		goto out;
66321d410a6eSMark Fasheh 	}
66331d410a6eSMark Fasheh 
663435edec1dSMark Fasheh 	ocfs2_zero_cluster_pages(inode, range_start, range_end, pages,
663535edec1dSMark Fasheh 				 numpages, phys, handle);
663660b11392SMark Fasheh 
663760b11392SMark Fasheh 	/*
663860b11392SMark Fasheh 	 * Initiate writeout of the pages we zero'd here. We don't
663960b11392SMark Fasheh 	 * wait on them - the truncate_inode_pages() call later will
664060b11392SMark Fasheh 	 * do that for us.
664160b11392SMark Fasheh 	 */
664235edec1dSMark Fasheh 	ret = do_sync_mapping_range(inode->i_mapping, range_start,
664335edec1dSMark Fasheh 				    range_end - 1, SYNC_FILE_RANGE_WRITE);
664460b11392SMark Fasheh 	if (ret)
664560b11392SMark Fasheh 		mlog_errno(ret);
664660b11392SMark Fasheh 
664760b11392SMark Fasheh out:
664860b11392SMark Fasheh 	if (pages)
664960b11392SMark Fasheh 		kfree(pages);
665060b11392SMark Fasheh 
665160b11392SMark Fasheh 	return ret;
665260b11392SMark Fasheh }
665360b11392SMark Fasheh 
6654fdd77704STiger Yang static void ocfs2_zero_dinode_id2_with_xattr(struct inode *inode,
6655fdd77704STiger Yang 					     struct ocfs2_dinode *di)
66561afc32b9SMark Fasheh {
66571afc32b9SMark Fasheh 	unsigned int blocksize = 1 << inode->i_sb->s_blocksize_bits;
6658fdd77704STiger Yang 	unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size);
66591afc32b9SMark Fasheh 
6660fdd77704STiger Yang 	if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL)
6661fdd77704STiger Yang 		memset(&di->id2, 0, blocksize -
6662fdd77704STiger Yang 				    offsetof(struct ocfs2_dinode, id2) -
6663fdd77704STiger Yang 				    xattrsize);
6664fdd77704STiger Yang 	else
6665fdd77704STiger Yang 		memset(&di->id2, 0, blocksize -
6666fdd77704STiger Yang 				    offsetof(struct ocfs2_dinode, id2));
66671afc32b9SMark Fasheh }
66681afc32b9SMark Fasheh 
66695b6a3a2bSMark Fasheh void ocfs2_dinode_new_extent_list(struct inode *inode,
66705b6a3a2bSMark Fasheh 				  struct ocfs2_dinode *di)
66715b6a3a2bSMark Fasheh {
6672fdd77704STiger Yang 	ocfs2_zero_dinode_id2_with_xattr(inode, di);
66735b6a3a2bSMark Fasheh 	di->id2.i_list.l_tree_depth = 0;
66745b6a3a2bSMark Fasheh 	di->id2.i_list.l_next_free_rec = 0;
6675fdd77704STiger Yang 	di->id2.i_list.l_count = cpu_to_le16(
6676fdd77704STiger Yang 		ocfs2_extent_recs_per_inode_with_xattr(inode->i_sb, di));
66775b6a3a2bSMark Fasheh }
66785b6a3a2bSMark Fasheh 
66791afc32b9SMark Fasheh void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di)
66801afc32b9SMark Fasheh {
66811afc32b9SMark Fasheh 	struct ocfs2_inode_info *oi = OCFS2_I(inode);
66821afc32b9SMark Fasheh 	struct ocfs2_inline_data *idata = &di->id2.i_data;
66831afc32b9SMark Fasheh 
66841afc32b9SMark Fasheh 	spin_lock(&oi->ip_lock);
66851afc32b9SMark Fasheh 	oi->ip_dyn_features |= OCFS2_INLINE_DATA_FL;
66861afc32b9SMark Fasheh 	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
66871afc32b9SMark Fasheh 	spin_unlock(&oi->ip_lock);
66881afc32b9SMark Fasheh 
66891afc32b9SMark Fasheh 	/*
66901afc32b9SMark Fasheh 	 * We clear the entire i_data structure here so that all
66911afc32b9SMark Fasheh 	 * fields can be properly initialized.
66921afc32b9SMark Fasheh 	 */
6693fdd77704STiger Yang 	ocfs2_zero_dinode_id2_with_xattr(inode, di);
66941afc32b9SMark Fasheh 
6695fdd77704STiger Yang 	idata->id_count = cpu_to_le16(
6696fdd77704STiger Yang 			ocfs2_max_inline_data_with_xattr(inode->i_sb, di));
66971afc32b9SMark Fasheh }
66981afc32b9SMark Fasheh 
66991afc32b9SMark Fasheh int ocfs2_convert_inline_data_to_extents(struct inode *inode,
67001afc32b9SMark Fasheh 					 struct buffer_head *di_bh)
67011afc32b9SMark Fasheh {
67021afc32b9SMark Fasheh 	int ret, i, has_data, num_pages = 0;
67031afc32b9SMark Fasheh 	handle_t *handle;
67041afc32b9SMark Fasheh 	u64 uninitialized_var(block);
67051afc32b9SMark Fasheh 	struct ocfs2_inode_info *oi = OCFS2_I(inode);
67061afc32b9SMark Fasheh 	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
67071afc32b9SMark Fasheh 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
67081afc32b9SMark Fasheh 	struct ocfs2_alloc_context *data_ac = NULL;
67091afc32b9SMark Fasheh 	struct page **pages = NULL;
67101afc32b9SMark Fasheh 	loff_t end = osb->s_clustersize;
67111afc32b9SMark Fasheh 
67121afc32b9SMark Fasheh 	has_data = i_size_read(inode) ? 1 : 0;
67131afc32b9SMark Fasheh 
67141afc32b9SMark Fasheh 	if (has_data) {
67151afc32b9SMark Fasheh 		pages = kcalloc(ocfs2_pages_per_cluster(osb->sb),
67161afc32b9SMark Fasheh 				sizeof(struct page *), GFP_NOFS);
67171afc32b9SMark Fasheh 		if (pages == NULL) {
67181afc32b9SMark Fasheh 			ret = -ENOMEM;
67191afc32b9SMark Fasheh 			mlog_errno(ret);
67201afc32b9SMark Fasheh 			goto out;
67211afc32b9SMark Fasheh 		}
67221afc32b9SMark Fasheh 
67231afc32b9SMark Fasheh 		ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
67241afc32b9SMark Fasheh 		if (ret) {
67251afc32b9SMark Fasheh 			mlog_errno(ret);
67261afc32b9SMark Fasheh 			goto out;
67271afc32b9SMark Fasheh 		}
67281afc32b9SMark Fasheh 	}
67291afc32b9SMark Fasheh 
67301afc32b9SMark Fasheh 	handle = ocfs2_start_trans(osb, OCFS2_INLINE_TO_EXTENTS_CREDITS);
67311afc32b9SMark Fasheh 	if (IS_ERR(handle)) {
67321afc32b9SMark Fasheh 		ret = PTR_ERR(handle);
67331afc32b9SMark Fasheh 		mlog_errno(ret);
67341afc32b9SMark Fasheh 		goto out_unlock;
67351afc32b9SMark Fasheh 	}
67361afc32b9SMark Fasheh 
67371afc32b9SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, di_bh,
67381afc32b9SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
67391afc32b9SMark Fasheh 	if (ret) {
67401afc32b9SMark Fasheh 		mlog_errno(ret);
67411afc32b9SMark Fasheh 		goto out_commit;
67421afc32b9SMark Fasheh 	}
67431afc32b9SMark Fasheh 
67441afc32b9SMark Fasheh 	if (has_data) {
67451afc32b9SMark Fasheh 		u32 bit_off, num;
67461afc32b9SMark Fasheh 		unsigned int page_end;
67471afc32b9SMark Fasheh 		u64 phys;
67481afc32b9SMark Fasheh 
67491afc32b9SMark Fasheh 		ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off,
67501afc32b9SMark Fasheh 					   &num);
67511afc32b9SMark Fasheh 		if (ret) {
67521afc32b9SMark Fasheh 			mlog_errno(ret);
67531afc32b9SMark Fasheh 			goto out_commit;
67541afc32b9SMark Fasheh 		}
67551afc32b9SMark Fasheh 
67561afc32b9SMark Fasheh 		/*
67571afc32b9SMark Fasheh 		 * Save two copies, one for insert, and one that can
67581afc32b9SMark Fasheh 		 * be changed by ocfs2_map_and_dirty_page() below.
67591afc32b9SMark Fasheh 		 */
67601afc32b9SMark Fasheh 		block = phys = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
67611afc32b9SMark Fasheh 
67621afc32b9SMark Fasheh 		/*
67631afc32b9SMark Fasheh 		 * Non sparse file systems zero on extend, so no need
67641afc32b9SMark Fasheh 		 * to do that now.
67651afc32b9SMark Fasheh 		 */
67661afc32b9SMark Fasheh 		if (!ocfs2_sparse_alloc(osb) &&
67671afc32b9SMark Fasheh 		    PAGE_CACHE_SIZE < osb->s_clustersize)
67681afc32b9SMark Fasheh 			end = PAGE_CACHE_SIZE;
67691afc32b9SMark Fasheh 
67701afc32b9SMark Fasheh 		ret = ocfs2_grab_eof_pages(inode, 0, end, pages, &num_pages);
67711afc32b9SMark Fasheh 		if (ret) {
67721afc32b9SMark Fasheh 			mlog_errno(ret);
67731afc32b9SMark Fasheh 			goto out_commit;
67741afc32b9SMark Fasheh 		}
67751afc32b9SMark Fasheh 
67761afc32b9SMark Fasheh 		/*
67771afc32b9SMark Fasheh 		 * This should populate the 1st page for us and mark
67781afc32b9SMark Fasheh 		 * it up to date.
67791afc32b9SMark Fasheh 		 */
67801afc32b9SMark Fasheh 		ret = ocfs2_read_inline_data(inode, pages[0], di_bh);
67811afc32b9SMark Fasheh 		if (ret) {
67821afc32b9SMark Fasheh 			mlog_errno(ret);
67831afc32b9SMark Fasheh 			goto out_commit;
67841afc32b9SMark Fasheh 		}
67851afc32b9SMark Fasheh 
67861afc32b9SMark Fasheh 		page_end = PAGE_CACHE_SIZE;
67871afc32b9SMark Fasheh 		if (PAGE_CACHE_SIZE > osb->s_clustersize)
67881afc32b9SMark Fasheh 			page_end = osb->s_clustersize;
67891afc32b9SMark Fasheh 
67901afc32b9SMark Fasheh 		for (i = 0; i < num_pages; i++)
67911afc32b9SMark Fasheh 			ocfs2_map_and_dirty_page(inode, handle, 0, page_end,
67921afc32b9SMark Fasheh 						 pages[i], i > 0, &phys);
67931afc32b9SMark Fasheh 	}
67941afc32b9SMark Fasheh 
67951afc32b9SMark Fasheh 	spin_lock(&oi->ip_lock);
67961afc32b9SMark Fasheh 	oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL;
67971afc32b9SMark Fasheh 	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
67981afc32b9SMark Fasheh 	spin_unlock(&oi->ip_lock);
67991afc32b9SMark Fasheh 
68005b6a3a2bSMark Fasheh 	ocfs2_dinode_new_extent_list(inode, di);
68011afc32b9SMark Fasheh 
68021afc32b9SMark Fasheh 	ocfs2_journal_dirty(handle, di_bh);
68031afc32b9SMark Fasheh 
68041afc32b9SMark Fasheh 	if (has_data) {
68051afc32b9SMark Fasheh 		/*
68061afc32b9SMark Fasheh 		 * An error at this point should be extremely rare. If
68071afc32b9SMark Fasheh 		 * this proves to be false, we could always re-build
68081afc32b9SMark Fasheh 		 * the in-inode data from our pages.
68091afc32b9SMark Fasheh 		 */
6810f56654c4STao Ma 		ret = ocfs2_dinode_insert_extent(osb, handle, inode, di_bh,
6811f56654c4STao Ma 						 0, block, 1, 0, NULL);
68121afc32b9SMark Fasheh 		if (ret) {
68131afc32b9SMark Fasheh 			mlog_errno(ret);
68141afc32b9SMark Fasheh 			goto out_commit;
68151afc32b9SMark Fasheh 		}
68161afc32b9SMark Fasheh 
68171afc32b9SMark Fasheh 		inode->i_blocks = ocfs2_inode_sector_count(inode);
68181afc32b9SMark Fasheh 	}
68191afc32b9SMark Fasheh 
68201afc32b9SMark Fasheh out_commit:
68211afc32b9SMark Fasheh 	ocfs2_commit_trans(osb, handle);
68221afc32b9SMark Fasheh 
68231afc32b9SMark Fasheh out_unlock:
68241afc32b9SMark Fasheh 	if (data_ac)
68251afc32b9SMark Fasheh 		ocfs2_free_alloc_context(data_ac);
68261afc32b9SMark Fasheh 
68271afc32b9SMark Fasheh out:
68281afc32b9SMark Fasheh 	if (pages) {
68291afc32b9SMark Fasheh 		ocfs2_unlock_and_free_pages(pages, num_pages);
68301afc32b9SMark Fasheh 		kfree(pages);
68311afc32b9SMark Fasheh 	}
68321afc32b9SMark Fasheh 
68331afc32b9SMark Fasheh 	return ret;
68341afc32b9SMark Fasheh }
68351afc32b9SMark Fasheh 
6836ccd979bdSMark Fasheh /*
6837ccd979bdSMark Fasheh  * It is expected, that by the time you call this function,
6838ccd979bdSMark Fasheh  * inode->i_size and fe->i_size have been adjusted.
6839ccd979bdSMark Fasheh  *
6840ccd979bdSMark Fasheh  * WARNING: This will kfree the truncate context
6841ccd979bdSMark Fasheh  */
6842ccd979bdSMark Fasheh int ocfs2_commit_truncate(struct ocfs2_super *osb,
6843ccd979bdSMark Fasheh 			  struct inode *inode,
6844ccd979bdSMark Fasheh 			  struct buffer_head *fe_bh,
6845ccd979bdSMark Fasheh 			  struct ocfs2_truncate_context *tc)
6846ccd979bdSMark Fasheh {
6847ccd979bdSMark Fasheh 	int status, i, credits, tl_sem = 0;
6848dcd0538fSMark Fasheh 	u32 clusters_to_del, new_highest_cpos, range;
6849ccd979bdSMark Fasheh 	struct ocfs2_extent_list *el;
68501fabe148SMark Fasheh 	handle_t *handle = NULL;
6851ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
6852dcd0538fSMark Fasheh 	struct ocfs2_path *path = NULL;
6853e7d4cb6bSTao Ma 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)fe_bh->b_data;
6854ccd979bdSMark Fasheh 
6855ccd979bdSMark Fasheh 	mlog_entry_void();
6856ccd979bdSMark Fasheh 
6857dcd0538fSMark Fasheh 	new_highest_cpos = ocfs2_clusters_for_bytes(osb->sb,
6858ccd979bdSMark Fasheh 						     i_size_read(inode));
6859ccd979bdSMark Fasheh 
6860e7d4cb6bSTao Ma 	path = ocfs2_new_path(fe_bh, &di->id2.i_list);
6861dcd0538fSMark Fasheh 	if (!path) {
6862dcd0538fSMark Fasheh 		status = -ENOMEM;
6863ccd979bdSMark Fasheh 		mlog_errno(status);
6864ccd979bdSMark Fasheh 		goto bail;
6865ccd979bdSMark Fasheh 	}
686683418978SMark Fasheh 
686783418978SMark Fasheh 	ocfs2_extent_map_trunc(inode, new_highest_cpos);
686883418978SMark Fasheh 
6869dcd0538fSMark Fasheh start:
6870dcd0538fSMark Fasheh 	/*
68713a0782d0SMark Fasheh 	 * Check that we still have allocation to delete.
68723a0782d0SMark Fasheh 	 */
68733a0782d0SMark Fasheh 	if (OCFS2_I(inode)->ip_clusters == 0) {
68743a0782d0SMark Fasheh 		status = 0;
68753a0782d0SMark Fasheh 		goto bail;
68763a0782d0SMark Fasheh 	}
68773a0782d0SMark Fasheh 
68783a0782d0SMark Fasheh 	/*
6879dcd0538fSMark Fasheh 	 * Truncate always works against the rightmost tree branch.
6880dcd0538fSMark Fasheh 	 */
6881dcd0538fSMark Fasheh 	status = ocfs2_find_path(inode, path, UINT_MAX);
6882dcd0538fSMark Fasheh 	if (status) {
6883dcd0538fSMark Fasheh 		mlog_errno(status);
6884ccd979bdSMark Fasheh 		goto bail;
6885ccd979bdSMark Fasheh 	}
6886ccd979bdSMark Fasheh 
6887dcd0538fSMark Fasheh 	mlog(0, "inode->ip_clusters = %u, tree_depth = %u\n",
6888dcd0538fSMark Fasheh 	     OCFS2_I(inode)->ip_clusters, path->p_tree_depth);
6889dcd0538fSMark Fasheh 
6890dcd0538fSMark Fasheh 	/*
6891dcd0538fSMark Fasheh 	 * By now, el will point to the extent list on the bottom most
6892dcd0538fSMark Fasheh 	 * portion of this tree. Only the tail record is considered in
6893dcd0538fSMark Fasheh 	 * each pass.
6894dcd0538fSMark Fasheh 	 *
6895dcd0538fSMark Fasheh 	 * We handle the following cases, in order:
6896dcd0538fSMark Fasheh 	 * - empty extent: delete the remaining branch
6897dcd0538fSMark Fasheh 	 * - remove the entire record
6898dcd0538fSMark Fasheh 	 * - remove a partial record
6899dcd0538fSMark Fasheh 	 * - no record needs to be removed (truncate has completed)
6900dcd0538fSMark Fasheh 	 */
6901dcd0538fSMark Fasheh 	el = path_leaf_el(path);
69023a0782d0SMark Fasheh 	if (le16_to_cpu(el->l_next_free_rec) == 0) {
69033a0782d0SMark Fasheh 		ocfs2_error(inode->i_sb,
69043a0782d0SMark Fasheh 			    "Inode %llu has empty extent block at %llu\n",
69053a0782d0SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
69063a0782d0SMark Fasheh 			    (unsigned long long)path_leaf_bh(path)->b_blocknr);
69073a0782d0SMark Fasheh 		status = -EROFS;
69083a0782d0SMark Fasheh 		goto bail;
69093a0782d0SMark Fasheh 	}
69103a0782d0SMark Fasheh 
6911ccd979bdSMark Fasheh 	i = le16_to_cpu(el->l_next_free_rec) - 1;
6912dcd0538fSMark Fasheh 	range = le32_to_cpu(el->l_recs[i].e_cpos) +
6913e48edee2SMark Fasheh 		ocfs2_rec_clusters(el, &el->l_recs[i]);
6914dcd0538fSMark Fasheh 	if (i == 0 && ocfs2_is_empty_extent(&el->l_recs[i])) {
6915dcd0538fSMark Fasheh 		clusters_to_del = 0;
6916dcd0538fSMark Fasheh 	} else if (le32_to_cpu(el->l_recs[i].e_cpos) >= new_highest_cpos) {
6917e48edee2SMark Fasheh 		clusters_to_del = ocfs2_rec_clusters(el, &el->l_recs[i]);
6918dcd0538fSMark Fasheh 	} else if (range > new_highest_cpos) {
6919e48edee2SMark Fasheh 		clusters_to_del = (ocfs2_rec_clusters(el, &el->l_recs[i]) +
6920ccd979bdSMark Fasheh 				   le32_to_cpu(el->l_recs[i].e_cpos)) -
6921dcd0538fSMark Fasheh 				  new_highest_cpos;
6922dcd0538fSMark Fasheh 	} else {
6923dcd0538fSMark Fasheh 		status = 0;
6924dcd0538fSMark Fasheh 		goto bail;
6925dcd0538fSMark Fasheh 	}
6926ccd979bdSMark Fasheh 
6927dcd0538fSMark Fasheh 	mlog(0, "clusters_to_del = %u in this pass, tail blk=%llu\n",
6928dcd0538fSMark Fasheh 	     clusters_to_del, (unsigned long long)path_leaf_bh(path)->b_blocknr);
6929dcd0538fSMark Fasheh 
69301b1dcc1bSJes Sorensen 	mutex_lock(&tl_inode->i_mutex);
6931ccd979bdSMark Fasheh 	tl_sem = 1;
6932ccd979bdSMark Fasheh 	/* ocfs2_truncate_log_needs_flush guarantees us at least one
6933ccd979bdSMark Fasheh 	 * record is free for use. If there isn't any, we flush to get
6934ccd979bdSMark Fasheh 	 * an empty truncate log.  */
6935ccd979bdSMark Fasheh 	if (ocfs2_truncate_log_needs_flush(osb)) {
6936ccd979bdSMark Fasheh 		status = __ocfs2_flush_truncate_log(osb);
6937ccd979bdSMark Fasheh 		if (status < 0) {
6938ccd979bdSMark Fasheh 			mlog_errno(status);
6939ccd979bdSMark Fasheh 			goto bail;
6940ccd979bdSMark Fasheh 		}
6941ccd979bdSMark Fasheh 	}
6942ccd979bdSMark Fasheh 
6943ccd979bdSMark Fasheh 	credits = ocfs2_calc_tree_trunc_credits(osb->sb, clusters_to_del,
6944dcd0538fSMark Fasheh 						(struct ocfs2_dinode *)fe_bh->b_data,
6945dcd0538fSMark Fasheh 						el);
694665eff9ccSMark Fasheh 	handle = ocfs2_start_trans(osb, credits);
6947ccd979bdSMark Fasheh 	if (IS_ERR(handle)) {
6948ccd979bdSMark Fasheh 		status = PTR_ERR(handle);
6949ccd979bdSMark Fasheh 		handle = NULL;
6950ccd979bdSMark Fasheh 		mlog_errno(status);
6951ccd979bdSMark Fasheh 		goto bail;
6952ccd979bdSMark Fasheh 	}
6953ccd979bdSMark Fasheh 
6954dcd0538fSMark Fasheh 	status = ocfs2_do_truncate(osb, clusters_to_del, inode, fe_bh, handle,
6955dcd0538fSMark Fasheh 				   tc, path);
6956ccd979bdSMark Fasheh 	if (status < 0) {
6957ccd979bdSMark Fasheh 		mlog_errno(status);
6958ccd979bdSMark Fasheh 		goto bail;
6959ccd979bdSMark Fasheh 	}
6960ccd979bdSMark Fasheh 
69611b1dcc1bSJes Sorensen 	mutex_unlock(&tl_inode->i_mutex);
6962ccd979bdSMark Fasheh 	tl_sem = 0;
6963ccd979bdSMark Fasheh 
696402dc1af4SMark Fasheh 	ocfs2_commit_trans(osb, handle);
6965ccd979bdSMark Fasheh 	handle = NULL;
6966ccd979bdSMark Fasheh 
6967dcd0538fSMark Fasheh 	ocfs2_reinit_path(path, 1);
6968dcd0538fSMark Fasheh 
6969dcd0538fSMark Fasheh 	/*
69703a0782d0SMark Fasheh 	 * The check above will catch the case where we've truncated
69713a0782d0SMark Fasheh 	 * away all allocation.
6972dcd0538fSMark Fasheh 	 */
6973ccd979bdSMark Fasheh 	goto start;
69743a0782d0SMark Fasheh 
6975ccd979bdSMark Fasheh bail:
6976ccd979bdSMark Fasheh 
6977ccd979bdSMark Fasheh 	ocfs2_schedule_truncate_log_flush(osb, 1);
6978ccd979bdSMark Fasheh 
6979ccd979bdSMark Fasheh 	if (tl_sem)
69801b1dcc1bSJes Sorensen 		mutex_unlock(&tl_inode->i_mutex);
6981ccd979bdSMark Fasheh 
6982ccd979bdSMark Fasheh 	if (handle)
698302dc1af4SMark Fasheh 		ocfs2_commit_trans(osb, handle);
6984ccd979bdSMark Fasheh 
698559a5e416SMark Fasheh 	ocfs2_run_deallocs(osb, &tc->tc_dealloc);
698659a5e416SMark Fasheh 
6987dcd0538fSMark Fasheh 	ocfs2_free_path(path);
6988ccd979bdSMark Fasheh 
6989ccd979bdSMark Fasheh 	/* This will drop the ext_alloc cluster lock for us */
6990ccd979bdSMark Fasheh 	ocfs2_free_truncate_context(tc);
6991ccd979bdSMark Fasheh 
6992ccd979bdSMark Fasheh 	mlog_exit(status);
6993ccd979bdSMark Fasheh 	return status;
6994ccd979bdSMark Fasheh }
6995ccd979bdSMark Fasheh 
6996ccd979bdSMark Fasheh /*
699759a5e416SMark Fasheh  * Expects the inode to already be locked.
6998ccd979bdSMark Fasheh  */
6999ccd979bdSMark Fasheh int ocfs2_prepare_truncate(struct ocfs2_super *osb,
7000ccd979bdSMark Fasheh 			   struct inode *inode,
7001ccd979bdSMark Fasheh 			   struct buffer_head *fe_bh,
7002ccd979bdSMark Fasheh 			   struct ocfs2_truncate_context **tc)
7003ccd979bdSMark Fasheh {
700459a5e416SMark Fasheh 	int status;
7005ccd979bdSMark Fasheh 	unsigned int new_i_clusters;
7006ccd979bdSMark Fasheh 	struct ocfs2_dinode *fe;
7007ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
7008ccd979bdSMark Fasheh 	struct buffer_head *last_eb_bh = NULL;
7009ccd979bdSMark Fasheh 
7010ccd979bdSMark Fasheh 	mlog_entry_void();
7011ccd979bdSMark Fasheh 
7012ccd979bdSMark Fasheh 	*tc = NULL;
7013ccd979bdSMark Fasheh 
7014ccd979bdSMark Fasheh 	new_i_clusters = ocfs2_clusters_for_bytes(osb->sb,
7015ccd979bdSMark Fasheh 						  i_size_read(inode));
7016ccd979bdSMark Fasheh 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
7017ccd979bdSMark Fasheh 
7018ccd979bdSMark Fasheh 	mlog(0, "fe->i_clusters = %u, new_i_clusters = %u, fe->i_size ="
70191ca1a111SMark Fasheh 	     "%llu\n", le32_to_cpu(fe->i_clusters), new_i_clusters,
70201ca1a111SMark Fasheh 	     (unsigned long long)le64_to_cpu(fe->i_size));
7021ccd979bdSMark Fasheh 
7022cd861280SRobert P. J. Day 	*tc = kzalloc(sizeof(struct ocfs2_truncate_context), GFP_KERNEL);
7023ccd979bdSMark Fasheh 	if (!(*tc)) {
7024ccd979bdSMark Fasheh 		status = -ENOMEM;
7025ccd979bdSMark Fasheh 		mlog_errno(status);
7026ccd979bdSMark Fasheh 		goto bail;
7027ccd979bdSMark Fasheh 	}
702859a5e416SMark Fasheh 	ocfs2_init_dealloc_ctxt(&(*tc)->tc_dealloc);
7029ccd979bdSMark Fasheh 
7030ccd979bdSMark Fasheh 	if (fe->id2.i_list.l_tree_depth) {
7031ccd979bdSMark Fasheh 		status = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk),
7032ccd979bdSMark Fasheh 					  &last_eb_bh, OCFS2_BH_CACHED, inode);
7033ccd979bdSMark Fasheh 		if (status < 0) {
7034ccd979bdSMark Fasheh 			mlog_errno(status);
7035ccd979bdSMark Fasheh 			goto bail;
7036ccd979bdSMark Fasheh 		}
7037ccd979bdSMark Fasheh 		eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
7038ccd979bdSMark Fasheh 		if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
7039ccd979bdSMark Fasheh 			OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
7040ccd979bdSMark Fasheh 
7041ccd979bdSMark Fasheh 			brelse(last_eb_bh);
7042ccd979bdSMark Fasheh 			status = -EIO;
7043ccd979bdSMark Fasheh 			goto bail;
7044ccd979bdSMark Fasheh 		}
7045ccd979bdSMark Fasheh 	}
7046ccd979bdSMark Fasheh 
7047ccd979bdSMark Fasheh 	(*tc)->tc_last_eb_bh = last_eb_bh;
7048ccd979bdSMark Fasheh 
7049ccd979bdSMark Fasheh 	status = 0;
7050ccd979bdSMark Fasheh bail:
7051ccd979bdSMark Fasheh 	if (status < 0) {
7052ccd979bdSMark Fasheh 		if (*tc)
7053ccd979bdSMark Fasheh 			ocfs2_free_truncate_context(*tc);
7054ccd979bdSMark Fasheh 		*tc = NULL;
7055ccd979bdSMark Fasheh 	}
7056ccd979bdSMark Fasheh 	mlog_exit_void();
7057ccd979bdSMark Fasheh 	return status;
7058ccd979bdSMark Fasheh }
7059ccd979bdSMark Fasheh 
70601afc32b9SMark Fasheh /*
70611afc32b9SMark Fasheh  * 'start' is inclusive, 'end' is not.
70621afc32b9SMark Fasheh  */
70631afc32b9SMark Fasheh int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh,
70641afc32b9SMark Fasheh 			  unsigned int start, unsigned int end, int trunc)
70651afc32b9SMark Fasheh {
70661afc32b9SMark Fasheh 	int ret;
70671afc32b9SMark Fasheh 	unsigned int numbytes;
70681afc32b9SMark Fasheh 	handle_t *handle;
70691afc32b9SMark Fasheh 	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
70701afc32b9SMark Fasheh 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
70711afc32b9SMark Fasheh 	struct ocfs2_inline_data *idata = &di->id2.i_data;
70721afc32b9SMark Fasheh 
70731afc32b9SMark Fasheh 	if (end > i_size_read(inode))
70741afc32b9SMark Fasheh 		end = i_size_read(inode);
70751afc32b9SMark Fasheh 
70761afc32b9SMark Fasheh 	BUG_ON(start >= end);
70771afc32b9SMark Fasheh 
70781afc32b9SMark Fasheh 	if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) ||
70791afc32b9SMark Fasheh 	    !(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL) ||
70801afc32b9SMark Fasheh 	    !ocfs2_supports_inline_data(osb)) {
70811afc32b9SMark Fasheh 		ocfs2_error(inode->i_sb,
70821afc32b9SMark Fasheh 			    "Inline data flags for inode %llu don't agree! "
70831afc32b9SMark Fasheh 			    "Disk: 0x%x, Memory: 0x%x, Superblock: 0x%x\n",
70841afc32b9SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
70851afc32b9SMark Fasheh 			    le16_to_cpu(di->i_dyn_features),
70861afc32b9SMark Fasheh 			    OCFS2_I(inode)->ip_dyn_features,
70871afc32b9SMark Fasheh 			    osb->s_feature_incompat);
70881afc32b9SMark Fasheh 		ret = -EROFS;
70891afc32b9SMark Fasheh 		goto out;
70901afc32b9SMark Fasheh 	}
70911afc32b9SMark Fasheh 
70921afc32b9SMark Fasheh 	handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
70931afc32b9SMark Fasheh 	if (IS_ERR(handle)) {
70941afc32b9SMark Fasheh 		ret = PTR_ERR(handle);
70951afc32b9SMark Fasheh 		mlog_errno(ret);
70961afc32b9SMark Fasheh 		goto out;
70971afc32b9SMark Fasheh 	}
70981afc32b9SMark Fasheh 
70991afc32b9SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, di_bh,
71001afc32b9SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
71011afc32b9SMark Fasheh 	if (ret) {
71021afc32b9SMark Fasheh 		mlog_errno(ret);
71031afc32b9SMark Fasheh 		goto out_commit;
71041afc32b9SMark Fasheh 	}
71051afc32b9SMark Fasheh 
71061afc32b9SMark Fasheh 	numbytes = end - start;
71071afc32b9SMark Fasheh 	memset(idata->id_data + start, 0, numbytes);
71081afc32b9SMark Fasheh 
71091afc32b9SMark Fasheh 	/*
71101afc32b9SMark Fasheh 	 * No need to worry about the data page here - it's been
71111afc32b9SMark Fasheh 	 * truncated already and inline data doesn't need it for
71121afc32b9SMark Fasheh 	 * pushing zero's to disk, so we'll let readpage pick it up
71131afc32b9SMark Fasheh 	 * later.
71141afc32b9SMark Fasheh 	 */
71151afc32b9SMark Fasheh 	if (trunc) {
71161afc32b9SMark Fasheh 		i_size_write(inode, start);
71171afc32b9SMark Fasheh 		di->i_size = cpu_to_le64(start);
71181afc32b9SMark Fasheh 	}
71191afc32b9SMark Fasheh 
71201afc32b9SMark Fasheh 	inode->i_blocks = ocfs2_inode_sector_count(inode);
71211afc32b9SMark Fasheh 	inode->i_ctime = inode->i_mtime = CURRENT_TIME;
71221afc32b9SMark Fasheh 
71231afc32b9SMark Fasheh 	di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec);
71241afc32b9SMark Fasheh 	di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
71251afc32b9SMark Fasheh 
71261afc32b9SMark Fasheh 	ocfs2_journal_dirty(handle, di_bh);
71271afc32b9SMark Fasheh 
71281afc32b9SMark Fasheh out_commit:
71291afc32b9SMark Fasheh 	ocfs2_commit_trans(osb, handle);
71301afc32b9SMark Fasheh 
71311afc32b9SMark Fasheh out:
71321afc32b9SMark Fasheh 	return ret;
71331afc32b9SMark Fasheh }
71341afc32b9SMark Fasheh 
7135ccd979bdSMark Fasheh static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc)
7136ccd979bdSMark Fasheh {
713759a5e416SMark Fasheh 	/*
713859a5e416SMark Fasheh 	 * The caller is responsible for completing deallocation
713959a5e416SMark Fasheh 	 * before freeing the context.
714059a5e416SMark Fasheh 	 */
714159a5e416SMark Fasheh 	if (tc->tc_dealloc.c_first_suballocator != NULL)
714259a5e416SMark Fasheh 		mlog(ML_NOTICE,
714359a5e416SMark Fasheh 		     "Truncate completion has non-empty dealloc context\n");
7144ccd979bdSMark Fasheh 
7145ccd979bdSMark Fasheh 	if (tc->tc_last_eb_bh)
7146ccd979bdSMark Fasheh 		brelse(tc->tc_last_eb_bh);
7147ccd979bdSMark Fasheh 
7148ccd979bdSMark Fasheh 	kfree(tc);
7149ccd979bdSMark Fasheh }
7150