xref: /openbmc/linux/fs/ocfs2/alloc.c (revision b1f3550fa1471b691ad6c2f35b5b22e93eaa5855)
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 
52ccd979bdSMark Fasheh static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc);
5359a5e416SMark Fasheh static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
5459a5e416SMark Fasheh 					 struct ocfs2_extent_block *eb);
55ccd979bdSMark Fasheh 
56dcd0538fSMark Fasheh /*
57dcd0538fSMark Fasheh  * Structures which describe a path through a btree, and functions to
58dcd0538fSMark Fasheh  * manipulate them.
59dcd0538fSMark Fasheh  *
60dcd0538fSMark Fasheh  * The idea here is to be as generic as possible with the tree
61dcd0538fSMark Fasheh  * manipulation code.
62dcd0538fSMark Fasheh  */
63dcd0538fSMark Fasheh struct ocfs2_path_item {
64dcd0538fSMark Fasheh 	struct buffer_head		*bh;
65dcd0538fSMark Fasheh 	struct ocfs2_extent_list	*el;
66dcd0538fSMark Fasheh };
67dcd0538fSMark Fasheh 
68dcd0538fSMark Fasheh #define OCFS2_MAX_PATH_DEPTH	5
69dcd0538fSMark Fasheh 
70dcd0538fSMark Fasheh struct ocfs2_path {
71dcd0538fSMark Fasheh 	int			p_tree_depth;
72dcd0538fSMark Fasheh 	struct ocfs2_path_item	p_node[OCFS2_MAX_PATH_DEPTH];
73dcd0538fSMark Fasheh };
74dcd0538fSMark Fasheh 
75dcd0538fSMark Fasheh #define path_root_bh(_path) ((_path)->p_node[0].bh)
76dcd0538fSMark Fasheh #define path_root_el(_path) ((_path)->p_node[0].el)
77dcd0538fSMark Fasheh #define path_leaf_bh(_path) ((_path)->p_node[(_path)->p_tree_depth].bh)
78dcd0538fSMark Fasheh #define path_leaf_el(_path) ((_path)->p_node[(_path)->p_tree_depth].el)
79dcd0538fSMark Fasheh #define path_num_items(_path) ((_path)->p_tree_depth + 1)
80dcd0538fSMark Fasheh 
81dcd0538fSMark Fasheh /*
82dcd0538fSMark Fasheh  * Reset the actual path elements so that we can re-use the structure
83dcd0538fSMark Fasheh  * to build another path. Generally, this involves freeing the buffer
84dcd0538fSMark Fasheh  * heads.
85dcd0538fSMark Fasheh  */
86dcd0538fSMark Fasheh static void ocfs2_reinit_path(struct ocfs2_path *path, int keep_root)
87dcd0538fSMark Fasheh {
88dcd0538fSMark Fasheh 	int i, start = 0, depth = 0;
89dcd0538fSMark Fasheh 	struct ocfs2_path_item *node;
90dcd0538fSMark Fasheh 
91dcd0538fSMark Fasheh 	if (keep_root)
92dcd0538fSMark Fasheh 		start = 1;
93dcd0538fSMark Fasheh 
94dcd0538fSMark Fasheh 	for(i = start; i < path_num_items(path); i++) {
95dcd0538fSMark Fasheh 		node = &path->p_node[i];
96dcd0538fSMark Fasheh 
97dcd0538fSMark Fasheh 		brelse(node->bh);
98dcd0538fSMark Fasheh 		node->bh = NULL;
99dcd0538fSMark Fasheh 		node->el = NULL;
100dcd0538fSMark Fasheh 	}
101dcd0538fSMark Fasheh 
102dcd0538fSMark Fasheh 	/*
103dcd0538fSMark Fasheh 	 * Tree depth may change during truncate, or insert. If we're
104dcd0538fSMark Fasheh 	 * keeping the root extent list, then make sure that our path
105dcd0538fSMark Fasheh 	 * structure reflects the proper depth.
106dcd0538fSMark Fasheh 	 */
107dcd0538fSMark Fasheh 	if (keep_root)
108dcd0538fSMark Fasheh 		depth = le16_to_cpu(path_root_el(path)->l_tree_depth);
109dcd0538fSMark Fasheh 
110dcd0538fSMark Fasheh 	path->p_tree_depth = depth;
111dcd0538fSMark Fasheh }
112dcd0538fSMark Fasheh 
113dcd0538fSMark Fasheh static void ocfs2_free_path(struct ocfs2_path *path)
114dcd0538fSMark Fasheh {
115dcd0538fSMark Fasheh 	if (path) {
116dcd0538fSMark Fasheh 		ocfs2_reinit_path(path, 0);
117dcd0538fSMark Fasheh 		kfree(path);
118dcd0538fSMark Fasheh 	}
119dcd0538fSMark Fasheh }
120dcd0538fSMark Fasheh 
121dcd0538fSMark Fasheh /*
122328d5752SMark Fasheh  * All the elements of src into dest. After this call, src could be freed
123328d5752SMark Fasheh  * without affecting dest.
124328d5752SMark Fasheh  *
125328d5752SMark Fasheh  * Both paths should have the same root. Any non-root elements of dest
126328d5752SMark Fasheh  * will be freed.
127328d5752SMark Fasheh  */
128328d5752SMark Fasheh static void ocfs2_cp_path(struct ocfs2_path *dest, struct ocfs2_path *src)
129328d5752SMark Fasheh {
130328d5752SMark Fasheh 	int i;
131328d5752SMark Fasheh 
132328d5752SMark Fasheh 	BUG_ON(path_root_bh(dest) != path_root_bh(src));
133328d5752SMark Fasheh 	BUG_ON(path_root_el(dest) != path_root_el(src));
134328d5752SMark Fasheh 
135328d5752SMark Fasheh 	ocfs2_reinit_path(dest, 1);
136328d5752SMark Fasheh 
137328d5752SMark Fasheh 	for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
138328d5752SMark Fasheh 		dest->p_node[i].bh = src->p_node[i].bh;
139328d5752SMark Fasheh 		dest->p_node[i].el = src->p_node[i].el;
140328d5752SMark Fasheh 
141328d5752SMark Fasheh 		if (dest->p_node[i].bh)
142328d5752SMark Fasheh 			get_bh(dest->p_node[i].bh);
143328d5752SMark Fasheh 	}
144328d5752SMark Fasheh }
145328d5752SMark Fasheh 
146328d5752SMark Fasheh /*
147dcd0538fSMark Fasheh  * Make the *dest path the same as src and re-initialize src path to
148dcd0538fSMark Fasheh  * have a root only.
149dcd0538fSMark Fasheh  */
150dcd0538fSMark Fasheh static void ocfs2_mv_path(struct ocfs2_path *dest, struct ocfs2_path *src)
151dcd0538fSMark Fasheh {
152dcd0538fSMark Fasheh 	int i;
153dcd0538fSMark Fasheh 
154dcd0538fSMark Fasheh 	BUG_ON(path_root_bh(dest) != path_root_bh(src));
155dcd0538fSMark Fasheh 
156dcd0538fSMark Fasheh 	for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
157dcd0538fSMark Fasheh 		brelse(dest->p_node[i].bh);
158dcd0538fSMark Fasheh 
159dcd0538fSMark Fasheh 		dest->p_node[i].bh = src->p_node[i].bh;
160dcd0538fSMark Fasheh 		dest->p_node[i].el = src->p_node[i].el;
161dcd0538fSMark Fasheh 
162dcd0538fSMark Fasheh 		src->p_node[i].bh = NULL;
163dcd0538fSMark Fasheh 		src->p_node[i].el = NULL;
164dcd0538fSMark Fasheh 	}
165dcd0538fSMark Fasheh }
166dcd0538fSMark Fasheh 
167dcd0538fSMark Fasheh /*
168dcd0538fSMark Fasheh  * Insert an extent block at given index.
169dcd0538fSMark Fasheh  *
170dcd0538fSMark Fasheh  * This will not take an additional reference on eb_bh.
171dcd0538fSMark Fasheh  */
172dcd0538fSMark Fasheh static inline void ocfs2_path_insert_eb(struct ocfs2_path *path, int index,
173dcd0538fSMark Fasheh 					struct buffer_head *eb_bh)
174dcd0538fSMark Fasheh {
175dcd0538fSMark Fasheh 	struct ocfs2_extent_block *eb = (struct ocfs2_extent_block *)eb_bh->b_data;
176dcd0538fSMark Fasheh 
177dcd0538fSMark Fasheh 	/*
178dcd0538fSMark Fasheh 	 * Right now, no root bh is an extent block, so this helps
179dcd0538fSMark Fasheh 	 * catch code errors with dinode trees. The assertion can be
180dcd0538fSMark Fasheh 	 * safely removed if we ever need to insert extent block
181dcd0538fSMark Fasheh 	 * structures at the root.
182dcd0538fSMark Fasheh 	 */
183dcd0538fSMark Fasheh 	BUG_ON(index == 0);
184dcd0538fSMark Fasheh 
185dcd0538fSMark Fasheh 	path->p_node[index].bh = eb_bh;
186dcd0538fSMark Fasheh 	path->p_node[index].el = &eb->h_list;
187dcd0538fSMark Fasheh }
188dcd0538fSMark Fasheh 
189dcd0538fSMark Fasheh static struct ocfs2_path *ocfs2_new_path(struct buffer_head *root_bh,
190dcd0538fSMark Fasheh 					 struct ocfs2_extent_list *root_el)
191dcd0538fSMark Fasheh {
192dcd0538fSMark Fasheh 	struct ocfs2_path *path;
193dcd0538fSMark Fasheh 
194dcd0538fSMark Fasheh 	BUG_ON(le16_to_cpu(root_el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH);
195dcd0538fSMark Fasheh 
196dcd0538fSMark Fasheh 	path = kzalloc(sizeof(*path), GFP_NOFS);
197dcd0538fSMark Fasheh 	if (path) {
198dcd0538fSMark Fasheh 		path->p_tree_depth = le16_to_cpu(root_el->l_tree_depth);
199dcd0538fSMark Fasheh 		get_bh(root_bh);
200dcd0538fSMark Fasheh 		path_root_bh(path) = root_bh;
201dcd0538fSMark Fasheh 		path_root_el(path) = root_el;
202dcd0538fSMark Fasheh 	}
203dcd0538fSMark Fasheh 
204dcd0538fSMark Fasheh 	return path;
205dcd0538fSMark Fasheh }
206dcd0538fSMark Fasheh 
207dcd0538fSMark Fasheh /*
208dcd0538fSMark Fasheh  * Allocate and initialize a new path based on a disk inode tree.
209dcd0538fSMark Fasheh  */
210dcd0538fSMark Fasheh static struct ocfs2_path *ocfs2_new_inode_path(struct buffer_head *di_bh)
211dcd0538fSMark Fasheh {
212dcd0538fSMark Fasheh 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
213dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el = &di->id2.i_list;
214dcd0538fSMark Fasheh 
215dcd0538fSMark Fasheh 	return ocfs2_new_path(di_bh, el);
216dcd0538fSMark Fasheh }
217dcd0538fSMark Fasheh 
218dcd0538fSMark Fasheh /*
219dcd0538fSMark Fasheh  * Convenience function to journal all components in a path.
220dcd0538fSMark Fasheh  */
221dcd0538fSMark Fasheh static int ocfs2_journal_access_path(struct inode *inode, handle_t *handle,
222dcd0538fSMark Fasheh 				     struct ocfs2_path *path)
223dcd0538fSMark Fasheh {
224dcd0538fSMark Fasheh 	int i, ret = 0;
225dcd0538fSMark Fasheh 
226dcd0538fSMark Fasheh 	if (!path)
227dcd0538fSMark Fasheh 		goto out;
228dcd0538fSMark Fasheh 
229dcd0538fSMark Fasheh 	for(i = 0; i < path_num_items(path); i++) {
230dcd0538fSMark Fasheh 		ret = ocfs2_journal_access(handle, inode, path->p_node[i].bh,
231dcd0538fSMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
232dcd0538fSMark Fasheh 		if (ret < 0) {
233dcd0538fSMark Fasheh 			mlog_errno(ret);
234dcd0538fSMark Fasheh 			goto out;
235dcd0538fSMark Fasheh 		}
236dcd0538fSMark Fasheh 	}
237dcd0538fSMark Fasheh 
238dcd0538fSMark Fasheh out:
239dcd0538fSMark Fasheh 	return ret;
240dcd0538fSMark Fasheh }
241dcd0538fSMark Fasheh 
242328d5752SMark Fasheh /*
243328d5752SMark Fasheh  * Return the index of the extent record which contains cluster #v_cluster.
244328d5752SMark Fasheh  * -1 is returned if it was not found.
245328d5752SMark Fasheh  *
246328d5752SMark Fasheh  * Should work fine on interior and exterior nodes.
247328d5752SMark Fasheh  */
248328d5752SMark Fasheh int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster)
249328d5752SMark Fasheh {
250328d5752SMark Fasheh 	int ret = -1;
251328d5752SMark Fasheh 	int i;
252328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec;
253328d5752SMark Fasheh 	u32 rec_end, rec_start, clusters;
254328d5752SMark Fasheh 
255328d5752SMark Fasheh 	for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
256328d5752SMark Fasheh 		rec = &el->l_recs[i];
257328d5752SMark Fasheh 
258328d5752SMark Fasheh 		rec_start = le32_to_cpu(rec->e_cpos);
259328d5752SMark Fasheh 		clusters = ocfs2_rec_clusters(el, rec);
260328d5752SMark Fasheh 
261328d5752SMark Fasheh 		rec_end = rec_start + clusters;
262328d5752SMark Fasheh 
263328d5752SMark Fasheh 		if (v_cluster >= rec_start && v_cluster < rec_end) {
264328d5752SMark Fasheh 			ret = i;
265328d5752SMark Fasheh 			break;
266328d5752SMark Fasheh 		}
267328d5752SMark Fasheh 	}
268328d5752SMark Fasheh 
269328d5752SMark Fasheh 	return ret;
270328d5752SMark Fasheh }
271328d5752SMark Fasheh 
272dcd0538fSMark Fasheh enum ocfs2_contig_type {
273dcd0538fSMark Fasheh 	CONTIG_NONE = 0,
274dcd0538fSMark Fasheh 	CONTIG_LEFT,
275328d5752SMark Fasheh 	CONTIG_RIGHT,
276328d5752SMark Fasheh 	CONTIG_LEFTRIGHT,
277dcd0538fSMark Fasheh };
278dcd0538fSMark Fasheh 
279e48edee2SMark Fasheh 
280e48edee2SMark Fasheh /*
281e48edee2SMark Fasheh  * NOTE: ocfs2_block_extent_contig(), ocfs2_extents_adjacent() and
282e48edee2SMark Fasheh  * ocfs2_extent_contig only work properly against leaf nodes!
283e48edee2SMark Fasheh  */
284dcd0538fSMark Fasheh static int ocfs2_block_extent_contig(struct super_block *sb,
285ccd979bdSMark Fasheh 				     struct ocfs2_extent_rec *ext,
286ccd979bdSMark Fasheh 				     u64 blkno)
287ccd979bdSMark Fasheh {
288e48edee2SMark Fasheh 	u64 blk_end = le64_to_cpu(ext->e_blkno);
289e48edee2SMark Fasheh 
290e48edee2SMark Fasheh 	blk_end += ocfs2_clusters_to_blocks(sb,
291e48edee2SMark Fasheh 				    le16_to_cpu(ext->e_leaf_clusters));
292e48edee2SMark Fasheh 
293e48edee2SMark Fasheh 	return blkno == blk_end;
294ccd979bdSMark Fasheh }
295ccd979bdSMark Fasheh 
296dcd0538fSMark Fasheh static int ocfs2_extents_adjacent(struct ocfs2_extent_rec *left,
297dcd0538fSMark Fasheh 				  struct ocfs2_extent_rec *right)
298dcd0538fSMark Fasheh {
299e48edee2SMark Fasheh 	u32 left_range;
300e48edee2SMark Fasheh 
301e48edee2SMark Fasheh 	left_range = le32_to_cpu(left->e_cpos) +
302e48edee2SMark Fasheh 		le16_to_cpu(left->e_leaf_clusters);
303e48edee2SMark Fasheh 
304e48edee2SMark Fasheh 	return (left_range == le32_to_cpu(right->e_cpos));
305dcd0538fSMark Fasheh }
306dcd0538fSMark Fasheh 
307dcd0538fSMark Fasheh static enum ocfs2_contig_type
308dcd0538fSMark Fasheh 	ocfs2_extent_contig(struct inode *inode,
309dcd0538fSMark Fasheh 			    struct ocfs2_extent_rec *ext,
310dcd0538fSMark Fasheh 			    struct ocfs2_extent_rec *insert_rec)
311dcd0538fSMark Fasheh {
312dcd0538fSMark Fasheh 	u64 blkno = le64_to_cpu(insert_rec->e_blkno);
313dcd0538fSMark Fasheh 
314328d5752SMark Fasheh 	/*
315328d5752SMark Fasheh 	 * Refuse to coalesce extent records with different flag
316328d5752SMark Fasheh 	 * fields - we don't want to mix unwritten extents with user
317328d5752SMark Fasheh 	 * data.
318328d5752SMark Fasheh 	 */
319328d5752SMark Fasheh 	if (ext->e_flags != insert_rec->e_flags)
320328d5752SMark Fasheh 		return CONTIG_NONE;
321328d5752SMark Fasheh 
322dcd0538fSMark Fasheh 	if (ocfs2_extents_adjacent(ext, insert_rec) &&
323dcd0538fSMark Fasheh 	    ocfs2_block_extent_contig(inode->i_sb, ext, blkno))
324dcd0538fSMark Fasheh 			return CONTIG_RIGHT;
325dcd0538fSMark Fasheh 
326dcd0538fSMark Fasheh 	blkno = le64_to_cpu(ext->e_blkno);
327dcd0538fSMark Fasheh 	if (ocfs2_extents_adjacent(insert_rec, ext) &&
328dcd0538fSMark Fasheh 	    ocfs2_block_extent_contig(inode->i_sb, insert_rec, blkno))
329dcd0538fSMark Fasheh 		return CONTIG_LEFT;
330dcd0538fSMark Fasheh 
331dcd0538fSMark Fasheh 	return CONTIG_NONE;
332dcd0538fSMark Fasheh }
333dcd0538fSMark Fasheh 
334dcd0538fSMark Fasheh /*
335dcd0538fSMark Fasheh  * NOTE: We can have pretty much any combination of contiguousness and
336dcd0538fSMark Fasheh  * appending.
337dcd0538fSMark Fasheh  *
338dcd0538fSMark Fasheh  * The usefulness of APPEND_TAIL is more in that it lets us know that
339dcd0538fSMark Fasheh  * we'll have to update the path to that leaf.
340dcd0538fSMark Fasheh  */
341dcd0538fSMark Fasheh enum ocfs2_append_type {
342dcd0538fSMark Fasheh 	APPEND_NONE = 0,
343dcd0538fSMark Fasheh 	APPEND_TAIL,
344dcd0538fSMark Fasheh };
345dcd0538fSMark Fasheh 
346328d5752SMark Fasheh enum ocfs2_split_type {
347328d5752SMark Fasheh 	SPLIT_NONE = 0,
348328d5752SMark Fasheh 	SPLIT_LEFT,
349328d5752SMark Fasheh 	SPLIT_RIGHT,
350328d5752SMark Fasheh };
351328d5752SMark Fasheh 
352dcd0538fSMark Fasheh struct ocfs2_insert_type {
353328d5752SMark Fasheh 	enum ocfs2_split_type	ins_split;
354dcd0538fSMark Fasheh 	enum ocfs2_append_type	ins_appending;
355dcd0538fSMark Fasheh 	enum ocfs2_contig_type	ins_contig;
356dcd0538fSMark Fasheh 	int			ins_contig_index;
357dcd0538fSMark Fasheh 	int			ins_tree_depth;
358dcd0538fSMark Fasheh };
359dcd0538fSMark Fasheh 
360328d5752SMark Fasheh struct ocfs2_merge_ctxt {
361328d5752SMark Fasheh 	enum ocfs2_contig_type	c_contig_type;
362328d5752SMark Fasheh 	int			c_has_empty_extent;
363328d5752SMark Fasheh 	int			c_split_covers_rec;
364328d5752SMark Fasheh };
365328d5752SMark Fasheh 
366ccd979bdSMark Fasheh /*
367ccd979bdSMark Fasheh  * How many free extents have we got before we need more meta data?
368ccd979bdSMark Fasheh  */
369ccd979bdSMark Fasheh int ocfs2_num_free_extents(struct ocfs2_super *osb,
370ccd979bdSMark Fasheh 			   struct inode *inode,
371ccd979bdSMark Fasheh 			   struct ocfs2_dinode *fe)
372ccd979bdSMark Fasheh {
373ccd979bdSMark Fasheh 	int retval;
374ccd979bdSMark Fasheh 	struct ocfs2_extent_list *el;
375ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
376ccd979bdSMark Fasheh 	struct buffer_head *eb_bh = NULL;
377ccd979bdSMark Fasheh 
378ccd979bdSMark Fasheh 	mlog_entry_void();
379ccd979bdSMark Fasheh 
380ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_DINODE(fe)) {
381ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_DINODE(inode->i_sb, fe);
382ccd979bdSMark Fasheh 		retval = -EIO;
383ccd979bdSMark Fasheh 		goto bail;
384ccd979bdSMark Fasheh 	}
385ccd979bdSMark Fasheh 
386ccd979bdSMark Fasheh 	if (fe->i_last_eb_blk) {
387ccd979bdSMark Fasheh 		retval = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk),
388ccd979bdSMark Fasheh 					  &eb_bh, OCFS2_BH_CACHED, inode);
389ccd979bdSMark Fasheh 		if (retval < 0) {
390ccd979bdSMark Fasheh 			mlog_errno(retval);
391ccd979bdSMark Fasheh 			goto bail;
392ccd979bdSMark Fasheh 		}
393ccd979bdSMark Fasheh 		eb = (struct ocfs2_extent_block *) eb_bh->b_data;
394ccd979bdSMark Fasheh 		el = &eb->h_list;
395ccd979bdSMark Fasheh 	} else
396ccd979bdSMark Fasheh 		el = &fe->id2.i_list;
397ccd979bdSMark Fasheh 
398ccd979bdSMark Fasheh 	BUG_ON(el->l_tree_depth != 0);
399ccd979bdSMark Fasheh 
400ccd979bdSMark Fasheh 	retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec);
401ccd979bdSMark Fasheh bail:
402ccd979bdSMark Fasheh 	if (eb_bh)
403ccd979bdSMark Fasheh 		brelse(eb_bh);
404ccd979bdSMark Fasheh 
405ccd979bdSMark Fasheh 	mlog_exit(retval);
406ccd979bdSMark Fasheh 	return retval;
407ccd979bdSMark Fasheh }
408ccd979bdSMark Fasheh 
409ccd979bdSMark Fasheh /* expects array to already be allocated
410ccd979bdSMark Fasheh  *
411ccd979bdSMark Fasheh  * sets h_signature, h_blkno, h_suballoc_bit, h_suballoc_slot, and
412ccd979bdSMark Fasheh  * l_count for you
413ccd979bdSMark Fasheh  */
414ccd979bdSMark Fasheh static int ocfs2_create_new_meta_bhs(struct ocfs2_super *osb,
4151fabe148SMark Fasheh 				     handle_t *handle,
416ccd979bdSMark Fasheh 				     struct inode *inode,
417ccd979bdSMark Fasheh 				     int wanted,
418ccd979bdSMark Fasheh 				     struct ocfs2_alloc_context *meta_ac,
419ccd979bdSMark Fasheh 				     struct buffer_head *bhs[])
420ccd979bdSMark Fasheh {
421ccd979bdSMark Fasheh 	int count, status, i;
422ccd979bdSMark Fasheh 	u16 suballoc_bit_start;
423ccd979bdSMark Fasheh 	u32 num_got;
424ccd979bdSMark Fasheh 	u64 first_blkno;
425ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
426ccd979bdSMark Fasheh 
427ccd979bdSMark Fasheh 	mlog_entry_void();
428ccd979bdSMark Fasheh 
429ccd979bdSMark Fasheh 	count = 0;
430ccd979bdSMark Fasheh 	while (count < wanted) {
431ccd979bdSMark Fasheh 		status = ocfs2_claim_metadata(osb,
432ccd979bdSMark Fasheh 					      handle,
433ccd979bdSMark Fasheh 					      meta_ac,
434ccd979bdSMark Fasheh 					      wanted - count,
435ccd979bdSMark Fasheh 					      &suballoc_bit_start,
436ccd979bdSMark Fasheh 					      &num_got,
437ccd979bdSMark Fasheh 					      &first_blkno);
438ccd979bdSMark Fasheh 		if (status < 0) {
439ccd979bdSMark Fasheh 			mlog_errno(status);
440ccd979bdSMark Fasheh 			goto bail;
441ccd979bdSMark Fasheh 		}
442ccd979bdSMark Fasheh 
443ccd979bdSMark Fasheh 		for(i = count;  i < (num_got + count); i++) {
444ccd979bdSMark Fasheh 			bhs[i] = sb_getblk(osb->sb, first_blkno);
445ccd979bdSMark Fasheh 			if (bhs[i] == NULL) {
446ccd979bdSMark Fasheh 				status = -EIO;
447ccd979bdSMark Fasheh 				mlog_errno(status);
448ccd979bdSMark Fasheh 				goto bail;
449ccd979bdSMark Fasheh 			}
450ccd979bdSMark Fasheh 			ocfs2_set_new_buffer_uptodate(inode, bhs[i]);
451ccd979bdSMark Fasheh 
452ccd979bdSMark Fasheh 			status = ocfs2_journal_access(handle, inode, bhs[i],
453ccd979bdSMark Fasheh 						      OCFS2_JOURNAL_ACCESS_CREATE);
454ccd979bdSMark Fasheh 			if (status < 0) {
455ccd979bdSMark Fasheh 				mlog_errno(status);
456ccd979bdSMark Fasheh 				goto bail;
457ccd979bdSMark Fasheh 			}
458ccd979bdSMark Fasheh 
459ccd979bdSMark Fasheh 			memset(bhs[i]->b_data, 0, osb->sb->s_blocksize);
460ccd979bdSMark Fasheh 			eb = (struct ocfs2_extent_block *) bhs[i]->b_data;
461ccd979bdSMark Fasheh 			/* Ok, setup the minimal stuff here. */
462ccd979bdSMark Fasheh 			strcpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
463ccd979bdSMark Fasheh 			eb->h_blkno = cpu_to_le64(first_blkno);
464ccd979bdSMark Fasheh 			eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
465ccd979bdSMark Fasheh 			eb->h_suballoc_slot = cpu_to_le16(osb->slot_num);
466ccd979bdSMark Fasheh 			eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start);
467ccd979bdSMark Fasheh 			eb->h_list.l_count =
468ccd979bdSMark Fasheh 				cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
469ccd979bdSMark Fasheh 
470ccd979bdSMark Fasheh 			suballoc_bit_start++;
471ccd979bdSMark Fasheh 			first_blkno++;
472ccd979bdSMark Fasheh 
473ccd979bdSMark Fasheh 			/* We'll also be dirtied by the caller, so
474ccd979bdSMark Fasheh 			 * this isn't absolutely necessary. */
475ccd979bdSMark Fasheh 			status = ocfs2_journal_dirty(handle, bhs[i]);
476ccd979bdSMark Fasheh 			if (status < 0) {
477ccd979bdSMark Fasheh 				mlog_errno(status);
478ccd979bdSMark Fasheh 				goto bail;
479ccd979bdSMark Fasheh 			}
480ccd979bdSMark Fasheh 		}
481ccd979bdSMark Fasheh 
482ccd979bdSMark Fasheh 		count += num_got;
483ccd979bdSMark Fasheh 	}
484ccd979bdSMark Fasheh 
485ccd979bdSMark Fasheh 	status = 0;
486ccd979bdSMark Fasheh bail:
487ccd979bdSMark Fasheh 	if (status < 0) {
488ccd979bdSMark Fasheh 		for(i = 0; i < wanted; i++) {
489ccd979bdSMark Fasheh 			if (bhs[i])
490ccd979bdSMark Fasheh 				brelse(bhs[i]);
491ccd979bdSMark Fasheh 			bhs[i] = NULL;
492ccd979bdSMark Fasheh 		}
493ccd979bdSMark Fasheh 	}
494ccd979bdSMark Fasheh 	mlog_exit(status);
495ccd979bdSMark Fasheh 	return status;
496ccd979bdSMark Fasheh }
497ccd979bdSMark Fasheh 
498ccd979bdSMark Fasheh /*
499dcd0538fSMark Fasheh  * Helper function for ocfs2_add_branch() and ocfs2_shift_tree_depth().
500dcd0538fSMark Fasheh  *
501dcd0538fSMark Fasheh  * Returns the sum of the rightmost extent rec logical offset and
502dcd0538fSMark Fasheh  * cluster count.
503dcd0538fSMark Fasheh  *
504dcd0538fSMark Fasheh  * ocfs2_add_branch() uses this to determine what logical cluster
505dcd0538fSMark Fasheh  * value should be populated into the leftmost new branch records.
506dcd0538fSMark Fasheh  *
507dcd0538fSMark Fasheh  * ocfs2_shift_tree_depth() uses this to determine the # clusters
508dcd0538fSMark Fasheh  * value for the new topmost tree record.
509dcd0538fSMark Fasheh  */
510dcd0538fSMark Fasheh static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list  *el)
511dcd0538fSMark Fasheh {
512dcd0538fSMark Fasheh 	int i;
513dcd0538fSMark Fasheh 
514dcd0538fSMark Fasheh 	i = le16_to_cpu(el->l_next_free_rec) - 1;
515dcd0538fSMark Fasheh 
516dcd0538fSMark Fasheh 	return le32_to_cpu(el->l_recs[i].e_cpos) +
517e48edee2SMark Fasheh 		ocfs2_rec_clusters(el, &el->l_recs[i]);
518dcd0538fSMark Fasheh }
519dcd0538fSMark Fasheh 
520dcd0538fSMark Fasheh /*
521ccd979bdSMark Fasheh  * Add an entire tree branch to our inode. eb_bh is the extent block
522ccd979bdSMark Fasheh  * to start at, if we don't want to start the branch at the dinode
523ccd979bdSMark Fasheh  * structure.
524ccd979bdSMark Fasheh  *
525ccd979bdSMark Fasheh  * last_eb_bh is required as we have to update it's next_leaf pointer
526ccd979bdSMark Fasheh  * for the new last extent block.
527ccd979bdSMark Fasheh  *
528ccd979bdSMark Fasheh  * the new branch will be 'empty' in the sense that every block will
529e48edee2SMark Fasheh  * contain a single record with cluster count == 0.
530ccd979bdSMark Fasheh  */
531ccd979bdSMark Fasheh static int ocfs2_add_branch(struct ocfs2_super *osb,
5321fabe148SMark Fasheh 			    handle_t *handle,
533ccd979bdSMark Fasheh 			    struct inode *inode,
534ccd979bdSMark Fasheh 			    struct buffer_head *fe_bh,
535ccd979bdSMark Fasheh 			    struct buffer_head *eb_bh,
536328d5752SMark Fasheh 			    struct buffer_head **last_eb_bh,
537ccd979bdSMark Fasheh 			    struct ocfs2_alloc_context *meta_ac)
538ccd979bdSMark Fasheh {
539ccd979bdSMark Fasheh 	int status, new_blocks, i;
540ccd979bdSMark Fasheh 	u64 next_blkno, new_last_eb_blk;
541ccd979bdSMark Fasheh 	struct buffer_head *bh;
542ccd979bdSMark Fasheh 	struct buffer_head **new_eb_bhs = NULL;
543ccd979bdSMark Fasheh 	struct ocfs2_dinode *fe;
544ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
545ccd979bdSMark Fasheh 	struct ocfs2_extent_list  *eb_el;
546ccd979bdSMark Fasheh 	struct ocfs2_extent_list  *el;
547dcd0538fSMark Fasheh 	u32 new_cpos;
548ccd979bdSMark Fasheh 
549ccd979bdSMark Fasheh 	mlog_entry_void();
550ccd979bdSMark Fasheh 
551328d5752SMark Fasheh 	BUG_ON(!last_eb_bh || !*last_eb_bh);
552ccd979bdSMark Fasheh 
553ccd979bdSMark Fasheh 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
554ccd979bdSMark Fasheh 
555ccd979bdSMark Fasheh 	if (eb_bh) {
556ccd979bdSMark Fasheh 		eb = (struct ocfs2_extent_block *) eb_bh->b_data;
557ccd979bdSMark Fasheh 		el = &eb->h_list;
558ccd979bdSMark Fasheh 	} else
559ccd979bdSMark Fasheh 		el = &fe->id2.i_list;
560ccd979bdSMark Fasheh 
561ccd979bdSMark Fasheh 	/* we never add a branch to a leaf. */
562ccd979bdSMark Fasheh 	BUG_ON(!el->l_tree_depth);
563ccd979bdSMark Fasheh 
564ccd979bdSMark Fasheh 	new_blocks = le16_to_cpu(el->l_tree_depth);
565ccd979bdSMark Fasheh 
566ccd979bdSMark Fasheh 	/* allocate the number of new eb blocks we need */
567ccd979bdSMark Fasheh 	new_eb_bhs = kcalloc(new_blocks, sizeof(struct buffer_head *),
568ccd979bdSMark Fasheh 			     GFP_KERNEL);
569ccd979bdSMark Fasheh 	if (!new_eb_bhs) {
570ccd979bdSMark Fasheh 		status = -ENOMEM;
571ccd979bdSMark Fasheh 		mlog_errno(status);
572ccd979bdSMark Fasheh 		goto bail;
573ccd979bdSMark Fasheh 	}
574ccd979bdSMark Fasheh 
575ccd979bdSMark Fasheh 	status = ocfs2_create_new_meta_bhs(osb, handle, inode, new_blocks,
576ccd979bdSMark Fasheh 					   meta_ac, new_eb_bhs);
577ccd979bdSMark Fasheh 	if (status < 0) {
578ccd979bdSMark Fasheh 		mlog_errno(status);
579ccd979bdSMark Fasheh 		goto bail;
580ccd979bdSMark Fasheh 	}
581ccd979bdSMark Fasheh 
582328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data;
583dcd0538fSMark Fasheh 	new_cpos = ocfs2_sum_rightmost_rec(&eb->h_list);
584dcd0538fSMark Fasheh 
585ccd979bdSMark Fasheh 	/* Note: new_eb_bhs[new_blocks - 1] is the guy which will be
586ccd979bdSMark Fasheh 	 * linked with the rest of the tree.
587ccd979bdSMark Fasheh 	 * conversly, new_eb_bhs[0] is the new bottommost leaf.
588ccd979bdSMark Fasheh 	 *
589ccd979bdSMark Fasheh 	 * when we leave the loop, new_last_eb_blk will point to the
590ccd979bdSMark Fasheh 	 * newest leaf, and next_blkno will point to the topmost extent
591ccd979bdSMark Fasheh 	 * block. */
592ccd979bdSMark Fasheh 	next_blkno = new_last_eb_blk = 0;
593ccd979bdSMark Fasheh 	for(i = 0; i < new_blocks; i++) {
594ccd979bdSMark Fasheh 		bh = new_eb_bhs[i];
595ccd979bdSMark Fasheh 		eb = (struct ocfs2_extent_block *) bh->b_data;
596ccd979bdSMark Fasheh 		if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
597ccd979bdSMark Fasheh 			OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
598ccd979bdSMark Fasheh 			status = -EIO;
599ccd979bdSMark Fasheh 			goto bail;
600ccd979bdSMark Fasheh 		}
601ccd979bdSMark Fasheh 		eb_el = &eb->h_list;
602ccd979bdSMark Fasheh 
603ccd979bdSMark Fasheh 		status = ocfs2_journal_access(handle, inode, bh,
604ccd979bdSMark Fasheh 					      OCFS2_JOURNAL_ACCESS_CREATE);
605ccd979bdSMark Fasheh 		if (status < 0) {
606ccd979bdSMark Fasheh 			mlog_errno(status);
607ccd979bdSMark Fasheh 			goto bail;
608ccd979bdSMark Fasheh 		}
609ccd979bdSMark Fasheh 
610ccd979bdSMark Fasheh 		eb->h_next_leaf_blk = 0;
611ccd979bdSMark Fasheh 		eb_el->l_tree_depth = cpu_to_le16(i);
612ccd979bdSMark Fasheh 		eb_el->l_next_free_rec = cpu_to_le16(1);
613dcd0538fSMark Fasheh 		/*
614dcd0538fSMark Fasheh 		 * This actually counts as an empty extent as
615dcd0538fSMark Fasheh 		 * c_clusters == 0
616dcd0538fSMark Fasheh 		 */
617dcd0538fSMark Fasheh 		eb_el->l_recs[0].e_cpos = cpu_to_le32(new_cpos);
618ccd979bdSMark Fasheh 		eb_el->l_recs[0].e_blkno = cpu_to_le64(next_blkno);
619e48edee2SMark Fasheh 		/*
620e48edee2SMark Fasheh 		 * eb_el isn't always an interior node, but even leaf
621e48edee2SMark Fasheh 		 * nodes want a zero'd flags and reserved field so
622e48edee2SMark Fasheh 		 * this gets the whole 32 bits regardless of use.
623e48edee2SMark Fasheh 		 */
624e48edee2SMark Fasheh 		eb_el->l_recs[0].e_int_clusters = cpu_to_le32(0);
625ccd979bdSMark Fasheh 		if (!eb_el->l_tree_depth)
626ccd979bdSMark Fasheh 			new_last_eb_blk = le64_to_cpu(eb->h_blkno);
627ccd979bdSMark Fasheh 
628ccd979bdSMark Fasheh 		status = ocfs2_journal_dirty(handle, bh);
629ccd979bdSMark Fasheh 		if (status < 0) {
630ccd979bdSMark Fasheh 			mlog_errno(status);
631ccd979bdSMark Fasheh 			goto bail;
632ccd979bdSMark Fasheh 		}
633ccd979bdSMark Fasheh 
634ccd979bdSMark Fasheh 		next_blkno = le64_to_cpu(eb->h_blkno);
635ccd979bdSMark Fasheh 	}
636ccd979bdSMark Fasheh 
637ccd979bdSMark Fasheh 	/* This is a bit hairy. We want to update up to three blocks
638ccd979bdSMark Fasheh 	 * here without leaving any of them in an inconsistent state
639ccd979bdSMark Fasheh 	 * in case of error. We don't have to worry about
640ccd979bdSMark Fasheh 	 * journal_dirty erroring as it won't unless we've aborted the
641ccd979bdSMark Fasheh 	 * handle (in which case we would never be here) so reserving
642ccd979bdSMark Fasheh 	 * the write with journal_access is all we need to do. */
643328d5752SMark Fasheh 	status = ocfs2_journal_access(handle, inode, *last_eb_bh,
644ccd979bdSMark Fasheh 				      OCFS2_JOURNAL_ACCESS_WRITE);
645ccd979bdSMark Fasheh 	if (status < 0) {
646ccd979bdSMark Fasheh 		mlog_errno(status);
647ccd979bdSMark Fasheh 		goto bail;
648ccd979bdSMark Fasheh 	}
649ccd979bdSMark Fasheh 	status = ocfs2_journal_access(handle, inode, fe_bh,
650ccd979bdSMark Fasheh 				      OCFS2_JOURNAL_ACCESS_WRITE);
651ccd979bdSMark Fasheh 	if (status < 0) {
652ccd979bdSMark Fasheh 		mlog_errno(status);
653ccd979bdSMark Fasheh 		goto bail;
654ccd979bdSMark Fasheh 	}
655ccd979bdSMark Fasheh 	if (eb_bh) {
656ccd979bdSMark Fasheh 		status = ocfs2_journal_access(handle, inode, eb_bh,
657ccd979bdSMark Fasheh 					      OCFS2_JOURNAL_ACCESS_WRITE);
658ccd979bdSMark Fasheh 		if (status < 0) {
659ccd979bdSMark Fasheh 			mlog_errno(status);
660ccd979bdSMark Fasheh 			goto bail;
661ccd979bdSMark Fasheh 		}
662ccd979bdSMark Fasheh 	}
663ccd979bdSMark Fasheh 
664ccd979bdSMark Fasheh 	/* Link the new branch into the rest of the tree (el will
665ccd979bdSMark Fasheh 	 * either be on the fe, or the extent block passed in. */
666ccd979bdSMark Fasheh 	i = le16_to_cpu(el->l_next_free_rec);
667ccd979bdSMark Fasheh 	el->l_recs[i].e_blkno = cpu_to_le64(next_blkno);
668dcd0538fSMark Fasheh 	el->l_recs[i].e_cpos = cpu_to_le32(new_cpos);
669e48edee2SMark Fasheh 	el->l_recs[i].e_int_clusters = 0;
670ccd979bdSMark Fasheh 	le16_add_cpu(&el->l_next_free_rec, 1);
671ccd979bdSMark Fasheh 
672ccd979bdSMark Fasheh 	/* fe needs a new last extent block pointer, as does the
673ccd979bdSMark Fasheh 	 * next_leaf on the previously last-extent-block. */
674ccd979bdSMark Fasheh 	fe->i_last_eb_blk = cpu_to_le64(new_last_eb_blk);
675ccd979bdSMark Fasheh 
676328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
677ccd979bdSMark Fasheh 	eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk);
678ccd979bdSMark Fasheh 
679328d5752SMark Fasheh 	status = ocfs2_journal_dirty(handle, *last_eb_bh);
680ccd979bdSMark Fasheh 	if (status < 0)
681ccd979bdSMark Fasheh 		mlog_errno(status);
682ccd979bdSMark Fasheh 	status = ocfs2_journal_dirty(handle, fe_bh);
683ccd979bdSMark Fasheh 	if (status < 0)
684ccd979bdSMark Fasheh 		mlog_errno(status);
685ccd979bdSMark Fasheh 	if (eb_bh) {
686ccd979bdSMark Fasheh 		status = ocfs2_journal_dirty(handle, eb_bh);
687ccd979bdSMark Fasheh 		if (status < 0)
688ccd979bdSMark Fasheh 			mlog_errno(status);
689ccd979bdSMark Fasheh 	}
690ccd979bdSMark Fasheh 
691328d5752SMark Fasheh 	/*
692328d5752SMark Fasheh 	 * Some callers want to track the rightmost leaf so pass it
693328d5752SMark Fasheh 	 * back here.
694328d5752SMark Fasheh 	 */
695328d5752SMark Fasheh 	brelse(*last_eb_bh);
696328d5752SMark Fasheh 	get_bh(new_eb_bhs[0]);
697328d5752SMark Fasheh 	*last_eb_bh = new_eb_bhs[0];
698328d5752SMark Fasheh 
699ccd979bdSMark Fasheh 	status = 0;
700ccd979bdSMark Fasheh bail:
701ccd979bdSMark Fasheh 	if (new_eb_bhs) {
702ccd979bdSMark Fasheh 		for (i = 0; i < new_blocks; i++)
703ccd979bdSMark Fasheh 			if (new_eb_bhs[i])
704ccd979bdSMark Fasheh 				brelse(new_eb_bhs[i]);
705ccd979bdSMark Fasheh 		kfree(new_eb_bhs);
706ccd979bdSMark Fasheh 	}
707ccd979bdSMark Fasheh 
708ccd979bdSMark Fasheh 	mlog_exit(status);
709ccd979bdSMark Fasheh 	return status;
710ccd979bdSMark Fasheh }
711ccd979bdSMark Fasheh 
712ccd979bdSMark Fasheh /*
713ccd979bdSMark Fasheh  * adds another level to the allocation tree.
714ccd979bdSMark Fasheh  * returns back the new extent block so you can add a branch to it
715ccd979bdSMark Fasheh  * after this call.
716ccd979bdSMark Fasheh  */
717ccd979bdSMark Fasheh static int ocfs2_shift_tree_depth(struct ocfs2_super *osb,
7181fabe148SMark Fasheh 				  handle_t *handle,
719ccd979bdSMark Fasheh 				  struct inode *inode,
720ccd979bdSMark Fasheh 				  struct buffer_head *fe_bh,
721ccd979bdSMark Fasheh 				  struct ocfs2_alloc_context *meta_ac,
722ccd979bdSMark Fasheh 				  struct buffer_head **ret_new_eb_bh)
723ccd979bdSMark Fasheh {
724ccd979bdSMark Fasheh 	int status, i;
725dcd0538fSMark Fasheh 	u32 new_clusters;
726ccd979bdSMark Fasheh 	struct buffer_head *new_eb_bh = NULL;
727ccd979bdSMark Fasheh 	struct ocfs2_dinode *fe;
728ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
729ccd979bdSMark Fasheh 	struct ocfs2_extent_list  *fe_el;
730ccd979bdSMark Fasheh 	struct ocfs2_extent_list  *eb_el;
731ccd979bdSMark Fasheh 
732ccd979bdSMark Fasheh 	mlog_entry_void();
733ccd979bdSMark Fasheh 
734ccd979bdSMark Fasheh 	status = ocfs2_create_new_meta_bhs(osb, handle, inode, 1, meta_ac,
735ccd979bdSMark Fasheh 					   &new_eb_bh);
736ccd979bdSMark Fasheh 	if (status < 0) {
737ccd979bdSMark Fasheh 		mlog_errno(status);
738ccd979bdSMark Fasheh 		goto bail;
739ccd979bdSMark Fasheh 	}
740ccd979bdSMark Fasheh 
741ccd979bdSMark Fasheh 	eb = (struct ocfs2_extent_block *) new_eb_bh->b_data;
742ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
743ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
744ccd979bdSMark Fasheh 		status = -EIO;
745ccd979bdSMark Fasheh 		goto bail;
746ccd979bdSMark Fasheh 	}
747ccd979bdSMark Fasheh 
748ccd979bdSMark Fasheh 	eb_el = &eb->h_list;
749ccd979bdSMark Fasheh 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
750ccd979bdSMark Fasheh 	fe_el = &fe->id2.i_list;
751ccd979bdSMark Fasheh 
752ccd979bdSMark Fasheh 	status = ocfs2_journal_access(handle, inode, new_eb_bh,
753ccd979bdSMark Fasheh 				      OCFS2_JOURNAL_ACCESS_CREATE);
754ccd979bdSMark Fasheh 	if (status < 0) {
755ccd979bdSMark Fasheh 		mlog_errno(status);
756ccd979bdSMark Fasheh 		goto bail;
757ccd979bdSMark Fasheh 	}
758ccd979bdSMark Fasheh 
759ccd979bdSMark Fasheh 	/* copy the fe data into the new extent block */
760ccd979bdSMark Fasheh 	eb_el->l_tree_depth = fe_el->l_tree_depth;
761ccd979bdSMark Fasheh 	eb_el->l_next_free_rec = fe_el->l_next_free_rec;
762e48edee2SMark Fasheh 	for(i = 0; i < le16_to_cpu(fe_el->l_next_free_rec); i++)
763e48edee2SMark Fasheh 		eb_el->l_recs[i] = fe_el->l_recs[i];
764ccd979bdSMark Fasheh 
765ccd979bdSMark Fasheh 	status = ocfs2_journal_dirty(handle, new_eb_bh);
766ccd979bdSMark Fasheh 	if (status < 0) {
767ccd979bdSMark Fasheh 		mlog_errno(status);
768ccd979bdSMark Fasheh 		goto bail;
769ccd979bdSMark Fasheh 	}
770ccd979bdSMark Fasheh 
771ccd979bdSMark Fasheh 	status = ocfs2_journal_access(handle, inode, fe_bh,
772ccd979bdSMark Fasheh 				      OCFS2_JOURNAL_ACCESS_WRITE);
773ccd979bdSMark Fasheh 	if (status < 0) {
774ccd979bdSMark Fasheh 		mlog_errno(status);
775ccd979bdSMark Fasheh 		goto bail;
776ccd979bdSMark Fasheh 	}
777ccd979bdSMark Fasheh 
778dcd0538fSMark Fasheh 	new_clusters = ocfs2_sum_rightmost_rec(eb_el);
779dcd0538fSMark Fasheh 
780ccd979bdSMark Fasheh 	/* update fe now */
781ccd979bdSMark Fasheh 	le16_add_cpu(&fe_el->l_tree_depth, 1);
782ccd979bdSMark Fasheh 	fe_el->l_recs[0].e_cpos = 0;
783ccd979bdSMark Fasheh 	fe_el->l_recs[0].e_blkno = eb->h_blkno;
784e48edee2SMark Fasheh 	fe_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters);
785e48edee2SMark Fasheh 	for(i = 1; i < le16_to_cpu(fe_el->l_next_free_rec); i++)
786e48edee2SMark Fasheh 		memset(&fe_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
787ccd979bdSMark Fasheh 	fe_el->l_next_free_rec = cpu_to_le16(1);
788ccd979bdSMark Fasheh 
789ccd979bdSMark Fasheh 	/* If this is our 1st tree depth shift, then last_eb_blk
790ccd979bdSMark Fasheh 	 * becomes the allocated extent block */
791ccd979bdSMark Fasheh 	if (fe_el->l_tree_depth == cpu_to_le16(1))
792ccd979bdSMark Fasheh 		fe->i_last_eb_blk = eb->h_blkno;
793ccd979bdSMark Fasheh 
794ccd979bdSMark Fasheh 	status = ocfs2_journal_dirty(handle, fe_bh);
795ccd979bdSMark Fasheh 	if (status < 0) {
796ccd979bdSMark Fasheh 		mlog_errno(status);
797ccd979bdSMark Fasheh 		goto bail;
798ccd979bdSMark Fasheh 	}
799ccd979bdSMark Fasheh 
800ccd979bdSMark Fasheh 	*ret_new_eb_bh = new_eb_bh;
801ccd979bdSMark Fasheh 	new_eb_bh = NULL;
802ccd979bdSMark Fasheh 	status = 0;
803ccd979bdSMark Fasheh bail:
804ccd979bdSMark Fasheh 	if (new_eb_bh)
805ccd979bdSMark Fasheh 		brelse(new_eb_bh);
806ccd979bdSMark Fasheh 
807ccd979bdSMark Fasheh 	mlog_exit(status);
808ccd979bdSMark Fasheh 	return status;
809ccd979bdSMark Fasheh }
810ccd979bdSMark Fasheh 
811ccd979bdSMark Fasheh /*
812ccd979bdSMark Fasheh  * Should only be called when there is no space left in any of the
813ccd979bdSMark Fasheh  * leaf nodes. What we want to do is find the lowest tree depth
814ccd979bdSMark Fasheh  * non-leaf extent block with room for new records. There are three
815ccd979bdSMark Fasheh  * valid results of this search:
816ccd979bdSMark Fasheh  *
817ccd979bdSMark Fasheh  * 1) a lowest extent block is found, then we pass it back in
818ccd979bdSMark Fasheh  *    *lowest_eb_bh and return '0'
819ccd979bdSMark Fasheh  *
820ccd979bdSMark Fasheh  * 2) the search fails to find anything, but the dinode has room. We
821ccd979bdSMark Fasheh  *    pass NULL back in *lowest_eb_bh, but still return '0'
822ccd979bdSMark Fasheh  *
823ccd979bdSMark Fasheh  * 3) the search fails to find anything AND the dinode is full, in
824ccd979bdSMark Fasheh  *    which case we return > 0
825ccd979bdSMark Fasheh  *
826ccd979bdSMark Fasheh  * return status < 0 indicates an error.
827ccd979bdSMark Fasheh  */
828ccd979bdSMark Fasheh static int ocfs2_find_branch_target(struct ocfs2_super *osb,
829ccd979bdSMark Fasheh 				    struct inode *inode,
830ccd979bdSMark Fasheh 				    struct buffer_head *fe_bh,
831ccd979bdSMark Fasheh 				    struct buffer_head **target_bh)
832ccd979bdSMark Fasheh {
833ccd979bdSMark Fasheh 	int status = 0, i;
834ccd979bdSMark Fasheh 	u64 blkno;
835ccd979bdSMark Fasheh 	struct ocfs2_dinode *fe;
836ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
837ccd979bdSMark Fasheh 	struct ocfs2_extent_list  *el;
838ccd979bdSMark Fasheh 	struct buffer_head *bh = NULL;
839ccd979bdSMark Fasheh 	struct buffer_head *lowest_bh = NULL;
840ccd979bdSMark Fasheh 
841ccd979bdSMark Fasheh 	mlog_entry_void();
842ccd979bdSMark Fasheh 
843ccd979bdSMark Fasheh 	*target_bh = NULL;
844ccd979bdSMark Fasheh 
845ccd979bdSMark Fasheh 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
846ccd979bdSMark Fasheh 	el = &fe->id2.i_list;
847ccd979bdSMark Fasheh 
848ccd979bdSMark Fasheh 	while(le16_to_cpu(el->l_tree_depth) > 1) {
849ccd979bdSMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) == 0) {
850b0697053SMark Fasheh 			ocfs2_error(inode->i_sb, "Dinode %llu has empty "
851ccd979bdSMark Fasheh 				    "extent list (next_free_rec == 0)",
852b0697053SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno);
853ccd979bdSMark Fasheh 			status = -EIO;
854ccd979bdSMark Fasheh 			goto bail;
855ccd979bdSMark Fasheh 		}
856ccd979bdSMark Fasheh 		i = le16_to_cpu(el->l_next_free_rec) - 1;
857ccd979bdSMark Fasheh 		blkno = le64_to_cpu(el->l_recs[i].e_blkno);
858ccd979bdSMark Fasheh 		if (!blkno) {
859b0697053SMark Fasheh 			ocfs2_error(inode->i_sb, "Dinode %llu has extent "
860ccd979bdSMark Fasheh 				    "list where extent # %d has no physical "
861ccd979bdSMark Fasheh 				    "block start",
862b0697053SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno, i);
863ccd979bdSMark Fasheh 			status = -EIO;
864ccd979bdSMark Fasheh 			goto bail;
865ccd979bdSMark Fasheh 		}
866ccd979bdSMark Fasheh 
867ccd979bdSMark Fasheh 		if (bh) {
868ccd979bdSMark Fasheh 			brelse(bh);
869ccd979bdSMark Fasheh 			bh = NULL;
870ccd979bdSMark Fasheh 		}
871ccd979bdSMark Fasheh 
872ccd979bdSMark Fasheh 		status = ocfs2_read_block(osb, blkno, &bh, OCFS2_BH_CACHED,
873ccd979bdSMark Fasheh 					  inode);
874ccd979bdSMark Fasheh 		if (status < 0) {
875ccd979bdSMark Fasheh 			mlog_errno(status);
876ccd979bdSMark Fasheh 			goto bail;
877ccd979bdSMark Fasheh 		}
878ccd979bdSMark Fasheh 
879ccd979bdSMark Fasheh 		eb = (struct ocfs2_extent_block *) bh->b_data;
880ccd979bdSMark Fasheh 		if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
881ccd979bdSMark Fasheh 			OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
882ccd979bdSMark Fasheh 			status = -EIO;
883ccd979bdSMark Fasheh 			goto bail;
884ccd979bdSMark Fasheh 		}
885ccd979bdSMark Fasheh 		el = &eb->h_list;
886ccd979bdSMark Fasheh 
887ccd979bdSMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) <
888ccd979bdSMark Fasheh 		    le16_to_cpu(el->l_count)) {
889ccd979bdSMark Fasheh 			if (lowest_bh)
890ccd979bdSMark Fasheh 				brelse(lowest_bh);
891ccd979bdSMark Fasheh 			lowest_bh = bh;
892ccd979bdSMark Fasheh 			get_bh(lowest_bh);
893ccd979bdSMark Fasheh 		}
894ccd979bdSMark Fasheh 	}
895ccd979bdSMark Fasheh 
896ccd979bdSMark Fasheh 	/* If we didn't find one and the fe doesn't have any room,
897ccd979bdSMark Fasheh 	 * then return '1' */
898ccd979bdSMark Fasheh 	if (!lowest_bh
899ccd979bdSMark Fasheh 	    && (fe->id2.i_list.l_next_free_rec == fe->id2.i_list.l_count))
900ccd979bdSMark Fasheh 		status = 1;
901ccd979bdSMark Fasheh 
902ccd979bdSMark Fasheh 	*target_bh = lowest_bh;
903ccd979bdSMark Fasheh bail:
904ccd979bdSMark Fasheh 	if (bh)
905ccd979bdSMark Fasheh 		brelse(bh);
906ccd979bdSMark Fasheh 
907ccd979bdSMark Fasheh 	mlog_exit(status);
908ccd979bdSMark Fasheh 	return status;
909ccd979bdSMark Fasheh }
910ccd979bdSMark Fasheh 
911e48edee2SMark Fasheh /*
912c3afcbb3SMark Fasheh  * Grow a b-tree so that it has more records.
913c3afcbb3SMark Fasheh  *
914c3afcbb3SMark Fasheh  * We might shift the tree depth in which case existing paths should
915c3afcbb3SMark Fasheh  * be considered invalid.
916c3afcbb3SMark Fasheh  *
917c3afcbb3SMark Fasheh  * Tree depth after the grow is returned via *final_depth.
918328d5752SMark Fasheh  *
919328d5752SMark Fasheh  * *last_eb_bh will be updated by ocfs2_add_branch().
920c3afcbb3SMark Fasheh  */
921c3afcbb3SMark Fasheh static int ocfs2_grow_tree(struct inode *inode, handle_t *handle,
922c3afcbb3SMark Fasheh 			   struct buffer_head *di_bh, int *final_depth,
923328d5752SMark Fasheh 			   struct buffer_head **last_eb_bh,
924c3afcbb3SMark Fasheh 			   struct ocfs2_alloc_context *meta_ac)
925c3afcbb3SMark Fasheh {
926c3afcbb3SMark Fasheh 	int ret, shift;
927c3afcbb3SMark Fasheh 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
928c3afcbb3SMark Fasheh 	int depth = le16_to_cpu(di->id2.i_list.l_tree_depth);
929c3afcbb3SMark Fasheh 	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
930c3afcbb3SMark Fasheh 	struct buffer_head *bh = NULL;
931c3afcbb3SMark Fasheh 
932c3afcbb3SMark Fasheh 	BUG_ON(meta_ac == NULL);
933c3afcbb3SMark Fasheh 
934c3afcbb3SMark Fasheh 	shift = ocfs2_find_branch_target(osb, inode, di_bh, &bh);
935c3afcbb3SMark Fasheh 	if (shift < 0) {
936c3afcbb3SMark Fasheh 		ret = shift;
937c3afcbb3SMark Fasheh 		mlog_errno(ret);
938c3afcbb3SMark Fasheh 		goto out;
939c3afcbb3SMark Fasheh 	}
940c3afcbb3SMark Fasheh 
941c3afcbb3SMark Fasheh 	/* We traveled all the way to the bottom of the allocation tree
942c3afcbb3SMark Fasheh 	 * and didn't find room for any more extents - we need to add
943c3afcbb3SMark Fasheh 	 * another tree level */
944c3afcbb3SMark Fasheh 	if (shift) {
945c3afcbb3SMark Fasheh 		BUG_ON(bh);
946c3afcbb3SMark Fasheh 		mlog(0, "need to shift tree depth (current = %d)\n", depth);
947c3afcbb3SMark Fasheh 
948c3afcbb3SMark Fasheh 		/* ocfs2_shift_tree_depth will return us a buffer with
949c3afcbb3SMark Fasheh 		 * the new extent block (so we can pass that to
950c3afcbb3SMark Fasheh 		 * ocfs2_add_branch). */
951c3afcbb3SMark Fasheh 		ret = ocfs2_shift_tree_depth(osb, handle, inode, di_bh,
952c3afcbb3SMark Fasheh 					     meta_ac, &bh);
953c3afcbb3SMark Fasheh 		if (ret < 0) {
954c3afcbb3SMark Fasheh 			mlog_errno(ret);
955c3afcbb3SMark Fasheh 			goto out;
956c3afcbb3SMark Fasheh 		}
957c3afcbb3SMark Fasheh 		depth++;
958328d5752SMark Fasheh 		if (depth == 1) {
959328d5752SMark Fasheh 			/*
960328d5752SMark Fasheh 			 * Special case: we have room now if we shifted from
961328d5752SMark Fasheh 			 * tree_depth 0, so no more work needs to be done.
962328d5752SMark Fasheh 			 *
963328d5752SMark Fasheh 			 * We won't be calling add_branch, so pass
964328d5752SMark Fasheh 			 * back *last_eb_bh as the new leaf. At depth
965328d5752SMark Fasheh 			 * zero, it should always be null so there's
966328d5752SMark Fasheh 			 * no reason to brelse.
967328d5752SMark Fasheh 			 */
968328d5752SMark Fasheh 			BUG_ON(*last_eb_bh);
969328d5752SMark Fasheh 			get_bh(bh);
970328d5752SMark Fasheh 			*last_eb_bh = bh;
971c3afcbb3SMark Fasheh 			goto out;
972c3afcbb3SMark Fasheh 		}
973328d5752SMark Fasheh 	}
974c3afcbb3SMark Fasheh 
975c3afcbb3SMark Fasheh 	/* call ocfs2_add_branch to add the final part of the tree with
976c3afcbb3SMark Fasheh 	 * the new data. */
977c3afcbb3SMark Fasheh 	mlog(0, "add branch. bh = %p\n", bh);
978c3afcbb3SMark Fasheh 	ret = ocfs2_add_branch(osb, handle, inode, di_bh, bh, last_eb_bh,
979c3afcbb3SMark Fasheh 			       meta_ac);
980c3afcbb3SMark Fasheh 	if (ret < 0) {
981c3afcbb3SMark Fasheh 		mlog_errno(ret);
982c3afcbb3SMark Fasheh 		goto out;
983c3afcbb3SMark Fasheh 	}
984c3afcbb3SMark Fasheh 
985c3afcbb3SMark Fasheh out:
986c3afcbb3SMark Fasheh 	if (final_depth)
987c3afcbb3SMark Fasheh 		*final_depth = depth;
988c3afcbb3SMark Fasheh 	brelse(bh);
989c3afcbb3SMark Fasheh 	return ret;
990c3afcbb3SMark Fasheh }
991c3afcbb3SMark Fasheh 
992c3afcbb3SMark Fasheh /*
993e48edee2SMark Fasheh  * This is only valid for leaf nodes, which are the only ones that can
994e48edee2SMark Fasheh  * have empty extents anyway.
995e48edee2SMark Fasheh  */
996dcd0538fSMark Fasheh static inline int ocfs2_is_empty_extent(struct ocfs2_extent_rec *rec)
997dcd0538fSMark Fasheh {
998e48edee2SMark Fasheh 	return !rec->e_leaf_clusters;
999dcd0538fSMark Fasheh }
1000dcd0538fSMark Fasheh 
1001dcd0538fSMark Fasheh /*
1002dcd0538fSMark Fasheh  * This function will discard the rightmost extent record.
1003dcd0538fSMark Fasheh  */
1004dcd0538fSMark Fasheh static void ocfs2_shift_records_right(struct ocfs2_extent_list *el)
1005dcd0538fSMark Fasheh {
1006dcd0538fSMark Fasheh 	int next_free = le16_to_cpu(el->l_next_free_rec);
1007dcd0538fSMark Fasheh 	int count = le16_to_cpu(el->l_count);
1008dcd0538fSMark Fasheh 	unsigned int num_bytes;
1009dcd0538fSMark Fasheh 
1010dcd0538fSMark Fasheh 	BUG_ON(!next_free);
1011dcd0538fSMark Fasheh 	/* This will cause us to go off the end of our extent list. */
1012dcd0538fSMark Fasheh 	BUG_ON(next_free >= count);
1013dcd0538fSMark Fasheh 
1014dcd0538fSMark Fasheh 	num_bytes = sizeof(struct ocfs2_extent_rec) * next_free;
1015dcd0538fSMark Fasheh 
1016dcd0538fSMark Fasheh 	memmove(&el->l_recs[1], &el->l_recs[0], num_bytes);
1017dcd0538fSMark Fasheh }
1018dcd0538fSMark Fasheh 
1019dcd0538fSMark Fasheh static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el,
1020dcd0538fSMark Fasheh 			      struct ocfs2_extent_rec *insert_rec)
1021dcd0538fSMark Fasheh {
1022dcd0538fSMark Fasheh 	int i, insert_index, next_free, has_empty, num_bytes;
1023dcd0538fSMark Fasheh 	u32 insert_cpos = le32_to_cpu(insert_rec->e_cpos);
1024dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *rec;
1025dcd0538fSMark Fasheh 
1026dcd0538fSMark Fasheh 	next_free = le16_to_cpu(el->l_next_free_rec);
1027dcd0538fSMark Fasheh 	has_empty = ocfs2_is_empty_extent(&el->l_recs[0]);
1028dcd0538fSMark Fasheh 
1029dcd0538fSMark Fasheh 	BUG_ON(!next_free);
1030dcd0538fSMark Fasheh 
1031dcd0538fSMark Fasheh 	/* The tree code before us didn't allow enough room in the leaf. */
1032*b1f3550fSJulia Lawall 	BUG_ON(el->l_next_free_rec == el->l_count && !has_empty);
1033dcd0538fSMark Fasheh 
1034dcd0538fSMark Fasheh 	/*
1035dcd0538fSMark Fasheh 	 * The easiest way to approach this is to just remove the
1036dcd0538fSMark Fasheh 	 * empty extent and temporarily decrement next_free.
1037dcd0538fSMark Fasheh 	 */
1038dcd0538fSMark Fasheh 	if (has_empty) {
1039dcd0538fSMark Fasheh 		/*
1040dcd0538fSMark Fasheh 		 * If next_free was 1 (only an empty extent), this
1041dcd0538fSMark Fasheh 		 * loop won't execute, which is fine. We still want
1042dcd0538fSMark Fasheh 		 * the decrement above to happen.
1043dcd0538fSMark Fasheh 		 */
1044dcd0538fSMark Fasheh 		for(i = 0; i < (next_free - 1); i++)
1045dcd0538fSMark Fasheh 			el->l_recs[i] = el->l_recs[i+1];
1046dcd0538fSMark Fasheh 
1047dcd0538fSMark Fasheh 		next_free--;
1048dcd0538fSMark Fasheh 	}
1049dcd0538fSMark Fasheh 
1050dcd0538fSMark Fasheh 	/*
1051dcd0538fSMark Fasheh 	 * Figure out what the new record index should be.
1052dcd0538fSMark Fasheh 	 */
1053dcd0538fSMark Fasheh 	for(i = 0; i < next_free; i++) {
1054dcd0538fSMark Fasheh 		rec = &el->l_recs[i];
1055dcd0538fSMark Fasheh 
1056dcd0538fSMark Fasheh 		if (insert_cpos < le32_to_cpu(rec->e_cpos))
1057dcd0538fSMark Fasheh 			break;
1058dcd0538fSMark Fasheh 	}
1059dcd0538fSMark Fasheh 	insert_index = i;
1060dcd0538fSMark Fasheh 
1061dcd0538fSMark Fasheh 	mlog(0, "ins %u: index %d, has_empty %d, next_free %d, count %d\n",
1062dcd0538fSMark Fasheh 	     insert_cpos, insert_index, has_empty, next_free, le16_to_cpu(el->l_count));
1063dcd0538fSMark Fasheh 
1064dcd0538fSMark Fasheh 	BUG_ON(insert_index < 0);
1065dcd0538fSMark Fasheh 	BUG_ON(insert_index >= le16_to_cpu(el->l_count));
1066dcd0538fSMark Fasheh 	BUG_ON(insert_index > next_free);
1067dcd0538fSMark Fasheh 
1068dcd0538fSMark Fasheh 	/*
1069dcd0538fSMark Fasheh 	 * No need to memmove if we're just adding to the tail.
1070dcd0538fSMark Fasheh 	 */
1071dcd0538fSMark Fasheh 	if (insert_index != next_free) {
1072dcd0538fSMark Fasheh 		BUG_ON(next_free >= le16_to_cpu(el->l_count));
1073dcd0538fSMark Fasheh 
1074dcd0538fSMark Fasheh 		num_bytes = next_free - insert_index;
1075dcd0538fSMark Fasheh 		num_bytes *= sizeof(struct ocfs2_extent_rec);
1076dcd0538fSMark Fasheh 		memmove(&el->l_recs[insert_index + 1],
1077dcd0538fSMark Fasheh 			&el->l_recs[insert_index],
1078dcd0538fSMark Fasheh 			num_bytes);
1079dcd0538fSMark Fasheh 	}
1080dcd0538fSMark Fasheh 
1081dcd0538fSMark Fasheh 	/*
1082dcd0538fSMark Fasheh 	 * Either we had an empty extent, and need to re-increment or
1083dcd0538fSMark Fasheh 	 * there was no empty extent on a non full rightmost leaf node,
1084dcd0538fSMark Fasheh 	 * in which case we still need to increment.
1085dcd0538fSMark Fasheh 	 */
1086dcd0538fSMark Fasheh 	next_free++;
1087dcd0538fSMark Fasheh 	el->l_next_free_rec = cpu_to_le16(next_free);
1088dcd0538fSMark Fasheh 	/*
1089dcd0538fSMark Fasheh 	 * Make sure none of the math above just messed up our tree.
1090dcd0538fSMark Fasheh 	 */
1091dcd0538fSMark Fasheh 	BUG_ON(le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count));
1092dcd0538fSMark Fasheh 
1093dcd0538fSMark Fasheh 	el->l_recs[insert_index] = *insert_rec;
1094dcd0538fSMark Fasheh 
1095dcd0538fSMark Fasheh }
1096dcd0538fSMark Fasheh 
1097328d5752SMark Fasheh static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el)
1098328d5752SMark Fasheh {
1099328d5752SMark Fasheh 	int size, num_recs = le16_to_cpu(el->l_next_free_rec);
1100328d5752SMark Fasheh 
1101328d5752SMark Fasheh 	BUG_ON(num_recs == 0);
1102328d5752SMark Fasheh 
1103328d5752SMark Fasheh 	if (ocfs2_is_empty_extent(&el->l_recs[0])) {
1104328d5752SMark Fasheh 		num_recs--;
1105328d5752SMark Fasheh 		size = num_recs * sizeof(struct ocfs2_extent_rec);
1106328d5752SMark Fasheh 		memmove(&el->l_recs[0], &el->l_recs[1], size);
1107328d5752SMark Fasheh 		memset(&el->l_recs[num_recs], 0,
1108328d5752SMark Fasheh 		       sizeof(struct ocfs2_extent_rec));
1109328d5752SMark Fasheh 		el->l_next_free_rec = cpu_to_le16(num_recs);
1110328d5752SMark Fasheh 	}
1111328d5752SMark Fasheh }
1112328d5752SMark Fasheh 
1113dcd0538fSMark Fasheh /*
1114dcd0538fSMark Fasheh  * Create an empty extent record .
1115dcd0538fSMark Fasheh  *
1116dcd0538fSMark Fasheh  * l_next_free_rec may be updated.
1117dcd0538fSMark Fasheh  *
1118dcd0538fSMark Fasheh  * If an empty extent already exists do nothing.
1119dcd0538fSMark Fasheh  */
1120dcd0538fSMark Fasheh static void ocfs2_create_empty_extent(struct ocfs2_extent_list *el)
1121dcd0538fSMark Fasheh {
1122dcd0538fSMark Fasheh 	int next_free = le16_to_cpu(el->l_next_free_rec);
1123dcd0538fSMark Fasheh 
1124e48edee2SMark Fasheh 	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
1125e48edee2SMark Fasheh 
1126dcd0538fSMark Fasheh 	if (next_free == 0)
1127dcd0538fSMark Fasheh 		goto set_and_inc;
1128dcd0538fSMark Fasheh 
1129dcd0538fSMark Fasheh 	if (ocfs2_is_empty_extent(&el->l_recs[0]))
1130dcd0538fSMark Fasheh 		return;
1131dcd0538fSMark Fasheh 
1132dcd0538fSMark Fasheh 	mlog_bug_on_msg(el->l_count == el->l_next_free_rec,
1133dcd0538fSMark Fasheh 			"Asked to create an empty extent in a full list:\n"
1134dcd0538fSMark Fasheh 			"count = %u, tree depth = %u",
1135dcd0538fSMark Fasheh 			le16_to_cpu(el->l_count),
1136dcd0538fSMark Fasheh 			le16_to_cpu(el->l_tree_depth));
1137dcd0538fSMark Fasheh 
1138dcd0538fSMark Fasheh 	ocfs2_shift_records_right(el);
1139dcd0538fSMark Fasheh 
1140dcd0538fSMark Fasheh set_and_inc:
1141dcd0538fSMark Fasheh 	le16_add_cpu(&el->l_next_free_rec, 1);
1142dcd0538fSMark Fasheh 	memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
1143dcd0538fSMark Fasheh }
1144dcd0538fSMark Fasheh 
1145dcd0538fSMark Fasheh /*
1146dcd0538fSMark Fasheh  * For a rotation which involves two leaf nodes, the "root node" is
1147dcd0538fSMark Fasheh  * the lowest level tree node which contains a path to both leafs. This
1148dcd0538fSMark Fasheh  * resulting set of information can be used to form a complete "subtree"
1149dcd0538fSMark Fasheh  *
1150dcd0538fSMark Fasheh  * This function is passed two full paths from the dinode down to a
1151dcd0538fSMark Fasheh  * pair of adjacent leaves. It's task is to figure out which path
1152dcd0538fSMark Fasheh  * index contains the subtree root - this can be the root index itself
1153dcd0538fSMark Fasheh  * in a worst-case rotation.
1154dcd0538fSMark Fasheh  *
1155dcd0538fSMark Fasheh  * The array index of the subtree root is passed back.
1156dcd0538fSMark Fasheh  */
1157dcd0538fSMark Fasheh static int ocfs2_find_subtree_root(struct inode *inode,
1158dcd0538fSMark Fasheh 				   struct ocfs2_path *left,
1159dcd0538fSMark Fasheh 				   struct ocfs2_path *right)
1160dcd0538fSMark Fasheh {
1161dcd0538fSMark Fasheh 	int i = 0;
1162dcd0538fSMark Fasheh 
1163dcd0538fSMark Fasheh 	/*
1164dcd0538fSMark Fasheh 	 * Check that the caller passed in two paths from the same tree.
1165dcd0538fSMark Fasheh 	 */
1166dcd0538fSMark Fasheh 	BUG_ON(path_root_bh(left) != path_root_bh(right));
1167dcd0538fSMark Fasheh 
1168dcd0538fSMark Fasheh 	do {
1169dcd0538fSMark Fasheh 		i++;
1170dcd0538fSMark Fasheh 
1171dcd0538fSMark Fasheh 		/*
1172dcd0538fSMark Fasheh 		 * The caller didn't pass two adjacent paths.
1173dcd0538fSMark Fasheh 		 */
1174dcd0538fSMark Fasheh 		mlog_bug_on_msg(i > left->p_tree_depth,
1175dcd0538fSMark Fasheh 				"Inode %lu, left depth %u, right depth %u\n"
1176dcd0538fSMark Fasheh 				"left leaf blk %llu, right leaf blk %llu\n",
1177dcd0538fSMark Fasheh 				inode->i_ino, left->p_tree_depth,
1178dcd0538fSMark Fasheh 				right->p_tree_depth,
1179dcd0538fSMark Fasheh 				(unsigned long long)path_leaf_bh(left)->b_blocknr,
1180dcd0538fSMark Fasheh 				(unsigned long long)path_leaf_bh(right)->b_blocknr);
1181dcd0538fSMark Fasheh 	} while (left->p_node[i].bh->b_blocknr ==
1182dcd0538fSMark Fasheh 		 right->p_node[i].bh->b_blocknr);
1183dcd0538fSMark Fasheh 
1184dcd0538fSMark Fasheh 	return i - 1;
1185dcd0538fSMark Fasheh }
1186dcd0538fSMark Fasheh 
1187dcd0538fSMark Fasheh typedef void (path_insert_t)(void *, struct buffer_head *);
1188dcd0538fSMark Fasheh 
1189dcd0538fSMark Fasheh /*
1190dcd0538fSMark Fasheh  * Traverse a btree path in search of cpos, starting at root_el.
1191dcd0538fSMark Fasheh  *
1192dcd0538fSMark Fasheh  * This code can be called with a cpos larger than the tree, in which
1193dcd0538fSMark Fasheh  * case it will return the rightmost path.
1194dcd0538fSMark Fasheh  */
1195dcd0538fSMark Fasheh static int __ocfs2_find_path(struct inode *inode,
1196dcd0538fSMark Fasheh 			     struct ocfs2_extent_list *root_el, u32 cpos,
1197dcd0538fSMark Fasheh 			     path_insert_t *func, void *data)
1198dcd0538fSMark Fasheh {
1199dcd0538fSMark Fasheh 	int i, ret = 0;
1200dcd0538fSMark Fasheh 	u32 range;
1201dcd0538fSMark Fasheh 	u64 blkno;
1202dcd0538fSMark Fasheh 	struct buffer_head *bh = NULL;
1203dcd0538fSMark Fasheh 	struct ocfs2_extent_block *eb;
1204dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el;
1205dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *rec;
1206dcd0538fSMark Fasheh 	struct ocfs2_inode_info *oi = OCFS2_I(inode);
1207dcd0538fSMark Fasheh 
1208dcd0538fSMark Fasheh 	el = root_el;
1209dcd0538fSMark Fasheh 	while (el->l_tree_depth) {
1210dcd0538fSMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) == 0) {
1211dcd0538fSMark Fasheh 			ocfs2_error(inode->i_sb,
1212dcd0538fSMark Fasheh 				    "Inode %llu has empty extent list at "
1213dcd0538fSMark Fasheh 				    "depth %u\n",
1214dcd0538fSMark Fasheh 				    (unsigned long long)oi->ip_blkno,
1215dcd0538fSMark Fasheh 				    le16_to_cpu(el->l_tree_depth));
1216dcd0538fSMark Fasheh 			ret = -EROFS;
1217dcd0538fSMark Fasheh 			goto out;
1218dcd0538fSMark Fasheh 
1219dcd0538fSMark Fasheh 		}
1220dcd0538fSMark Fasheh 
1221dcd0538fSMark Fasheh 		for(i = 0; i < le16_to_cpu(el->l_next_free_rec) - 1; i++) {
1222dcd0538fSMark Fasheh 			rec = &el->l_recs[i];
1223dcd0538fSMark Fasheh 
1224dcd0538fSMark Fasheh 			/*
1225dcd0538fSMark Fasheh 			 * In the case that cpos is off the allocation
1226dcd0538fSMark Fasheh 			 * tree, this should just wind up returning the
1227dcd0538fSMark Fasheh 			 * rightmost record.
1228dcd0538fSMark Fasheh 			 */
1229dcd0538fSMark Fasheh 			range = le32_to_cpu(rec->e_cpos) +
1230e48edee2SMark Fasheh 				ocfs2_rec_clusters(el, rec);
1231dcd0538fSMark Fasheh 			if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
1232dcd0538fSMark Fasheh 			    break;
1233dcd0538fSMark Fasheh 		}
1234dcd0538fSMark Fasheh 
1235dcd0538fSMark Fasheh 		blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1236dcd0538fSMark Fasheh 		if (blkno == 0) {
1237dcd0538fSMark Fasheh 			ocfs2_error(inode->i_sb,
1238dcd0538fSMark Fasheh 				    "Inode %llu has bad blkno in extent list "
1239dcd0538fSMark Fasheh 				    "at depth %u (index %d)\n",
1240dcd0538fSMark Fasheh 				    (unsigned long long)oi->ip_blkno,
1241dcd0538fSMark Fasheh 				    le16_to_cpu(el->l_tree_depth), i);
1242dcd0538fSMark Fasheh 			ret = -EROFS;
1243dcd0538fSMark Fasheh 			goto out;
1244dcd0538fSMark Fasheh 		}
1245dcd0538fSMark Fasheh 
1246dcd0538fSMark Fasheh 		brelse(bh);
1247dcd0538fSMark Fasheh 		bh = NULL;
1248dcd0538fSMark Fasheh 		ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), blkno,
1249dcd0538fSMark Fasheh 				       &bh, OCFS2_BH_CACHED, inode);
1250dcd0538fSMark Fasheh 		if (ret) {
1251dcd0538fSMark Fasheh 			mlog_errno(ret);
1252dcd0538fSMark Fasheh 			goto out;
1253dcd0538fSMark Fasheh 		}
1254dcd0538fSMark Fasheh 
1255dcd0538fSMark Fasheh 		eb = (struct ocfs2_extent_block *) bh->b_data;
1256dcd0538fSMark Fasheh 		el = &eb->h_list;
1257dcd0538fSMark Fasheh 		if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
1258dcd0538fSMark Fasheh 			OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
1259dcd0538fSMark Fasheh 			ret = -EIO;
1260dcd0538fSMark Fasheh 			goto out;
1261dcd0538fSMark Fasheh 		}
1262dcd0538fSMark Fasheh 
1263dcd0538fSMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) >
1264dcd0538fSMark Fasheh 		    le16_to_cpu(el->l_count)) {
1265dcd0538fSMark Fasheh 			ocfs2_error(inode->i_sb,
1266dcd0538fSMark Fasheh 				    "Inode %llu has bad count in extent list "
1267dcd0538fSMark Fasheh 				    "at block %llu (next free=%u, count=%u)\n",
1268dcd0538fSMark Fasheh 				    (unsigned long long)oi->ip_blkno,
1269dcd0538fSMark Fasheh 				    (unsigned long long)bh->b_blocknr,
1270dcd0538fSMark Fasheh 				    le16_to_cpu(el->l_next_free_rec),
1271dcd0538fSMark Fasheh 				    le16_to_cpu(el->l_count));
1272dcd0538fSMark Fasheh 			ret = -EROFS;
1273dcd0538fSMark Fasheh 			goto out;
1274dcd0538fSMark Fasheh 		}
1275dcd0538fSMark Fasheh 
1276dcd0538fSMark Fasheh 		if (func)
1277dcd0538fSMark Fasheh 			func(data, bh);
1278dcd0538fSMark Fasheh 	}
1279dcd0538fSMark Fasheh 
1280dcd0538fSMark Fasheh out:
1281dcd0538fSMark Fasheh 	/*
1282dcd0538fSMark Fasheh 	 * Catch any trailing bh that the loop didn't handle.
1283dcd0538fSMark Fasheh 	 */
1284dcd0538fSMark Fasheh 	brelse(bh);
1285dcd0538fSMark Fasheh 
1286dcd0538fSMark Fasheh 	return ret;
1287dcd0538fSMark Fasheh }
1288dcd0538fSMark Fasheh 
1289dcd0538fSMark Fasheh /*
1290dcd0538fSMark Fasheh  * Given an initialized path (that is, it has a valid root extent
1291dcd0538fSMark Fasheh  * list), this function will traverse the btree in search of the path
1292dcd0538fSMark Fasheh  * which would contain cpos.
1293dcd0538fSMark Fasheh  *
1294dcd0538fSMark Fasheh  * The path traveled is recorded in the path structure.
1295dcd0538fSMark Fasheh  *
1296dcd0538fSMark Fasheh  * Note that this will not do any comparisons on leaf node extent
1297dcd0538fSMark Fasheh  * records, so it will work fine in the case that we just added a tree
1298dcd0538fSMark Fasheh  * branch.
1299dcd0538fSMark Fasheh  */
1300dcd0538fSMark Fasheh struct find_path_data {
1301dcd0538fSMark Fasheh 	int index;
1302dcd0538fSMark Fasheh 	struct ocfs2_path *path;
1303dcd0538fSMark Fasheh };
1304dcd0538fSMark Fasheh static void find_path_ins(void *data, struct buffer_head *bh)
1305dcd0538fSMark Fasheh {
1306dcd0538fSMark Fasheh 	struct find_path_data *fp = data;
1307dcd0538fSMark Fasheh 
1308dcd0538fSMark Fasheh 	get_bh(bh);
1309dcd0538fSMark Fasheh 	ocfs2_path_insert_eb(fp->path, fp->index, bh);
1310dcd0538fSMark Fasheh 	fp->index++;
1311dcd0538fSMark Fasheh }
1312dcd0538fSMark Fasheh static int ocfs2_find_path(struct inode *inode, struct ocfs2_path *path,
1313dcd0538fSMark Fasheh 			   u32 cpos)
1314dcd0538fSMark Fasheh {
1315dcd0538fSMark Fasheh 	struct find_path_data data;
1316dcd0538fSMark Fasheh 
1317dcd0538fSMark Fasheh 	data.index = 1;
1318dcd0538fSMark Fasheh 	data.path = path;
1319dcd0538fSMark Fasheh 	return __ocfs2_find_path(inode, path_root_el(path), cpos,
1320dcd0538fSMark Fasheh 				 find_path_ins, &data);
1321dcd0538fSMark Fasheh }
1322dcd0538fSMark Fasheh 
1323dcd0538fSMark Fasheh static void find_leaf_ins(void *data, struct buffer_head *bh)
1324dcd0538fSMark Fasheh {
1325dcd0538fSMark Fasheh 	struct ocfs2_extent_block *eb =(struct ocfs2_extent_block *)bh->b_data;
1326dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el = &eb->h_list;
1327dcd0538fSMark Fasheh 	struct buffer_head **ret = data;
1328dcd0538fSMark Fasheh 
1329dcd0538fSMark Fasheh 	/* We want to retain only the leaf block. */
1330dcd0538fSMark Fasheh 	if (le16_to_cpu(el->l_tree_depth) == 0) {
1331dcd0538fSMark Fasheh 		get_bh(bh);
1332dcd0538fSMark Fasheh 		*ret = bh;
1333dcd0538fSMark Fasheh 	}
1334dcd0538fSMark Fasheh }
1335dcd0538fSMark Fasheh /*
1336dcd0538fSMark Fasheh  * Find the leaf block in the tree which would contain cpos. No
1337dcd0538fSMark Fasheh  * checking of the actual leaf is done.
1338dcd0538fSMark Fasheh  *
1339dcd0538fSMark Fasheh  * Some paths want to call this instead of allocating a path structure
1340dcd0538fSMark Fasheh  * and calling ocfs2_find_path().
1341dcd0538fSMark Fasheh  *
1342dcd0538fSMark Fasheh  * This function doesn't handle non btree extent lists.
1343dcd0538fSMark Fasheh  */
1344363041a5SMark Fasheh int ocfs2_find_leaf(struct inode *inode, struct ocfs2_extent_list *root_el,
1345363041a5SMark Fasheh 		    u32 cpos, struct buffer_head **leaf_bh)
1346dcd0538fSMark Fasheh {
1347dcd0538fSMark Fasheh 	int ret;
1348dcd0538fSMark Fasheh 	struct buffer_head *bh = NULL;
1349dcd0538fSMark Fasheh 
1350dcd0538fSMark Fasheh 	ret = __ocfs2_find_path(inode, root_el, cpos, find_leaf_ins, &bh);
1351dcd0538fSMark Fasheh 	if (ret) {
1352dcd0538fSMark Fasheh 		mlog_errno(ret);
1353dcd0538fSMark Fasheh 		goto out;
1354dcd0538fSMark Fasheh 	}
1355dcd0538fSMark Fasheh 
1356dcd0538fSMark Fasheh 	*leaf_bh = bh;
1357dcd0538fSMark Fasheh out:
1358dcd0538fSMark Fasheh 	return ret;
1359dcd0538fSMark Fasheh }
1360dcd0538fSMark Fasheh 
1361dcd0538fSMark Fasheh /*
1362dcd0538fSMark Fasheh  * Adjust the adjacent records (left_rec, right_rec) involved in a rotation.
1363dcd0538fSMark Fasheh  *
1364dcd0538fSMark Fasheh  * Basically, we've moved stuff around at the bottom of the tree and
1365dcd0538fSMark Fasheh  * we need to fix up the extent records above the changes to reflect
1366dcd0538fSMark Fasheh  * the new changes.
1367dcd0538fSMark Fasheh  *
1368dcd0538fSMark Fasheh  * left_rec: the record on the left.
1369dcd0538fSMark Fasheh  * left_child_el: is the child list pointed to by left_rec
1370dcd0538fSMark Fasheh  * right_rec: the record to the right of left_rec
1371dcd0538fSMark Fasheh  * right_child_el: is the child list pointed to by right_rec
1372dcd0538fSMark Fasheh  *
1373dcd0538fSMark Fasheh  * By definition, this only works on interior nodes.
1374dcd0538fSMark Fasheh  */
1375dcd0538fSMark Fasheh static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec,
1376dcd0538fSMark Fasheh 				  struct ocfs2_extent_list *left_child_el,
1377dcd0538fSMark Fasheh 				  struct ocfs2_extent_rec *right_rec,
1378dcd0538fSMark Fasheh 				  struct ocfs2_extent_list *right_child_el)
1379dcd0538fSMark Fasheh {
1380dcd0538fSMark Fasheh 	u32 left_clusters, right_end;
1381dcd0538fSMark Fasheh 
1382dcd0538fSMark Fasheh 	/*
1383dcd0538fSMark Fasheh 	 * Interior nodes never have holes. Their cpos is the cpos of
1384dcd0538fSMark Fasheh 	 * the leftmost record in their child list. Their cluster
1385dcd0538fSMark Fasheh 	 * count covers the full theoretical range of their child list
1386dcd0538fSMark Fasheh 	 * - the range between their cpos and the cpos of the record
1387dcd0538fSMark Fasheh 	 * immediately to their right.
1388dcd0538fSMark Fasheh 	 */
1389dcd0538fSMark Fasheh 	left_clusters = le32_to_cpu(right_child_el->l_recs[0].e_cpos);
1390328d5752SMark Fasheh 	if (ocfs2_is_empty_extent(&right_child_el->l_recs[0])) {
1391328d5752SMark Fasheh 		BUG_ON(le16_to_cpu(right_child_el->l_next_free_rec) <= 1);
1392328d5752SMark Fasheh 		left_clusters = le32_to_cpu(right_child_el->l_recs[1].e_cpos);
1393328d5752SMark Fasheh 	}
1394dcd0538fSMark Fasheh 	left_clusters -= le32_to_cpu(left_rec->e_cpos);
1395e48edee2SMark Fasheh 	left_rec->e_int_clusters = cpu_to_le32(left_clusters);
1396dcd0538fSMark Fasheh 
1397dcd0538fSMark Fasheh 	/*
1398dcd0538fSMark Fasheh 	 * Calculate the rightmost cluster count boundary before
1399e48edee2SMark Fasheh 	 * moving cpos - we will need to adjust clusters after
1400dcd0538fSMark Fasheh 	 * updating e_cpos to keep the same highest cluster count.
1401dcd0538fSMark Fasheh 	 */
1402dcd0538fSMark Fasheh 	right_end = le32_to_cpu(right_rec->e_cpos);
1403e48edee2SMark Fasheh 	right_end += le32_to_cpu(right_rec->e_int_clusters);
1404dcd0538fSMark Fasheh 
1405dcd0538fSMark Fasheh 	right_rec->e_cpos = left_rec->e_cpos;
1406dcd0538fSMark Fasheh 	le32_add_cpu(&right_rec->e_cpos, left_clusters);
1407dcd0538fSMark Fasheh 
1408dcd0538fSMark Fasheh 	right_end -= le32_to_cpu(right_rec->e_cpos);
1409e48edee2SMark Fasheh 	right_rec->e_int_clusters = cpu_to_le32(right_end);
1410dcd0538fSMark Fasheh }
1411dcd0538fSMark Fasheh 
1412dcd0538fSMark Fasheh /*
1413dcd0538fSMark Fasheh  * Adjust the adjacent root node records involved in a
1414dcd0538fSMark Fasheh  * rotation. left_el_blkno is passed in as a key so that we can easily
1415dcd0538fSMark Fasheh  * find it's index in the root list.
1416dcd0538fSMark Fasheh  */
1417dcd0538fSMark Fasheh static void ocfs2_adjust_root_records(struct ocfs2_extent_list *root_el,
1418dcd0538fSMark Fasheh 				      struct ocfs2_extent_list *left_el,
1419dcd0538fSMark Fasheh 				      struct ocfs2_extent_list *right_el,
1420dcd0538fSMark Fasheh 				      u64 left_el_blkno)
1421dcd0538fSMark Fasheh {
1422dcd0538fSMark Fasheh 	int i;
1423dcd0538fSMark Fasheh 
1424dcd0538fSMark Fasheh 	BUG_ON(le16_to_cpu(root_el->l_tree_depth) <=
1425dcd0538fSMark Fasheh 	       le16_to_cpu(left_el->l_tree_depth));
1426dcd0538fSMark Fasheh 
1427dcd0538fSMark Fasheh 	for(i = 0; i < le16_to_cpu(root_el->l_next_free_rec) - 1; i++) {
1428dcd0538fSMark Fasheh 		if (le64_to_cpu(root_el->l_recs[i].e_blkno) == left_el_blkno)
1429dcd0538fSMark Fasheh 			break;
1430dcd0538fSMark Fasheh 	}
1431dcd0538fSMark Fasheh 
1432dcd0538fSMark Fasheh 	/*
1433dcd0538fSMark Fasheh 	 * The path walking code should have never returned a root and
1434dcd0538fSMark Fasheh 	 * two paths which are not adjacent.
1435dcd0538fSMark Fasheh 	 */
1436dcd0538fSMark Fasheh 	BUG_ON(i >= (le16_to_cpu(root_el->l_next_free_rec) - 1));
1437dcd0538fSMark Fasheh 
1438dcd0538fSMark Fasheh 	ocfs2_adjust_adjacent_records(&root_el->l_recs[i], left_el,
1439dcd0538fSMark Fasheh 				      &root_el->l_recs[i + 1], right_el);
1440dcd0538fSMark Fasheh }
1441dcd0538fSMark Fasheh 
1442dcd0538fSMark Fasheh /*
1443dcd0538fSMark Fasheh  * We've changed a leaf block (in right_path) and need to reflect that
1444dcd0538fSMark Fasheh  * change back up the subtree.
1445dcd0538fSMark Fasheh  *
1446dcd0538fSMark Fasheh  * This happens in multiple places:
1447dcd0538fSMark Fasheh  *   - When we've moved an extent record from the left path leaf to the right
1448dcd0538fSMark Fasheh  *     path leaf to make room for an empty extent in the left path leaf.
1449dcd0538fSMark Fasheh  *   - When our insert into the right path leaf is at the leftmost edge
1450dcd0538fSMark Fasheh  *     and requires an update of the path immediately to it's left. This
1451dcd0538fSMark Fasheh  *     can occur at the end of some types of rotation and appending inserts.
1452677b9752STao Ma  *   - When we've adjusted the last extent record in the left path leaf and the
1453677b9752STao Ma  *     1st extent record in the right path leaf during cross extent block merge.
1454dcd0538fSMark Fasheh  */
1455dcd0538fSMark Fasheh static void ocfs2_complete_edge_insert(struct inode *inode, handle_t *handle,
1456dcd0538fSMark Fasheh 				       struct ocfs2_path *left_path,
1457dcd0538fSMark Fasheh 				       struct ocfs2_path *right_path,
1458dcd0538fSMark Fasheh 				       int subtree_index)
1459dcd0538fSMark Fasheh {
1460dcd0538fSMark Fasheh 	int ret, i, idx;
1461dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el, *left_el, *right_el;
1462dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *left_rec, *right_rec;
1463dcd0538fSMark Fasheh 	struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
1464dcd0538fSMark Fasheh 
1465dcd0538fSMark Fasheh 	/*
1466dcd0538fSMark Fasheh 	 * Update the counts and position values within all the
1467dcd0538fSMark Fasheh 	 * interior nodes to reflect the leaf rotation we just did.
1468dcd0538fSMark Fasheh 	 *
1469dcd0538fSMark Fasheh 	 * The root node is handled below the loop.
1470dcd0538fSMark Fasheh 	 *
1471dcd0538fSMark Fasheh 	 * We begin the loop with right_el and left_el pointing to the
1472dcd0538fSMark Fasheh 	 * leaf lists and work our way up.
1473dcd0538fSMark Fasheh 	 *
1474dcd0538fSMark Fasheh 	 * NOTE: within this loop, left_el and right_el always refer
1475dcd0538fSMark Fasheh 	 * to the *child* lists.
1476dcd0538fSMark Fasheh 	 */
1477dcd0538fSMark Fasheh 	left_el = path_leaf_el(left_path);
1478dcd0538fSMark Fasheh 	right_el = path_leaf_el(right_path);
1479dcd0538fSMark Fasheh 	for(i = left_path->p_tree_depth - 1; i > subtree_index; i--) {
1480dcd0538fSMark Fasheh 		mlog(0, "Adjust records at index %u\n", i);
1481dcd0538fSMark Fasheh 
1482dcd0538fSMark Fasheh 		/*
1483dcd0538fSMark Fasheh 		 * One nice property of knowing that all of these
1484dcd0538fSMark Fasheh 		 * nodes are below the root is that we only deal with
1485dcd0538fSMark Fasheh 		 * the leftmost right node record and the rightmost
1486dcd0538fSMark Fasheh 		 * left node record.
1487dcd0538fSMark Fasheh 		 */
1488dcd0538fSMark Fasheh 		el = left_path->p_node[i].el;
1489dcd0538fSMark Fasheh 		idx = le16_to_cpu(left_el->l_next_free_rec) - 1;
1490dcd0538fSMark Fasheh 		left_rec = &el->l_recs[idx];
1491dcd0538fSMark Fasheh 
1492dcd0538fSMark Fasheh 		el = right_path->p_node[i].el;
1493dcd0538fSMark Fasheh 		right_rec = &el->l_recs[0];
1494dcd0538fSMark Fasheh 
1495dcd0538fSMark Fasheh 		ocfs2_adjust_adjacent_records(left_rec, left_el, right_rec,
1496dcd0538fSMark Fasheh 					      right_el);
1497dcd0538fSMark Fasheh 
1498dcd0538fSMark Fasheh 		ret = ocfs2_journal_dirty(handle, left_path->p_node[i].bh);
1499dcd0538fSMark Fasheh 		if (ret)
1500dcd0538fSMark Fasheh 			mlog_errno(ret);
1501dcd0538fSMark Fasheh 
1502dcd0538fSMark Fasheh 		ret = ocfs2_journal_dirty(handle, right_path->p_node[i].bh);
1503dcd0538fSMark Fasheh 		if (ret)
1504dcd0538fSMark Fasheh 			mlog_errno(ret);
1505dcd0538fSMark Fasheh 
1506dcd0538fSMark Fasheh 		/*
1507dcd0538fSMark Fasheh 		 * Setup our list pointers now so that the current
1508dcd0538fSMark Fasheh 		 * parents become children in the next iteration.
1509dcd0538fSMark Fasheh 		 */
1510dcd0538fSMark Fasheh 		left_el = left_path->p_node[i].el;
1511dcd0538fSMark Fasheh 		right_el = right_path->p_node[i].el;
1512dcd0538fSMark Fasheh 	}
1513dcd0538fSMark Fasheh 
1514dcd0538fSMark Fasheh 	/*
1515dcd0538fSMark Fasheh 	 * At the root node, adjust the two adjacent records which
1516dcd0538fSMark Fasheh 	 * begin our path to the leaves.
1517dcd0538fSMark Fasheh 	 */
1518dcd0538fSMark Fasheh 
1519dcd0538fSMark Fasheh 	el = left_path->p_node[subtree_index].el;
1520dcd0538fSMark Fasheh 	left_el = left_path->p_node[subtree_index + 1].el;
1521dcd0538fSMark Fasheh 	right_el = right_path->p_node[subtree_index + 1].el;
1522dcd0538fSMark Fasheh 
1523dcd0538fSMark Fasheh 	ocfs2_adjust_root_records(el, left_el, right_el,
1524dcd0538fSMark Fasheh 				  left_path->p_node[subtree_index + 1].bh->b_blocknr);
1525dcd0538fSMark Fasheh 
1526dcd0538fSMark Fasheh 	root_bh = left_path->p_node[subtree_index].bh;
1527dcd0538fSMark Fasheh 
1528dcd0538fSMark Fasheh 	ret = ocfs2_journal_dirty(handle, root_bh);
1529dcd0538fSMark Fasheh 	if (ret)
1530dcd0538fSMark Fasheh 		mlog_errno(ret);
1531dcd0538fSMark Fasheh }
1532dcd0538fSMark Fasheh 
1533dcd0538fSMark Fasheh static int ocfs2_rotate_subtree_right(struct inode *inode,
1534dcd0538fSMark Fasheh 				      handle_t *handle,
1535dcd0538fSMark Fasheh 				      struct ocfs2_path *left_path,
1536dcd0538fSMark Fasheh 				      struct ocfs2_path *right_path,
1537dcd0538fSMark Fasheh 				      int subtree_index)
1538dcd0538fSMark Fasheh {
1539dcd0538fSMark Fasheh 	int ret, i;
1540dcd0538fSMark Fasheh 	struct buffer_head *right_leaf_bh;
1541dcd0538fSMark Fasheh 	struct buffer_head *left_leaf_bh = NULL;
1542dcd0538fSMark Fasheh 	struct buffer_head *root_bh;
1543dcd0538fSMark Fasheh 	struct ocfs2_extent_list *right_el, *left_el;
1544dcd0538fSMark Fasheh 	struct ocfs2_extent_rec move_rec;
1545dcd0538fSMark Fasheh 
1546dcd0538fSMark Fasheh 	left_leaf_bh = path_leaf_bh(left_path);
1547dcd0538fSMark Fasheh 	left_el = path_leaf_el(left_path);
1548dcd0538fSMark Fasheh 
1549dcd0538fSMark Fasheh 	if (left_el->l_next_free_rec != left_el->l_count) {
1550dcd0538fSMark Fasheh 		ocfs2_error(inode->i_sb,
1551dcd0538fSMark Fasheh 			    "Inode %llu has non-full interior leaf node %llu"
1552dcd0538fSMark Fasheh 			    "(next free = %u)",
1553dcd0538fSMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
1554dcd0538fSMark Fasheh 			    (unsigned long long)left_leaf_bh->b_blocknr,
1555dcd0538fSMark Fasheh 			    le16_to_cpu(left_el->l_next_free_rec));
1556dcd0538fSMark Fasheh 		return -EROFS;
1557dcd0538fSMark Fasheh 	}
1558dcd0538fSMark Fasheh 
1559dcd0538fSMark Fasheh 	/*
1560dcd0538fSMark Fasheh 	 * This extent block may already have an empty record, so we
1561dcd0538fSMark Fasheh 	 * return early if so.
1562dcd0538fSMark Fasheh 	 */
1563dcd0538fSMark Fasheh 	if (ocfs2_is_empty_extent(&left_el->l_recs[0]))
1564dcd0538fSMark Fasheh 		return 0;
1565dcd0538fSMark Fasheh 
1566dcd0538fSMark Fasheh 	root_bh = left_path->p_node[subtree_index].bh;
1567dcd0538fSMark Fasheh 	BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
1568dcd0538fSMark Fasheh 
1569dcd0538fSMark Fasheh 	ret = ocfs2_journal_access(handle, inode, root_bh,
1570dcd0538fSMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
1571dcd0538fSMark Fasheh 	if (ret) {
1572dcd0538fSMark Fasheh 		mlog_errno(ret);
1573dcd0538fSMark Fasheh 		goto out;
1574dcd0538fSMark Fasheh 	}
1575dcd0538fSMark Fasheh 
1576dcd0538fSMark Fasheh 	for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
1577dcd0538fSMark Fasheh 		ret = ocfs2_journal_access(handle, inode,
1578dcd0538fSMark Fasheh 					   right_path->p_node[i].bh,
1579dcd0538fSMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
1580dcd0538fSMark Fasheh 		if (ret) {
1581dcd0538fSMark Fasheh 			mlog_errno(ret);
1582dcd0538fSMark Fasheh 			goto out;
1583dcd0538fSMark Fasheh 		}
1584dcd0538fSMark Fasheh 
1585dcd0538fSMark Fasheh 		ret = ocfs2_journal_access(handle, inode,
1586dcd0538fSMark Fasheh 					   left_path->p_node[i].bh,
1587dcd0538fSMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
1588dcd0538fSMark Fasheh 		if (ret) {
1589dcd0538fSMark Fasheh 			mlog_errno(ret);
1590dcd0538fSMark Fasheh 			goto out;
1591dcd0538fSMark Fasheh 		}
1592dcd0538fSMark Fasheh 	}
1593dcd0538fSMark Fasheh 
1594dcd0538fSMark Fasheh 	right_leaf_bh = path_leaf_bh(right_path);
1595dcd0538fSMark Fasheh 	right_el = path_leaf_el(right_path);
1596dcd0538fSMark Fasheh 
1597dcd0538fSMark Fasheh 	/* This is a code error, not a disk corruption. */
1598dcd0538fSMark Fasheh 	mlog_bug_on_msg(!right_el->l_next_free_rec, "Inode %llu: Rotate fails "
1599dcd0538fSMark Fasheh 			"because rightmost leaf block %llu is empty\n",
1600dcd0538fSMark Fasheh 			(unsigned long long)OCFS2_I(inode)->ip_blkno,
1601dcd0538fSMark Fasheh 			(unsigned long long)right_leaf_bh->b_blocknr);
1602dcd0538fSMark Fasheh 
1603dcd0538fSMark Fasheh 	ocfs2_create_empty_extent(right_el);
1604dcd0538fSMark Fasheh 
1605dcd0538fSMark Fasheh 	ret = ocfs2_journal_dirty(handle, right_leaf_bh);
1606dcd0538fSMark Fasheh 	if (ret) {
1607dcd0538fSMark Fasheh 		mlog_errno(ret);
1608dcd0538fSMark Fasheh 		goto out;
1609dcd0538fSMark Fasheh 	}
1610dcd0538fSMark Fasheh 
1611dcd0538fSMark Fasheh 	/* Do the copy now. */
1612dcd0538fSMark Fasheh 	i = le16_to_cpu(left_el->l_next_free_rec) - 1;
1613dcd0538fSMark Fasheh 	move_rec = left_el->l_recs[i];
1614dcd0538fSMark Fasheh 	right_el->l_recs[0] = move_rec;
1615dcd0538fSMark Fasheh 
1616dcd0538fSMark Fasheh 	/*
1617dcd0538fSMark Fasheh 	 * Clear out the record we just copied and shift everything
1618dcd0538fSMark Fasheh 	 * over, leaving an empty extent in the left leaf.
1619dcd0538fSMark Fasheh 	 *
1620dcd0538fSMark Fasheh 	 * We temporarily subtract from next_free_rec so that the
1621dcd0538fSMark Fasheh 	 * shift will lose the tail record (which is now defunct).
1622dcd0538fSMark Fasheh 	 */
1623dcd0538fSMark Fasheh 	le16_add_cpu(&left_el->l_next_free_rec, -1);
1624dcd0538fSMark Fasheh 	ocfs2_shift_records_right(left_el);
1625dcd0538fSMark Fasheh 	memset(&left_el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
1626dcd0538fSMark Fasheh 	le16_add_cpu(&left_el->l_next_free_rec, 1);
1627dcd0538fSMark Fasheh 
1628dcd0538fSMark Fasheh 	ret = ocfs2_journal_dirty(handle, left_leaf_bh);
1629dcd0538fSMark Fasheh 	if (ret) {
1630dcd0538fSMark Fasheh 		mlog_errno(ret);
1631dcd0538fSMark Fasheh 		goto out;
1632dcd0538fSMark Fasheh 	}
1633dcd0538fSMark Fasheh 
1634dcd0538fSMark Fasheh 	ocfs2_complete_edge_insert(inode, handle, left_path, right_path,
1635dcd0538fSMark Fasheh 				subtree_index);
1636dcd0538fSMark Fasheh 
1637dcd0538fSMark Fasheh out:
1638dcd0538fSMark Fasheh 	return ret;
1639dcd0538fSMark Fasheh }
1640dcd0538fSMark Fasheh 
1641dcd0538fSMark Fasheh /*
1642dcd0538fSMark Fasheh  * Given a full path, determine what cpos value would return us a path
1643dcd0538fSMark Fasheh  * containing the leaf immediately to the left of the current one.
1644dcd0538fSMark Fasheh  *
1645dcd0538fSMark Fasheh  * Will return zero if the path passed in is already the leftmost path.
1646dcd0538fSMark Fasheh  */
1647dcd0538fSMark Fasheh static int ocfs2_find_cpos_for_left_leaf(struct super_block *sb,
1648dcd0538fSMark Fasheh 					 struct ocfs2_path *path, u32 *cpos)
1649dcd0538fSMark Fasheh {
1650dcd0538fSMark Fasheh 	int i, j, ret = 0;
1651dcd0538fSMark Fasheh 	u64 blkno;
1652dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el;
1653dcd0538fSMark Fasheh 
1654e48edee2SMark Fasheh 	BUG_ON(path->p_tree_depth == 0);
1655e48edee2SMark Fasheh 
1656dcd0538fSMark Fasheh 	*cpos = 0;
1657dcd0538fSMark Fasheh 
1658dcd0538fSMark Fasheh 	blkno = path_leaf_bh(path)->b_blocknr;
1659dcd0538fSMark Fasheh 
1660dcd0538fSMark Fasheh 	/* Start at the tree node just above the leaf and work our way up. */
1661dcd0538fSMark Fasheh 	i = path->p_tree_depth - 1;
1662dcd0538fSMark Fasheh 	while (i >= 0) {
1663dcd0538fSMark Fasheh 		el = path->p_node[i].el;
1664dcd0538fSMark Fasheh 
1665dcd0538fSMark Fasheh 		/*
1666dcd0538fSMark Fasheh 		 * Find the extent record just before the one in our
1667dcd0538fSMark Fasheh 		 * path.
1668dcd0538fSMark Fasheh 		 */
1669dcd0538fSMark Fasheh 		for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
1670dcd0538fSMark Fasheh 			if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
1671dcd0538fSMark Fasheh 				if (j == 0) {
1672dcd0538fSMark Fasheh 					if (i == 0) {
1673dcd0538fSMark Fasheh 						/*
1674dcd0538fSMark Fasheh 						 * We've determined that the
1675dcd0538fSMark Fasheh 						 * path specified is already
1676dcd0538fSMark Fasheh 						 * the leftmost one - return a
1677dcd0538fSMark Fasheh 						 * cpos of zero.
1678dcd0538fSMark Fasheh 						 */
1679dcd0538fSMark Fasheh 						goto out;
1680dcd0538fSMark Fasheh 					}
1681dcd0538fSMark Fasheh 					/*
1682dcd0538fSMark Fasheh 					 * The leftmost record points to our
1683dcd0538fSMark Fasheh 					 * leaf - we need to travel up the
1684dcd0538fSMark Fasheh 					 * tree one level.
1685dcd0538fSMark Fasheh 					 */
1686dcd0538fSMark Fasheh 					goto next_node;
1687dcd0538fSMark Fasheh 				}
1688dcd0538fSMark Fasheh 
1689dcd0538fSMark Fasheh 				*cpos = le32_to_cpu(el->l_recs[j - 1].e_cpos);
1690e48edee2SMark Fasheh 				*cpos = *cpos + ocfs2_rec_clusters(el,
1691e48edee2SMark Fasheh 							   &el->l_recs[j - 1]);
1692e48edee2SMark Fasheh 				*cpos = *cpos - 1;
1693dcd0538fSMark Fasheh 				goto out;
1694dcd0538fSMark Fasheh 			}
1695dcd0538fSMark Fasheh 		}
1696dcd0538fSMark Fasheh 
1697dcd0538fSMark Fasheh 		/*
1698dcd0538fSMark Fasheh 		 * If we got here, we never found a valid node where
1699dcd0538fSMark Fasheh 		 * the tree indicated one should be.
1700dcd0538fSMark Fasheh 		 */
1701dcd0538fSMark Fasheh 		ocfs2_error(sb,
1702dcd0538fSMark Fasheh 			    "Invalid extent tree at extent block %llu\n",
1703dcd0538fSMark Fasheh 			    (unsigned long long)blkno);
1704dcd0538fSMark Fasheh 		ret = -EROFS;
1705dcd0538fSMark Fasheh 		goto out;
1706dcd0538fSMark Fasheh 
1707dcd0538fSMark Fasheh next_node:
1708dcd0538fSMark Fasheh 		blkno = path->p_node[i].bh->b_blocknr;
1709dcd0538fSMark Fasheh 		i--;
1710dcd0538fSMark Fasheh 	}
1711dcd0538fSMark Fasheh 
1712dcd0538fSMark Fasheh out:
1713dcd0538fSMark Fasheh 	return ret;
1714dcd0538fSMark Fasheh }
1715dcd0538fSMark Fasheh 
1716328d5752SMark Fasheh /*
1717328d5752SMark Fasheh  * Extend the transaction by enough credits to complete the rotation,
1718328d5752SMark Fasheh  * and still leave at least the original number of credits allocated
1719328d5752SMark Fasheh  * to this transaction.
1720328d5752SMark Fasheh  */
1721dcd0538fSMark Fasheh static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth,
1722328d5752SMark Fasheh 					   int op_credits,
1723dcd0538fSMark Fasheh 					   struct ocfs2_path *path)
1724dcd0538fSMark Fasheh {
1725328d5752SMark Fasheh 	int credits = (path->p_tree_depth - subtree_depth) * 2 + 1 + op_credits;
1726dcd0538fSMark Fasheh 
1727dcd0538fSMark Fasheh 	if (handle->h_buffer_credits < credits)
1728dcd0538fSMark Fasheh 		return ocfs2_extend_trans(handle, credits);
1729dcd0538fSMark Fasheh 
1730dcd0538fSMark Fasheh 	return 0;
1731dcd0538fSMark Fasheh }
1732dcd0538fSMark Fasheh 
1733dcd0538fSMark Fasheh /*
1734dcd0538fSMark Fasheh  * Trap the case where we're inserting into the theoretical range past
1735dcd0538fSMark Fasheh  * the _actual_ left leaf range. Otherwise, we'll rotate a record
1736dcd0538fSMark Fasheh  * whose cpos is less than ours into the right leaf.
1737dcd0538fSMark Fasheh  *
1738dcd0538fSMark Fasheh  * It's only necessary to look at the rightmost record of the left
1739dcd0538fSMark Fasheh  * leaf because the logic that calls us should ensure that the
1740dcd0538fSMark Fasheh  * theoretical ranges in the path components above the leaves are
1741dcd0538fSMark Fasheh  * correct.
1742dcd0538fSMark Fasheh  */
1743dcd0538fSMark Fasheh static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path,
1744dcd0538fSMark Fasheh 						 u32 insert_cpos)
1745dcd0538fSMark Fasheh {
1746dcd0538fSMark Fasheh 	struct ocfs2_extent_list *left_el;
1747dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *rec;
1748dcd0538fSMark Fasheh 	int next_free;
1749dcd0538fSMark Fasheh 
1750dcd0538fSMark Fasheh 	left_el = path_leaf_el(left_path);
1751dcd0538fSMark Fasheh 	next_free = le16_to_cpu(left_el->l_next_free_rec);
1752dcd0538fSMark Fasheh 	rec = &left_el->l_recs[next_free - 1];
1753dcd0538fSMark Fasheh 
1754dcd0538fSMark Fasheh 	if (insert_cpos > le32_to_cpu(rec->e_cpos))
1755dcd0538fSMark Fasheh 		return 1;
1756dcd0538fSMark Fasheh 	return 0;
1757dcd0538fSMark Fasheh }
1758dcd0538fSMark Fasheh 
1759328d5752SMark Fasheh static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos)
1760328d5752SMark Fasheh {
1761328d5752SMark Fasheh 	int next_free = le16_to_cpu(el->l_next_free_rec);
1762328d5752SMark Fasheh 	unsigned int range;
1763328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec;
1764328d5752SMark Fasheh 
1765328d5752SMark Fasheh 	if (next_free == 0)
1766328d5752SMark Fasheh 		return 0;
1767328d5752SMark Fasheh 
1768328d5752SMark Fasheh 	rec = &el->l_recs[0];
1769328d5752SMark Fasheh 	if (ocfs2_is_empty_extent(rec)) {
1770328d5752SMark Fasheh 		/* Empty list. */
1771328d5752SMark Fasheh 		if (next_free == 1)
1772328d5752SMark Fasheh 			return 0;
1773328d5752SMark Fasheh 		rec = &el->l_recs[1];
1774328d5752SMark Fasheh 	}
1775328d5752SMark Fasheh 
1776328d5752SMark Fasheh 	range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
1777328d5752SMark Fasheh 	if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
1778328d5752SMark Fasheh 		return 1;
1779328d5752SMark Fasheh 	return 0;
1780328d5752SMark Fasheh }
1781328d5752SMark Fasheh 
1782dcd0538fSMark Fasheh /*
1783dcd0538fSMark Fasheh  * Rotate all the records in a btree right one record, starting at insert_cpos.
1784dcd0538fSMark Fasheh  *
1785dcd0538fSMark Fasheh  * The path to the rightmost leaf should be passed in.
1786dcd0538fSMark Fasheh  *
1787dcd0538fSMark Fasheh  * The array is assumed to be large enough to hold an entire path (tree depth).
1788dcd0538fSMark Fasheh  *
1789dcd0538fSMark Fasheh  * Upon succesful return from this function:
1790dcd0538fSMark Fasheh  *
1791dcd0538fSMark Fasheh  * - The 'right_path' array will contain a path to the leaf block
1792dcd0538fSMark Fasheh  *   whose range contains e_cpos.
1793dcd0538fSMark Fasheh  * - That leaf block will have a single empty extent in list index 0.
1794dcd0538fSMark Fasheh  * - In the case that the rotation requires a post-insert update,
1795dcd0538fSMark Fasheh  *   *ret_left_path will contain a valid path which can be passed to
1796dcd0538fSMark Fasheh  *   ocfs2_insert_path().
1797dcd0538fSMark Fasheh  */
1798dcd0538fSMark Fasheh static int ocfs2_rotate_tree_right(struct inode *inode,
1799dcd0538fSMark Fasheh 				   handle_t *handle,
1800328d5752SMark Fasheh 				   enum ocfs2_split_type split,
1801dcd0538fSMark Fasheh 				   u32 insert_cpos,
1802dcd0538fSMark Fasheh 				   struct ocfs2_path *right_path,
1803dcd0538fSMark Fasheh 				   struct ocfs2_path **ret_left_path)
1804dcd0538fSMark Fasheh {
1805328d5752SMark Fasheh 	int ret, start, orig_credits = handle->h_buffer_credits;
1806dcd0538fSMark Fasheh 	u32 cpos;
1807dcd0538fSMark Fasheh 	struct ocfs2_path *left_path = NULL;
1808dcd0538fSMark Fasheh 
1809dcd0538fSMark Fasheh 	*ret_left_path = NULL;
1810dcd0538fSMark Fasheh 
1811dcd0538fSMark Fasheh 	left_path = ocfs2_new_path(path_root_bh(right_path),
1812dcd0538fSMark Fasheh 				   path_root_el(right_path));
1813dcd0538fSMark Fasheh 	if (!left_path) {
1814dcd0538fSMark Fasheh 		ret = -ENOMEM;
1815dcd0538fSMark Fasheh 		mlog_errno(ret);
1816dcd0538fSMark Fasheh 		goto out;
1817dcd0538fSMark Fasheh 	}
1818dcd0538fSMark Fasheh 
1819dcd0538fSMark Fasheh 	ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path, &cpos);
1820dcd0538fSMark Fasheh 	if (ret) {
1821dcd0538fSMark Fasheh 		mlog_errno(ret);
1822dcd0538fSMark Fasheh 		goto out;
1823dcd0538fSMark Fasheh 	}
1824dcd0538fSMark Fasheh 
1825dcd0538fSMark Fasheh 	mlog(0, "Insert: %u, first left path cpos: %u\n", insert_cpos, cpos);
1826dcd0538fSMark Fasheh 
1827dcd0538fSMark Fasheh 	/*
1828dcd0538fSMark Fasheh 	 * What we want to do here is:
1829dcd0538fSMark Fasheh 	 *
1830dcd0538fSMark Fasheh 	 * 1) Start with the rightmost path.
1831dcd0538fSMark Fasheh 	 *
1832dcd0538fSMark Fasheh 	 * 2) Determine a path to the leaf block directly to the left
1833dcd0538fSMark Fasheh 	 *    of that leaf.
1834dcd0538fSMark Fasheh 	 *
1835dcd0538fSMark Fasheh 	 * 3) Determine the 'subtree root' - the lowest level tree node
1836dcd0538fSMark Fasheh 	 *    which contains a path to both leaves.
1837dcd0538fSMark Fasheh 	 *
1838dcd0538fSMark Fasheh 	 * 4) Rotate the subtree.
1839dcd0538fSMark Fasheh 	 *
1840dcd0538fSMark Fasheh 	 * 5) Find the next subtree by considering the left path to be
1841dcd0538fSMark Fasheh 	 *    the new right path.
1842dcd0538fSMark Fasheh 	 *
1843dcd0538fSMark Fasheh 	 * The check at the top of this while loop also accepts
1844dcd0538fSMark Fasheh 	 * insert_cpos == cpos because cpos is only a _theoretical_
1845dcd0538fSMark Fasheh 	 * value to get us the left path - insert_cpos might very well
1846dcd0538fSMark Fasheh 	 * be filling that hole.
1847dcd0538fSMark Fasheh 	 *
1848dcd0538fSMark Fasheh 	 * Stop at a cpos of '0' because we either started at the
1849dcd0538fSMark Fasheh 	 * leftmost branch (i.e., a tree with one branch and a
1850dcd0538fSMark Fasheh 	 * rotation inside of it), or we've gone as far as we can in
1851dcd0538fSMark Fasheh 	 * rotating subtrees.
1852dcd0538fSMark Fasheh 	 */
1853dcd0538fSMark Fasheh 	while (cpos && insert_cpos <= cpos) {
1854dcd0538fSMark Fasheh 		mlog(0, "Rotating a tree: ins. cpos: %u, left path cpos: %u\n",
1855dcd0538fSMark Fasheh 		     insert_cpos, cpos);
1856dcd0538fSMark Fasheh 
1857dcd0538fSMark Fasheh 		ret = ocfs2_find_path(inode, left_path, cpos);
1858dcd0538fSMark Fasheh 		if (ret) {
1859dcd0538fSMark Fasheh 			mlog_errno(ret);
1860dcd0538fSMark Fasheh 			goto out;
1861dcd0538fSMark Fasheh 		}
1862dcd0538fSMark Fasheh 
1863dcd0538fSMark Fasheh 		mlog_bug_on_msg(path_leaf_bh(left_path) ==
1864dcd0538fSMark Fasheh 				path_leaf_bh(right_path),
1865dcd0538fSMark Fasheh 				"Inode %lu: error during insert of %u "
1866dcd0538fSMark Fasheh 				"(left path cpos %u) results in two identical "
1867dcd0538fSMark Fasheh 				"paths ending at %llu\n",
1868dcd0538fSMark Fasheh 				inode->i_ino, insert_cpos, cpos,
1869dcd0538fSMark Fasheh 				(unsigned long long)
1870dcd0538fSMark Fasheh 				path_leaf_bh(left_path)->b_blocknr);
1871dcd0538fSMark Fasheh 
1872328d5752SMark Fasheh 		if (split == SPLIT_NONE &&
1873328d5752SMark Fasheh 		    ocfs2_rotate_requires_path_adjustment(left_path,
1874dcd0538fSMark Fasheh 							  insert_cpos)) {
1875dcd0538fSMark Fasheh 
1876dcd0538fSMark Fasheh 			/*
1877dcd0538fSMark Fasheh 			 * We've rotated the tree as much as we
1878dcd0538fSMark Fasheh 			 * should. The rest is up to
1879dcd0538fSMark Fasheh 			 * ocfs2_insert_path() to complete, after the
1880dcd0538fSMark Fasheh 			 * record insertion. We indicate this
1881dcd0538fSMark Fasheh 			 * situation by returning the left path.
1882dcd0538fSMark Fasheh 			 *
1883dcd0538fSMark Fasheh 			 * The reason we don't adjust the records here
1884dcd0538fSMark Fasheh 			 * before the record insert is that an error
1885dcd0538fSMark Fasheh 			 * later might break the rule where a parent
1886dcd0538fSMark Fasheh 			 * record e_cpos will reflect the actual
1887dcd0538fSMark Fasheh 			 * e_cpos of the 1st nonempty record of the
1888dcd0538fSMark Fasheh 			 * child list.
1889dcd0538fSMark Fasheh 			 */
1890dcd0538fSMark Fasheh 			*ret_left_path = left_path;
1891dcd0538fSMark Fasheh 			goto out_ret_path;
1892dcd0538fSMark Fasheh 		}
1893dcd0538fSMark Fasheh 
1894dcd0538fSMark Fasheh 		start = ocfs2_find_subtree_root(inode, left_path, right_path);
1895dcd0538fSMark Fasheh 
1896dcd0538fSMark Fasheh 		mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n",
1897dcd0538fSMark Fasheh 		     start,
1898dcd0538fSMark Fasheh 		     (unsigned long long) right_path->p_node[start].bh->b_blocknr,
1899dcd0538fSMark Fasheh 		     right_path->p_tree_depth);
1900dcd0538fSMark Fasheh 
1901dcd0538fSMark Fasheh 		ret = ocfs2_extend_rotate_transaction(handle, start,
1902328d5752SMark Fasheh 						      orig_credits, right_path);
1903dcd0538fSMark Fasheh 		if (ret) {
1904dcd0538fSMark Fasheh 			mlog_errno(ret);
1905dcd0538fSMark Fasheh 			goto out;
1906dcd0538fSMark Fasheh 		}
1907dcd0538fSMark Fasheh 
1908dcd0538fSMark Fasheh 		ret = ocfs2_rotate_subtree_right(inode, handle, left_path,
1909dcd0538fSMark Fasheh 						 right_path, start);
1910dcd0538fSMark Fasheh 		if (ret) {
1911dcd0538fSMark Fasheh 			mlog_errno(ret);
1912dcd0538fSMark Fasheh 			goto out;
1913dcd0538fSMark Fasheh 		}
1914dcd0538fSMark Fasheh 
1915328d5752SMark Fasheh 		if (split != SPLIT_NONE &&
1916328d5752SMark Fasheh 		    ocfs2_leftmost_rec_contains(path_leaf_el(right_path),
1917328d5752SMark Fasheh 						insert_cpos)) {
1918328d5752SMark Fasheh 			/*
1919328d5752SMark Fasheh 			 * A rotate moves the rightmost left leaf
1920328d5752SMark Fasheh 			 * record over to the leftmost right leaf
1921328d5752SMark Fasheh 			 * slot. If we're doing an extent split
1922328d5752SMark Fasheh 			 * instead of a real insert, then we have to
1923328d5752SMark Fasheh 			 * check that the extent to be split wasn't
1924328d5752SMark Fasheh 			 * just moved over. If it was, then we can
1925328d5752SMark Fasheh 			 * exit here, passing left_path back -
1926328d5752SMark Fasheh 			 * ocfs2_split_extent() is smart enough to
1927328d5752SMark Fasheh 			 * search both leaves.
1928328d5752SMark Fasheh 			 */
1929328d5752SMark Fasheh 			*ret_left_path = left_path;
1930328d5752SMark Fasheh 			goto out_ret_path;
1931328d5752SMark Fasheh 		}
1932328d5752SMark Fasheh 
1933dcd0538fSMark Fasheh 		/*
1934dcd0538fSMark Fasheh 		 * There is no need to re-read the next right path
1935dcd0538fSMark Fasheh 		 * as we know that it'll be our current left
1936dcd0538fSMark Fasheh 		 * path. Optimize by copying values instead.
1937dcd0538fSMark Fasheh 		 */
1938dcd0538fSMark Fasheh 		ocfs2_mv_path(right_path, left_path);
1939dcd0538fSMark Fasheh 
1940dcd0538fSMark Fasheh 		ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path,
1941dcd0538fSMark Fasheh 						    &cpos);
1942dcd0538fSMark Fasheh 		if (ret) {
1943dcd0538fSMark Fasheh 			mlog_errno(ret);
1944dcd0538fSMark Fasheh 			goto out;
1945dcd0538fSMark Fasheh 		}
1946dcd0538fSMark Fasheh 	}
1947dcd0538fSMark Fasheh 
1948dcd0538fSMark Fasheh out:
1949dcd0538fSMark Fasheh 	ocfs2_free_path(left_path);
1950dcd0538fSMark Fasheh 
1951dcd0538fSMark Fasheh out_ret_path:
1952dcd0538fSMark Fasheh 	return ret;
1953dcd0538fSMark Fasheh }
1954dcd0538fSMark Fasheh 
1955328d5752SMark Fasheh static void ocfs2_update_edge_lengths(struct inode *inode, handle_t *handle,
1956328d5752SMark Fasheh 				      struct ocfs2_path *path)
1957328d5752SMark Fasheh {
1958328d5752SMark Fasheh 	int i, idx;
1959328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec;
1960328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
1961328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
1962328d5752SMark Fasheh 	u32 range;
1963328d5752SMark Fasheh 
1964328d5752SMark Fasheh 	/* Path should always be rightmost. */
1965328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
1966328d5752SMark Fasheh 	BUG_ON(eb->h_next_leaf_blk != 0ULL);
1967328d5752SMark Fasheh 
1968328d5752SMark Fasheh 	el = &eb->h_list;
1969328d5752SMark Fasheh 	BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
1970328d5752SMark Fasheh 	idx = le16_to_cpu(el->l_next_free_rec) - 1;
1971328d5752SMark Fasheh 	rec = &el->l_recs[idx];
1972328d5752SMark Fasheh 	range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
1973328d5752SMark Fasheh 
1974328d5752SMark Fasheh 	for (i = 0; i < path->p_tree_depth; i++) {
1975328d5752SMark Fasheh 		el = path->p_node[i].el;
1976328d5752SMark Fasheh 		idx = le16_to_cpu(el->l_next_free_rec) - 1;
1977328d5752SMark Fasheh 		rec = &el->l_recs[idx];
1978328d5752SMark Fasheh 
1979328d5752SMark Fasheh 		rec->e_int_clusters = cpu_to_le32(range);
1980328d5752SMark Fasheh 		le32_add_cpu(&rec->e_int_clusters, -le32_to_cpu(rec->e_cpos));
1981328d5752SMark Fasheh 
1982328d5752SMark Fasheh 		ocfs2_journal_dirty(handle, path->p_node[i].bh);
1983328d5752SMark Fasheh 	}
1984328d5752SMark Fasheh }
1985328d5752SMark Fasheh 
1986328d5752SMark Fasheh static void ocfs2_unlink_path(struct inode *inode, handle_t *handle,
1987328d5752SMark Fasheh 			      struct ocfs2_cached_dealloc_ctxt *dealloc,
1988328d5752SMark Fasheh 			      struct ocfs2_path *path, int unlink_start)
1989328d5752SMark Fasheh {
1990328d5752SMark Fasheh 	int ret, i;
1991328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
1992328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
1993328d5752SMark Fasheh 	struct buffer_head *bh;
1994328d5752SMark Fasheh 
1995328d5752SMark Fasheh 	for(i = unlink_start; i < path_num_items(path); i++) {
1996328d5752SMark Fasheh 		bh = path->p_node[i].bh;
1997328d5752SMark Fasheh 
1998328d5752SMark Fasheh 		eb = (struct ocfs2_extent_block *)bh->b_data;
1999328d5752SMark Fasheh 		/*
2000328d5752SMark Fasheh 		 * Not all nodes might have had their final count
2001328d5752SMark Fasheh 		 * decremented by the caller - handle this here.
2002328d5752SMark Fasheh 		 */
2003328d5752SMark Fasheh 		el = &eb->h_list;
2004328d5752SMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) > 1) {
2005328d5752SMark Fasheh 			mlog(ML_ERROR,
2006328d5752SMark Fasheh 			     "Inode %llu, attempted to remove extent block "
2007328d5752SMark Fasheh 			     "%llu with %u records\n",
2008328d5752SMark Fasheh 			     (unsigned long long)OCFS2_I(inode)->ip_blkno,
2009328d5752SMark Fasheh 			     (unsigned long long)le64_to_cpu(eb->h_blkno),
2010328d5752SMark Fasheh 			     le16_to_cpu(el->l_next_free_rec));
2011328d5752SMark Fasheh 
2012328d5752SMark Fasheh 			ocfs2_journal_dirty(handle, bh);
2013328d5752SMark Fasheh 			ocfs2_remove_from_cache(inode, bh);
2014328d5752SMark Fasheh 			continue;
2015328d5752SMark Fasheh 		}
2016328d5752SMark Fasheh 
2017328d5752SMark Fasheh 		el->l_next_free_rec = 0;
2018328d5752SMark Fasheh 		memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2019328d5752SMark Fasheh 
2020328d5752SMark Fasheh 		ocfs2_journal_dirty(handle, bh);
2021328d5752SMark Fasheh 
2022328d5752SMark Fasheh 		ret = ocfs2_cache_extent_block_free(dealloc, eb);
2023328d5752SMark Fasheh 		if (ret)
2024328d5752SMark Fasheh 			mlog_errno(ret);
2025328d5752SMark Fasheh 
2026328d5752SMark Fasheh 		ocfs2_remove_from_cache(inode, bh);
2027328d5752SMark Fasheh 	}
2028328d5752SMark Fasheh }
2029328d5752SMark Fasheh 
2030328d5752SMark Fasheh static void ocfs2_unlink_subtree(struct inode *inode, handle_t *handle,
2031328d5752SMark Fasheh 				 struct ocfs2_path *left_path,
2032328d5752SMark Fasheh 				 struct ocfs2_path *right_path,
2033328d5752SMark Fasheh 				 int subtree_index,
2034328d5752SMark Fasheh 				 struct ocfs2_cached_dealloc_ctxt *dealloc)
2035328d5752SMark Fasheh {
2036328d5752SMark Fasheh 	int i;
2037328d5752SMark Fasheh 	struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
2038328d5752SMark Fasheh 	struct ocfs2_extent_list *root_el = left_path->p_node[subtree_index].el;
2039328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
2040328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
2041328d5752SMark Fasheh 
2042328d5752SMark Fasheh 	el = path_leaf_el(left_path);
2043328d5752SMark Fasheh 
2044328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)right_path->p_node[subtree_index + 1].bh->b_data;
2045328d5752SMark Fasheh 
2046328d5752SMark Fasheh 	for(i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
2047328d5752SMark Fasheh 		if (root_el->l_recs[i].e_blkno == eb->h_blkno)
2048328d5752SMark Fasheh 			break;
2049328d5752SMark Fasheh 
2050328d5752SMark Fasheh 	BUG_ON(i >= le16_to_cpu(root_el->l_next_free_rec));
2051328d5752SMark Fasheh 
2052328d5752SMark Fasheh 	memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
2053328d5752SMark Fasheh 	le16_add_cpu(&root_el->l_next_free_rec, -1);
2054328d5752SMark Fasheh 
2055328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2056328d5752SMark Fasheh 	eb->h_next_leaf_blk = 0;
2057328d5752SMark Fasheh 
2058328d5752SMark Fasheh 	ocfs2_journal_dirty(handle, root_bh);
2059328d5752SMark Fasheh 	ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2060328d5752SMark Fasheh 
2061328d5752SMark Fasheh 	ocfs2_unlink_path(inode, handle, dealloc, right_path,
2062328d5752SMark Fasheh 			  subtree_index + 1);
2063328d5752SMark Fasheh }
2064328d5752SMark Fasheh 
2065328d5752SMark Fasheh static int ocfs2_rotate_subtree_left(struct inode *inode, handle_t *handle,
2066328d5752SMark Fasheh 				     struct ocfs2_path *left_path,
2067328d5752SMark Fasheh 				     struct ocfs2_path *right_path,
2068328d5752SMark Fasheh 				     int subtree_index,
2069328d5752SMark Fasheh 				     struct ocfs2_cached_dealloc_ctxt *dealloc,
2070328d5752SMark Fasheh 				     int *deleted)
2071328d5752SMark Fasheh {
2072328d5752SMark Fasheh 	int ret, i, del_right_subtree = 0, right_has_empty = 0;
2073328d5752SMark Fasheh 	struct buffer_head *root_bh, *di_bh = path_root_bh(right_path);
2074328d5752SMark Fasheh 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2075328d5752SMark Fasheh 	struct ocfs2_extent_list *right_leaf_el, *left_leaf_el;
2076328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
2077328d5752SMark Fasheh 
2078328d5752SMark Fasheh 	*deleted = 0;
2079328d5752SMark Fasheh 
2080328d5752SMark Fasheh 	right_leaf_el = path_leaf_el(right_path);
2081328d5752SMark Fasheh 	left_leaf_el = path_leaf_el(left_path);
2082328d5752SMark Fasheh 	root_bh = left_path->p_node[subtree_index].bh;
2083328d5752SMark Fasheh 	BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2084328d5752SMark Fasheh 
2085328d5752SMark Fasheh 	if (!ocfs2_is_empty_extent(&left_leaf_el->l_recs[0]))
2086328d5752SMark Fasheh 		return 0;
2087328d5752SMark Fasheh 
2088328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)path_leaf_bh(right_path)->b_data;
2089328d5752SMark Fasheh 	if (ocfs2_is_empty_extent(&right_leaf_el->l_recs[0])) {
2090328d5752SMark Fasheh 		/*
2091328d5752SMark Fasheh 		 * It's legal for us to proceed if the right leaf is
2092328d5752SMark Fasheh 		 * the rightmost one and it has an empty extent. There
2093328d5752SMark Fasheh 		 * are two cases to handle - whether the leaf will be
2094328d5752SMark Fasheh 		 * empty after removal or not. If the leaf isn't empty
2095328d5752SMark Fasheh 		 * then just remove the empty extent up front. The
2096328d5752SMark Fasheh 		 * next block will handle empty leaves by flagging
2097328d5752SMark Fasheh 		 * them for unlink.
2098328d5752SMark Fasheh 		 *
2099328d5752SMark Fasheh 		 * Non rightmost leaves will throw -EAGAIN and the
2100328d5752SMark Fasheh 		 * caller can manually move the subtree and retry.
2101328d5752SMark Fasheh 		 */
2102328d5752SMark Fasheh 
2103328d5752SMark Fasheh 		if (eb->h_next_leaf_blk != 0ULL)
2104328d5752SMark Fasheh 			return -EAGAIN;
2105328d5752SMark Fasheh 
2106328d5752SMark Fasheh 		if (le16_to_cpu(right_leaf_el->l_next_free_rec) > 1) {
2107328d5752SMark Fasheh 			ret = ocfs2_journal_access(handle, inode,
2108328d5752SMark Fasheh 						   path_leaf_bh(right_path),
2109328d5752SMark Fasheh 						   OCFS2_JOURNAL_ACCESS_WRITE);
2110328d5752SMark Fasheh 			if (ret) {
2111328d5752SMark Fasheh 				mlog_errno(ret);
2112328d5752SMark Fasheh 				goto out;
2113328d5752SMark Fasheh 			}
2114328d5752SMark Fasheh 
2115328d5752SMark Fasheh 			ocfs2_remove_empty_extent(right_leaf_el);
2116328d5752SMark Fasheh 		} else
2117328d5752SMark Fasheh 			right_has_empty = 1;
2118328d5752SMark Fasheh 	}
2119328d5752SMark Fasheh 
2120328d5752SMark Fasheh 	if (eb->h_next_leaf_blk == 0ULL &&
2121328d5752SMark Fasheh 	    le16_to_cpu(right_leaf_el->l_next_free_rec) == 1) {
2122328d5752SMark Fasheh 		/*
2123328d5752SMark Fasheh 		 * We have to update i_last_eb_blk during the meta
2124328d5752SMark Fasheh 		 * data delete.
2125328d5752SMark Fasheh 		 */
2126328d5752SMark Fasheh 		ret = ocfs2_journal_access(handle, inode, di_bh,
2127328d5752SMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
2128328d5752SMark Fasheh 		if (ret) {
2129328d5752SMark Fasheh 			mlog_errno(ret);
2130328d5752SMark Fasheh 			goto out;
2131328d5752SMark Fasheh 		}
2132328d5752SMark Fasheh 
2133328d5752SMark Fasheh 		del_right_subtree = 1;
2134328d5752SMark Fasheh 	}
2135328d5752SMark Fasheh 
2136328d5752SMark Fasheh 	/*
2137328d5752SMark Fasheh 	 * Getting here with an empty extent in the right path implies
2138328d5752SMark Fasheh 	 * that it's the rightmost path and will be deleted.
2139328d5752SMark Fasheh 	 */
2140328d5752SMark Fasheh 	BUG_ON(right_has_empty && !del_right_subtree);
2141328d5752SMark Fasheh 
2142328d5752SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, root_bh,
2143328d5752SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
2144328d5752SMark Fasheh 	if (ret) {
2145328d5752SMark Fasheh 		mlog_errno(ret);
2146328d5752SMark Fasheh 		goto out;
2147328d5752SMark Fasheh 	}
2148328d5752SMark Fasheh 
2149328d5752SMark Fasheh 	for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2150328d5752SMark Fasheh 		ret = ocfs2_journal_access(handle, inode,
2151328d5752SMark Fasheh 					   right_path->p_node[i].bh,
2152328d5752SMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
2153328d5752SMark Fasheh 		if (ret) {
2154328d5752SMark Fasheh 			mlog_errno(ret);
2155328d5752SMark Fasheh 			goto out;
2156328d5752SMark Fasheh 		}
2157328d5752SMark Fasheh 
2158328d5752SMark Fasheh 		ret = ocfs2_journal_access(handle, inode,
2159328d5752SMark Fasheh 					   left_path->p_node[i].bh,
2160328d5752SMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
2161328d5752SMark Fasheh 		if (ret) {
2162328d5752SMark Fasheh 			mlog_errno(ret);
2163328d5752SMark Fasheh 			goto out;
2164328d5752SMark Fasheh 		}
2165328d5752SMark Fasheh 	}
2166328d5752SMark Fasheh 
2167328d5752SMark Fasheh 	if (!right_has_empty) {
2168328d5752SMark Fasheh 		/*
2169328d5752SMark Fasheh 		 * Only do this if we're moving a real
2170328d5752SMark Fasheh 		 * record. Otherwise, the action is delayed until
2171328d5752SMark Fasheh 		 * after removal of the right path in which case we
2172328d5752SMark Fasheh 		 * can do a simple shift to remove the empty extent.
2173328d5752SMark Fasheh 		 */
2174328d5752SMark Fasheh 		ocfs2_rotate_leaf(left_leaf_el, &right_leaf_el->l_recs[0]);
2175328d5752SMark Fasheh 		memset(&right_leaf_el->l_recs[0], 0,
2176328d5752SMark Fasheh 		       sizeof(struct ocfs2_extent_rec));
2177328d5752SMark Fasheh 	}
2178328d5752SMark Fasheh 	if (eb->h_next_leaf_blk == 0ULL) {
2179328d5752SMark Fasheh 		/*
2180328d5752SMark Fasheh 		 * Move recs over to get rid of empty extent, decrease
2181328d5752SMark Fasheh 		 * next_free. This is allowed to remove the last
2182328d5752SMark Fasheh 		 * extent in our leaf (setting l_next_free_rec to
2183328d5752SMark Fasheh 		 * zero) - the delete code below won't care.
2184328d5752SMark Fasheh 		 */
2185328d5752SMark Fasheh 		ocfs2_remove_empty_extent(right_leaf_el);
2186328d5752SMark Fasheh 	}
2187328d5752SMark Fasheh 
2188328d5752SMark Fasheh 	ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2189328d5752SMark Fasheh 	if (ret)
2190328d5752SMark Fasheh 		mlog_errno(ret);
2191328d5752SMark Fasheh 	ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
2192328d5752SMark Fasheh 	if (ret)
2193328d5752SMark Fasheh 		mlog_errno(ret);
2194328d5752SMark Fasheh 
2195328d5752SMark Fasheh 	if (del_right_subtree) {
2196328d5752SMark Fasheh 		ocfs2_unlink_subtree(inode, handle, left_path, right_path,
2197328d5752SMark Fasheh 				     subtree_index, dealloc);
2198328d5752SMark Fasheh 		ocfs2_update_edge_lengths(inode, handle, left_path);
2199328d5752SMark Fasheh 
2200328d5752SMark Fasheh 		eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2201328d5752SMark Fasheh 		di->i_last_eb_blk = eb->h_blkno;
2202328d5752SMark Fasheh 
2203328d5752SMark Fasheh 		/*
2204328d5752SMark Fasheh 		 * Removal of the extent in the left leaf was skipped
2205328d5752SMark Fasheh 		 * above so we could delete the right path
2206328d5752SMark Fasheh 		 * 1st.
2207328d5752SMark Fasheh 		 */
2208328d5752SMark Fasheh 		if (right_has_empty)
2209328d5752SMark Fasheh 			ocfs2_remove_empty_extent(left_leaf_el);
2210328d5752SMark Fasheh 
2211328d5752SMark Fasheh 		ret = ocfs2_journal_dirty(handle, di_bh);
2212328d5752SMark Fasheh 		if (ret)
2213328d5752SMark Fasheh 			mlog_errno(ret);
2214328d5752SMark Fasheh 
2215328d5752SMark Fasheh 		*deleted = 1;
2216328d5752SMark Fasheh 	} else
2217328d5752SMark Fasheh 		ocfs2_complete_edge_insert(inode, handle, left_path, right_path,
2218328d5752SMark Fasheh 					   subtree_index);
2219328d5752SMark Fasheh 
2220328d5752SMark Fasheh out:
2221328d5752SMark Fasheh 	return ret;
2222328d5752SMark Fasheh }
2223328d5752SMark Fasheh 
2224328d5752SMark Fasheh /*
2225328d5752SMark Fasheh  * Given a full path, determine what cpos value would return us a path
2226328d5752SMark Fasheh  * containing the leaf immediately to the right of the current one.
2227328d5752SMark Fasheh  *
2228328d5752SMark Fasheh  * Will return zero if the path passed in is already the rightmost path.
2229328d5752SMark Fasheh  *
2230328d5752SMark Fasheh  * This looks similar, but is subtly different to
2231328d5752SMark Fasheh  * ocfs2_find_cpos_for_left_leaf().
2232328d5752SMark Fasheh  */
2233328d5752SMark Fasheh static int ocfs2_find_cpos_for_right_leaf(struct super_block *sb,
2234328d5752SMark Fasheh 					  struct ocfs2_path *path, u32 *cpos)
2235328d5752SMark Fasheh {
2236328d5752SMark Fasheh 	int i, j, ret = 0;
2237328d5752SMark Fasheh 	u64 blkno;
2238328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
2239328d5752SMark Fasheh 
2240328d5752SMark Fasheh 	*cpos = 0;
2241328d5752SMark Fasheh 
2242328d5752SMark Fasheh 	if (path->p_tree_depth == 0)
2243328d5752SMark Fasheh 		return 0;
2244328d5752SMark Fasheh 
2245328d5752SMark Fasheh 	blkno = path_leaf_bh(path)->b_blocknr;
2246328d5752SMark Fasheh 
2247328d5752SMark Fasheh 	/* Start at the tree node just above the leaf and work our way up. */
2248328d5752SMark Fasheh 	i = path->p_tree_depth - 1;
2249328d5752SMark Fasheh 	while (i >= 0) {
2250328d5752SMark Fasheh 		int next_free;
2251328d5752SMark Fasheh 
2252328d5752SMark Fasheh 		el = path->p_node[i].el;
2253328d5752SMark Fasheh 
2254328d5752SMark Fasheh 		/*
2255328d5752SMark Fasheh 		 * Find the extent record just after the one in our
2256328d5752SMark Fasheh 		 * path.
2257328d5752SMark Fasheh 		 */
2258328d5752SMark Fasheh 		next_free = le16_to_cpu(el->l_next_free_rec);
2259328d5752SMark Fasheh 		for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2260328d5752SMark Fasheh 			if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2261328d5752SMark Fasheh 				if (j == (next_free - 1)) {
2262328d5752SMark Fasheh 					if (i == 0) {
2263328d5752SMark Fasheh 						/*
2264328d5752SMark Fasheh 						 * We've determined that the
2265328d5752SMark Fasheh 						 * path specified is already
2266328d5752SMark Fasheh 						 * the rightmost one - return a
2267328d5752SMark Fasheh 						 * cpos of zero.
2268328d5752SMark Fasheh 						 */
2269328d5752SMark Fasheh 						goto out;
2270328d5752SMark Fasheh 					}
2271328d5752SMark Fasheh 					/*
2272328d5752SMark Fasheh 					 * The rightmost record points to our
2273328d5752SMark Fasheh 					 * leaf - we need to travel up the
2274328d5752SMark Fasheh 					 * tree one level.
2275328d5752SMark Fasheh 					 */
2276328d5752SMark Fasheh 					goto next_node;
2277328d5752SMark Fasheh 				}
2278328d5752SMark Fasheh 
2279328d5752SMark Fasheh 				*cpos = le32_to_cpu(el->l_recs[j + 1].e_cpos);
2280328d5752SMark Fasheh 				goto out;
2281328d5752SMark Fasheh 			}
2282328d5752SMark Fasheh 		}
2283328d5752SMark Fasheh 
2284328d5752SMark Fasheh 		/*
2285328d5752SMark Fasheh 		 * If we got here, we never found a valid node where
2286328d5752SMark Fasheh 		 * the tree indicated one should be.
2287328d5752SMark Fasheh 		 */
2288328d5752SMark Fasheh 		ocfs2_error(sb,
2289328d5752SMark Fasheh 			    "Invalid extent tree at extent block %llu\n",
2290328d5752SMark Fasheh 			    (unsigned long long)blkno);
2291328d5752SMark Fasheh 		ret = -EROFS;
2292328d5752SMark Fasheh 		goto out;
2293328d5752SMark Fasheh 
2294328d5752SMark Fasheh next_node:
2295328d5752SMark Fasheh 		blkno = path->p_node[i].bh->b_blocknr;
2296328d5752SMark Fasheh 		i--;
2297328d5752SMark Fasheh 	}
2298328d5752SMark Fasheh 
2299328d5752SMark Fasheh out:
2300328d5752SMark Fasheh 	return ret;
2301328d5752SMark Fasheh }
2302328d5752SMark Fasheh 
2303328d5752SMark Fasheh static int ocfs2_rotate_rightmost_leaf_left(struct inode *inode,
2304328d5752SMark Fasheh 					    handle_t *handle,
2305328d5752SMark Fasheh 					    struct buffer_head *bh,
2306328d5752SMark Fasheh 					    struct ocfs2_extent_list *el)
2307328d5752SMark Fasheh {
2308328d5752SMark Fasheh 	int ret;
2309328d5752SMark Fasheh 
2310328d5752SMark Fasheh 	if (!ocfs2_is_empty_extent(&el->l_recs[0]))
2311328d5752SMark Fasheh 		return 0;
2312328d5752SMark Fasheh 
2313328d5752SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, bh,
2314328d5752SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
2315328d5752SMark Fasheh 	if (ret) {
2316328d5752SMark Fasheh 		mlog_errno(ret);
2317328d5752SMark Fasheh 		goto out;
2318328d5752SMark Fasheh 	}
2319328d5752SMark Fasheh 
2320328d5752SMark Fasheh 	ocfs2_remove_empty_extent(el);
2321328d5752SMark Fasheh 
2322328d5752SMark Fasheh 	ret = ocfs2_journal_dirty(handle, bh);
2323328d5752SMark Fasheh 	if (ret)
2324328d5752SMark Fasheh 		mlog_errno(ret);
2325328d5752SMark Fasheh 
2326328d5752SMark Fasheh out:
2327328d5752SMark Fasheh 	return ret;
2328328d5752SMark Fasheh }
2329328d5752SMark Fasheh 
2330328d5752SMark Fasheh static int __ocfs2_rotate_tree_left(struct inode *inode,
2331328d5752SMark Fasheh 				    handle_t *handle, int orig_credits,
2332328d5752SMark Fasheh 				    struct ocfs2_path *path,
2333328d5752SMark Fasheh 				    struct ocfs2_cached_dealloc_ctxt *dealloc,
2334328d5752SMark Fasheh 				    struct ocfs2_path **empty_extent_path)
2335328d5752SMark Fasheh {
2336328d5752SMark Fasheh 	int ret, subtree_root, deleted;
2337328d5752SMark Fasheh 	u32 right_cpos;
2338328d5752SMark Fasheh 	struct ocfs2_path *left_path = NULL;
2339328d5752SMark Fasheh 	struct ocfs2_path *right_path = NULL;
2340328d5752SMark Fasheh 
2341328d5752SMark Fasheh 	BUG_ON(!ocfs2_is_empty_extent(&(path_leaf_el(path)->l_recs[0])));
2342328d5752SMark Fasheh 
2343328d5752SMark Fasheh 	*empty_extent_path = NULL;
2344328d5752SMark Fasheh 
2345328d5752SMark Fasheh 	ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, path,
2346328d5752SMark Fasheh 					     &right_cpos);
2347328d5752SMark Fasheh 	if (ret) {
2348328d5752SMark Fasheh 		mlog_errno(ret);
2349328d5752SMark Fasheh 		goto out;
2350328d5752SMark Fasheh 	}
2351328d5752SMark Fasheh 
2352328d5752SMark Fasheh 	left_path = ocfs2_new_path(path_root_bh(path),
2353328d5752SMark Fasheh 				   path_root_el(path));
2354328d5752SMark Fasheh 	if (!left_path) {
2355328d5752SMark Fasheh 		ret = -ENOMEM;
2356328d5752SMark Fasheh 		mlog_errno(ret);
2357328d5752SMark Fasheh 		goto out;
2358328d5752SMark Fasheh 	}
2359328d5752SMark Fasheh 
2360328d5752SMark Fasheh 	ocfs2_cp_path(left_path, path);
2361328d5752SMark Fasheh 
2362328d5752SMark Fasheh 	right_path = ocfs2_new_path(path_root_bh(path),
2363328d5752SMark Fasheh 				    path_root_el(path));
2364328d5752SMark Fasheh 	if (!right_path) {
2365328d5752SMark Fasheh 		ret = -ENOMEM;
2366328d5752SMark Fasheh 		mlog_errno(ret);
2367328d5752SMark Fasheh 		goto out;
2368328d5752SMark Fasheh 	}
2369328d5752SMark Fasheh 
2370328d5752SMark Fasheh 	while (right_cpos) {
2371328d5752SMark Fasheh 		ret = ocfs2_find_path(inode, right_path, right_cpos);
2372328d5752SMark Fasheh 		if (ret) {
2373328d5752SMark Fasheh 			mlog_errno(ret);
2374328d5752SMark Fasheh 			goto out;
2375328d5752SMark Fasheh 		}
2376328d5752SMark Fasheh 
2377328d5752SMark Fasheh 		subtree_root = ocfs2_find_subtree_root(inode, left_path,
2378328d5752SMark Fasheh 						       right_path);
2379328d5752SMark Fasheh 
2380328d5752SMark Fasheh 		mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n",
2381328d5752SMark Fasheh 		     subtree_root,
2382328d5752SMark Fasheh 		     (unsigned long long)
2383328d5752SMark Fasheh 		     right_path->p_node[subtree_root].bh->b_blocknr,
2384328d5752SMark Fasheh 		     right_path->p_tree_depth);
2385328d5752SMark Fasheh 
2386328d5752SMark Fasheh 		ret = ocfs2_extend_rotate_transaction(handle, subtree_root,
2387328d5752SMark Fasheh 						      orig_credits, left_path);
2388328d5752SMark Fasheh 		if (ret) {
2389328d5752SMark Fasheh 			mlog_errno(ret);
2390328d5752SMark Fasheh 			goto out;
2391328d5752SMark Fasheh 		}
2392328d5752SMark Fasheh 
2393e8aed345SMark Fasheh 		/*
2394e8aed345SMark Fasheh 		 * Caller might still want to make changes to the
2395e8aed345SMark Fasheh 		 * tree root, so re-add it to the journal here.
2396e8aed345SMark Fasheh 		 */
2397e8aed345SMark Fasheh 		ret = ocfs2_journal_access(handle, inode,
2398e8aed345SMark Fasheh 					   path_root_bh(left_path),
2399e8aed345SMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
2400e8aed345SMark Fasheh 		if (ret) {
2401e8aed345SMark Fasheh 			mlog_errno(ret);
2402e8aed345SMark Fasheh 			goto out;
2403e8aed345SMark Fasheh 		}
2404e8aed345SMark Fasheh 
2405328d5752SMark Fasheh 		ret = ocfs2_rotate_subtree_left(inode, handle, left_path,
2406328d5752SMark Fasheh 						right_path, subtree_root,
2407328d5752SMark Fasheh 						dealloc, &deleted);
2408328d5752SMark Fasheh 		if (ret == -EAGAIN) {
2409328d5752SMark Fasheh 			/*
2410328d5752SMark Fasheh 			 * The rotation has to temporarily stop due to
2411328d5752SMark Fasheh 			 * the right subtree having an empty
2412328d5752SMark Fasheh 			 * extent. Pass it back to the caller for a
2413328d5752SMark Fasheh 			 * fixup.
2414328d5752SMark Fasheh 			 */
2415328d5752SMark Fasheh 			*empty_extent_path = right_path;
2416328d5752SMark Fasheh 			right_path = NULL;
2417328d5752SMark Fasheh 			goto out;
2418328d5752SMark Fasheh 		}
2419328d5752SMark Fasheh 		if (ret) {
2420328d5752SMark Fasheh 			mlog_errno(ret);
2421328d5752SMark Fasheh 			goto out;
2422328d5752SMark Fasheh 		}
2423328d5752SMark Fasheh 
2424328d5752SMark Fasheh 		/*
2425328d5752SMark Fasheh 		 * The subtree rotate might have removed records on
2426328d5752SMark Fasheh 		 * the rightmost edge. If so, then rotation is
2427328d5752SMark Fasheh 		 * complete.
2428328d5752SMark Fasheh 		 */
2429328d5752SMark Fasheh 		if (deleted)
2430328d5752SMark Fasheh 			break;
2431328d5752SMark Fasheh 
2432328d5752SMark Fasheh 		ocfs2_mv_path(left_path, right_path);
2433328d5752SMark Fasheh 
2434328d5752SMark Fasheh 		ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, left_path,
2435328d5752SMark Fasheh 						     &right_cpos);
2436328d5752SMark Fasheh 		if (ret) {
2437328d5752SMark Fasheh 			mlog_errno(ret);
2438328d5752SMark Fasheh 			goto out;
2439328d5752SMark Fasheh 		}
2440328d5752SMark Fasheh 	}
2441328d5752SMark Fasheh 
2442328d5752SMark Fasheh out:
2443328d5752SMark Fasheh 	ocfs2_free_path(right_path);
2444328d5752SMark Fasheh 	ocfs2_free_path(left_path);
2445328d5752SMark Fasheh 
2446328d5752SMark Fasheh 	return ret;
2447328d5752SMark Fasheh }
2448328d5752SMark Fasheh 
2449328d5752SMark Fasheh static int ocfs2_remove_rightmost_path(struct inode *inode, handle_t *handle,
2450328d5752SMark Fasheh 				       struct ocfs2_path *path,
2451328d5752SMark Fasheh 				       struct ocfs2_cached_dealloc_ctxt *dealloc)
2452328d5752SMark Fasheh {
2453328d5752SMark Fasheh 	int ret, subtree_index;
2454328d5752SMark Fasheh 	u32 cpos;
2455328d5752SMark Fasheh 	struct ocfs2_path *left_path = NULL;
2456328d5752SMark Fasheh 	struct ocfs2_dinode *di;
2457328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
2458328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
2459328d5752SMark Fasheh 
2460328d5752SMark Fasheh 	/*
2461328d5752SMark Fasheh 	 * XXX: This code assumes that the root is an inode, which is
2462328d5752SMark Fasheh 	 * true for now but may change as tree code gets generic.
2463328d5752SMark Fasheh 	 */
2464328d5752SMark Fasheh 	di = (struct ocfs2_dinode *)path_root_bh(path)->b_data;
2465328d5752SMark Fasheh 	if (!OCFS2_IS_VALID_DINODE(di)) {
2466328d5752SMark Fasheh 		ret = -EIO;
2467328d5752SMark Fasheh 		ocfs2_error(inode->i_sb,
2468328d5752SMark Fasheh 			    "Inode %llu has invalid path root",
2469328d5752SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno);
2470328d5752SMark Fasheh 		goto out;
2471328d5752SMark Fasheh 	}
2472328d5752SMark Fasheh 
2473328d5752SMark Fasheh 	/*
2474328d5752SMark Fasheh 	 * There's two ways we handle this depending on
2475328d5752SMark Fasheh 	 * whether path is the only existing one.
2476328d5752SMark Fasheh 	 */
2477328d5752SMark Fasheh 	ret = ocfs2_extend_rotate_transaction(handle, 0,
2478328d5752SMark Fasheh 					      handle->h_buffer_credits,
2479328d5752SMark Fasheh 					      path);
2480328d5752SMark Fasheh 	if (ret) {
2481328d5752SMark Fasheh 		mlog_errno(ret);
2482328d5752SMark Fasheh 		goto out;
2483328d5752SMark Fasheh 	}
2484328d5752SMark Fasheh 
2485328d5752SMark Fasheh 	ret = ocfs2_journal_access_path(inode, handle, path);
2486328d5752SMark Fasheh 	if (ret) {
2487328d5752SMark Fasheh 		mlog_errno(ret);
2488328d5752SMark Fasheh 		goto out;
2489328d5752SMark Fasheh 	}
2490328d5752SMark Fasheh 
2491328d5752SMark Fasheh 	ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, &cpos);
2492328d5752SMark Fasheh 	if (ret) {
2493328d5752SMark Fasheh 		mlog_errno(ret);
2494328d5752SMark Fasheh 		goto out;
2495328d5752SMark Fasheh 	}
2496328d5752SMark Fasheh 
2497328d5752SMark Fasheh 	if (cpos) {
2498328d5752SMark Fasheh 		/*
2499328d5752SMark Fasheh 		 * We have a path to the left of this one - it needs
2500328d5752SMark Fasheh 		 * an update too.
2501328d5752SMark Fasheh 		 */
2502328d5752SMark Fasheh 		left_path = ocfs2_new_path(path_root_bh(path),
2503328d5752SMark Fasheh 					   path_root_el(path));
2504328d5752SMark Fasheh 		if (!left_path) {
2505328d5752SMark Fasheh 			ret = -ENOMEM;
2506328d5752SMark Fasheh 			mlog_errno(ret);
2507328d5752SMark Fasheh 			goto out;
2508328d5752SMark Fasheh 		}
2509328d5752SMark Fasheh 
2510328d5752SMark Fasheh 		ret = ocfs2_find_path(inode, left_path, cpos);
2511328d5752SMark Fasheh 		if (ret) {
2512328d5752SMark Fasheh 			mlog_errno(ret);
2513328d5752SMark Fasheh 			goto out;
2514328d5752SMark Fasheh 		}
2515328d5752SMark Fasheh 
2516328d5752SMark Fasheh 		ret = ocfs2_journal_access_path(inode, handle, left_path);
2517328d5752SMark Fasheh 		if (ret) {
2518328d5752SMark Fasheh 			mlog_errno(ret);
2519328d5752SMark Fasheh 			goto out;
2520328d5752SMark Fasheh 		}
2521328d5752SMark Fasheh 
2522328d5752SMark Fasheh 		subtree_index = ocfs2_find_subtree_root(inode, left_path, path);
2523328d5752SMark Fasheh 
2524328d5752SMark Fasheh 		ocfs2_unlink_subtree(inode, handle, left_path, path,
2525328d5752SMark Fasheh 				     subtree_index, dealloc);
2526328d5752SMark Fasheh 		ocfs2_update_edge_lengths(inode, handle, left_path);
2527328d5752SMark Fasheh 
2528328d5752SMark Fasheh 		eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2529328d5752SMark Fasheh 		di->i_last_eb_blk = eb->h_blkno;
2530328d5752SMark Fasheh 	} else {
2531328d5752SMark Fasheh 		/*
2532328d5752SMark Fasheh 		 * 'path' is also the leftmost path which
2533328d5752SMark Fasheh 		 * means it must be the only one. This gets
2534328d5752SMark Fasheh 		 * handled differently because we want to
2535328d5752SMark Fasheh 		 * revert the inode back to having extents
2536328d5752SMark Fasheh 		 * in-line.
2537328d5752SMark Fasheh 		 */
2538328d5752SMark Fasheh 		ocfs2_unlink_path(inode, handle, dealloc, path, 1);
2539328d5752SMark Fasheh 
2540328d5752SMark Fasheh 		el = &di->id2.i_list;
2541328d5752SMark Fasheh 		el->l_tree_depth = 0;
2542328d5752SMark Fasheh 		el->l_next_free_rec = 0;
2543328d5752SMark Fasheh 		memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2544328d5752SMark Fasheh 
2545328d5752SMark Fasheh 		di->i_last_eb_blk = 0;
2546328d5752SMark Fasheh 	}
2547328d5752SMark Fasheh 
2548328d5752SMark Fasheh 	ocfs2_journal_dirty(handle, path_root_bh(path));
2549328d5752SMark Fasheh 
2550328d5752SMark Fasheh out:
2551328d5752SMark Fasheh 	ocfs2_free_path(left_path);
2552328d5752SMark Fasheh 	return ret;
2553328d5752SMark Fasheh }
2554328d5752SMark Fasheh 
2555328d5752SMark Fasheh /*
2556328d5752SMark Fasheh  * Left rotation of btree records.
2557328d5752SMark Fasheh  *
2558328d5752SMark Fasheh  * In many ways, this is (unsurprisingly) the opposite of right
2559328d5752SMark Fasheh  * rotation. We start at some non-rightmost path containing an empty
2560328d5752SMark Fasheh  * extent in the leaf block. The code works its way to the rightmost
2561328d5752SMark Fasheh  * path by rotating records to the left in every subtree.
2562328d5752SMark Fasheh  *
2563328d5752SMark Fasheh  * This is used by any code which reduces the number of extent records
2564328d5752SMark Fasheh  * in a leaf. After removal, an empty record should be placed in the
2565328d5752SMark Fasheh  * leftmost list position.
2566328d5752SMark Fasheh  *
2567328d5752SMark Fasheh  * This won't handle a length update of the rightmost path records if
2568328d5752SMark Fasheh  * the rightmost tree leaf record is removed so the caller is
2569328d5752SMark Fasheh  * responsible for detecting and correcting that.
2570328d5752SMark Fasheh  */
2571328d5752SMark Fasheh static int ocfs2_rotate_tree_left(struct inode *inode, handle_t *handle,
2572328d5752SMark Fasheh 				  struct ocfs2_path *path,
2573328d5752SMark Fasheh 				  struct ocfs2_cached_dealloc_ctxt *dealloc)
2574328d5752SMark Fasheh {
2575328d5752SMark Fasheh 	int ret, orig_credits = handle->h_buffer_credits;
2576328d5752SMark Fasheh 	struct ocfs2_path *tmp_path = NULL, *restart_path = NULL;
2577328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
2578328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
2579328d5752SMark Fasheh 
2580328d5752SMark Fasheh 	el = path_leaf_el(path);
2581328d5752SMark Fasheh 	if (!ocfs2_is_empty_extent(&el->l_recs[0]))
2582328d5752SMark Fasheh 		return 0;
2583328d5752SMark Fasheh 
2584328d5752SMark Fasheh 	if (path->p_tree_depth == 0) {
2585328d5752SMark Fasheh rightmost_no_delete:
2586328d5752SMark Fasheh 		/*
2587328d5752SMark Fasheh 		 * In-inode extents. This is trivially handled, so do
2588328d5752SMark Fasheh 		 * it up front.
2589328d5752SMark Fasheh 		 */
2590328d5752SMark Fasheh 		ret = ocfs2_rotate_rightmost_leaf_left(inode, handle,
2591328d5752SMark Fasheh 						       path_leaf_bh(path),
2592328d5752SMark Fasheh 						       path_leaf_el(path));
2593328d5752SMark Fasheh 		if (ret)
2594328d5752SMark Fasheh 			mlog_errno(ret);
2595328d5752SMark Fasheh 		goto out;
2596328d5752SMark Fasheh 	}
2597328d5752SMark Fasheh 
2598328d5752SMark Fasheh 	/*
2599328d5752SMark Fasheh 	 * Handle rightmost branch now. There's several cases:
2600328d5752SMark Fasheh 	 *  1) simple rotation leaving records in there. That's trivial.
2601328d5752SMark Fasheh 	 *  2) rotation requiring a branch delete - there's no more
2602328d5752SMark Fasheh 	 *     records left. Two cases of this:
2603328d5752SMark Fasheh 	 *     a) There are branches to the left.
2604328d5752SMark Fasheh 	 *     b) This is also the leftmost (the only) branch.
2605328d5752SMark Fasheh 	 *
2606328d5752SMark Fasheh 	 *  1) is handled via ocfs2_rotate_rightmost_leaf_left()
2607328d5752SMark Fasheh 	 *  2a) we need the left branch so that we can update it with the unlink
2608328d5752SMark Fasheh 	 *  2b) we need to bring the inode back to inline extents.
2609328d5752SMark Fasheh 	 */
2610328d5752SMark Fasheh 
2611328d5752SMark Fasheh 	eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
2612328d5752SMark Fasheh 	el = &eb->h_list;
2613328d5752SMark Fasheh 	if (eb->h_next_leaf_blk == 0) {
2614328d5752SMark Fasheh 		/*
2615328d5752SMark Fasheh 		 * This gets a bit tricky if we're going to delete the
2616328d5752SMark Fasheh 		 * rightmost path. Get the other cases out of the way
2617328d5752SMark Fasheh 		 * 1st.
2618328d5752SMark Fasheh 		 */
2619328d5752SMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) > 1)
2620328d5752SMark Fasheh 			goto rightmost_no_delete;
2621328d5752SMark Fasheh 
2622328d5752SMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) == 0) {
2623328d5752SMark Fasheh 			ret = -EIO;
2624328d5752SMark Fasheh 			ocfs2_error(inode->i_sb,
2625328d5752SMark Fasheh 				    "Inode %llu has empty extent block at %llu",
2626328d5752SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno,
2627328d5752SMark Fasheh 				    (unsigned long long)le64_to_cpu(eb->h_blkno));
2628328d5752SMark Fasheh 			goto out;
2629328d5752SMark Fasheh 		}
2630328d5752SMark Fasheh 
2631328d5752SMark Fasheh 		/*
2632328d5752SMark Fasheh 		 * XXX: The caller can not trust "path" any more after
2633328d5752SMark Fasheh 		 * this as it will have been deleted. What do we do?
2634328d5752SMark Fasheh 		 *
2635328d5752SMark Fasheh 		 * In theory the rotate-for-merge code will never get
2636328d5752SMark Fasheh 		 * here because it'll always ask for a rotate in a
2637328d5752SMark Fasheh 		 * nonempty list.
2638328d5752SMark Fasheh 		 */
2639328d5752SMark Fasheh 
2640328d5752SMark Fasheh 		ret = ocfs2_remove_rightmost_path(inode, handle, path,
2641328d5752SMark Fasheh 						  dealloc);
2642328d5752SMark Fasheh 		if (ret)
2643328d5752SMark Fasheh 			mlog_errno(ret);
2644328d5752SMark Fasheh 		goto out;
2645328d5752SMark Fasheh 	}
2646328d5752SMark Fasheh 
2647328d5752SMark Fasheh 	/*
2648328d5752SMark Fasheh 	 * Now we can loop, remembering the path we get from -EAGAIN
2649328d5752SMark Fasheh 	 * and restarting from there.
2650328d5752SMark Fasheh 	 */
2651328d5752SMark Fasheh try_rotate:
2652328d5752SMark Fasheh 	ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits, path,
2653328d5752SMark Fasheh 				       dealloc, &restart_path);
2654328d5752SMark Fasheh 	if (ret && ret != -EAGAIN) {
2655328d5752SMark Fasheh 		mlog_errno(ret);
2656328d5752SMark Fasheh 		goto out;
2657328d5752SMark Fasheh 	}
2658328d5752SMark Fasheh 
2659328d5752SMark Fasheh 	while (ret == -EAGAIN) {
2660328d5752SMark Fasheh 		tmp_path = restart_path;
2661328d5752SMark Fasheh 		restart_path = NULL;
2662328d5752SMark Fasheh 
2663328d5752SMark Fasheh 		ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits,
2664328d5752SMark Fasheh 					       tmp_path, dealloc,
2665328d5752SMark Fasheh 					       &restart_path);
2666328d5752SMark Fasheh 		if (ret && ret != -EAGAIN) {
2667328d5752SMark Fasheh 			mlog_errno(ret);
2668328d5752SMark Fasheh 			goto out;
2669328d5752SMark Fasheh 		}
2670328d5752SMark Fasheh 
2671328d5752SMark Fasheh 		ocfs2_free_path(tmp_path);
2672328d5752SMark Fasheh 		tmp_path = NULL;
2673328d5752SMark Fasheh 
2674328d5752SMark Fasheh 		if (ret == 0)
2675328d5752SMark Fasheh 			goto try_rotate;
2676328d5752SMark Fasheh 	}
2677328d5752SMark Fasheh 
2678328d5752SMark Fasheh out:
2679328d5752SMark Fasheh 	ocfs2_free_path(tmp_path);
2680328d5752SMark Fasheh 	ocfs2_free_path(restart_path);
2681328d5752SMark Fasheh 	return ret;
2682328d5752SMark Fasheh }
2683328d5752SMark Fasheh 
2684328d5752SMark Fasheh static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el,
2685328d5752SMark Fasheh 				int index)
2686328d5752SMark Fasheh {
2687328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec = &el->l_recs[index];
2688328d5752SMark Fasheh 	unsigned int size;
2689328d5752SMark Fasheh 
2690328d5752SMark Fasheh 	if (rec->e_leaf_clusters == 0) {
2691328d5752SMark Fasheh 		/*
2692328d5752SMark Fasheh 		 * We consumed all of the merged-from record. An empty
2693328d5752SMark Fasheh 		 * extent cannot exist anywhere but the 1st array
2694328d5752SMark Fasheh 		 * position, so move things over if the merged-from
2695328d5752SMark Fasheh 		 * record doesn't occupy that position.
2696328d5752SMark Fasheh 		 *
2697328d5752SMark Fasheh 		 * This creates a new empty extent so the caller
2698328d5752SMark Fasheh 		 * should be smart enough to have removed any existing
2699328d5752SMark Fasheh 		 * ones.
2700328d5752SMark Fasheh 		 */
2701328d5752SMark Fasheh 		if (index > 0) {
2702328d5752SMark Fasheh 			BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
2703328d5752SMark Fasheh 			size = index * sizeof(struct ocfs2_extent_rec);
2704328d5752SMark Fasheh 			memmove(&el->l_recs[1], &el->l_recs[0], size);
2705328d5752SMark Fasheh 		}
2706328d5752SMark Fasheh 
2707328d5752SMark Fasheh 		/*
2708328d5752SMark Fasheh 		 * Always memset - the caller doesn't check whether it
2709328d5752SMark Fasheh 		 * created an empty extent, so there could be junk in
2710328d5752SMark Fasheh 		 * the other fields.
2711328d5752SMark Fasheh 		 */
2712328d5752SMark Fasheh 		memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2713328d5752SMark Fasheh 	}
2714328d5752SMark Fasheh }
2715328d5752SMark Fasheh 
2716677b9752STao Ma static int ocfs2_get_right_path(struct inode *inode,
2717677b9752STao Ma 				struct ocfs2_path *left_path,
2718677b9752STao Ma 				struct ocfs2_path **ret_right_path)
2719328d5752SMark Fasheh {
2720328d5752SMark Fasheh 	int ret;
2721677b9752STao Ma 	u32 right_cpos;
2722677b9752STao Ma 	struct ocfs2_path *right_path = NULL;
2723677b9752STao Ma 	struct ocfs2_extent_list *left_el;
2724677b9752STao Ma 
2725677b9752STao Ma 	*ret_right_path = NULL;
2726677b9752STao Ma 
2727677b9752STao Ma 	/* This function shouldn't be called for non-trees. */
2728677b9752STao Ma 	BUG_ON(left_path->p_tree_depth == 0);
2729677b9752STao Ma 
2730677b9752STao Ma 	left_el = path_leaf_el(left_path);
2731677b9752STao Ma 	BUG_ON(left_el->l_next_free_rec != left_el->l_count);
2732677b9752STao Ma 
2733677b9752STao Ma 	ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, left_path,
2734677b9752STao Ma 					     &right_cpos);
2735677b9752STao Ma 	if (ret) {
2736677b9752STao Ma 		mlog_errno(ret);
2737677b9752STao Ma 		goto out;
2738677b9752STao Ma 	}
2739677b9752STao Ma 
2740677b9752STao Ma 	/* This function shouldn't be called for the rightmost leaf. */
2741677b9752STao Ma 	BUG_ON(right_cpos == 0);
2742677b9752STao Ma 
2743677b9752STao Ma 	right_path = ocfs2_new_path(path_root_bh(left_path),
2744677b9752STao Ma 				    path_root_el(left_path));
2745677b9752STao Ma 	if (!right_path) {
2746677b9752STao Ma 		ret = -ENOMEM;
2747677b9752STao Ma 		mlog_errno(ret);
2748677b9752STao Ma 		goto out;
2749677b9752STao Ma 	}
2750677b9752STao Ma 
2751677b9752STao Ma 	ret = ocfs2_find_path(inode, right_path, right_cpos);
2752677b9752STao Ma 	if (ret) {
2753677b9752STao Ma 		mlog_errno(ret);
2754677b9752STao Ma 		goto out;
2755677b9752STao Ma 	}
2756677b9752STao Ma 
2757677b9752STao Ma 	*ret_right_path = right_path;
2758677b9752STao Ma out:
2759677b9752STao Ma 	if (ret)
2760677b9752STao Ma 		ocfs2_free_path(right_path);
2761677b9752STao Ma 	return ret;
2762677b9752STao Ma }
2763677b9752STao Ma 
2764677b9752STao Ma /*
2765677b9752STao Ma  * Remove split_rec clusters from the record at index and merge them
2766677b9752STao Ma  * onto the beginning of the record "next" to it.
2767677b9752STao Ma  * For index < l_count - 1, the next means the extent rec at index + 1.
2768677b9752STao Ma  * For index == l_count - 1, the "next" means the 1st extent rec of the
2769677b9752STao Ma  * next extent block.
2770677b9752STao Ma  */
2771677b9752STao Ma static int ocfs2_merge_rec_right(struct inode *inode,
2772677b9752STao Ma 				 struct ocfs2_path *left_path,
2773677b9752STao Ma 				 handle_t *handle,
2774677b9752STao Ma 				 struct ocfs2_extent_rec *split_rec,
2775677b9752STao Ma 				 int index)
2776677b9752STao Ma {
2777677b9752STao Ma 	int ret, next_free, i;
2778328d5752SMark Fasheh 	unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
2779328d5752SMark Fasheh 	struct ocfs2_extent_rec *left_rec;
2780328d5752SMark Fasheh 	struct ocfs2_extent_rec *right_rec;
2781677b9752STao Ma 	struct ocfs2_extent_list *right_el;
2782677b9752STao Ma 	struct ocfs2_path *right_path = NULL;
2783677b9752STao Ma 	int subtree_index = 0;
2784677b9752STao Ma 	struct ocfs2_extent_list *el = path_leaf_el(left_path);
2785677b9752STao Ma 	struct buffer_head *bh = path_leaf_bh(left_path);
2786677b9752STao Ma 	struct buffer_head *root_bh = NULL;
2787328d5752SMark Fasheh 
2788328d5752SMark Fasheh 	BUG_ON(index >= le16_to_cpu(el->l_next_free_rec));
2789328d5752SMark Fasheh 	left_rec = &el->l_recs[index];
2790677b9752STao Ma 
2791677b9752STao Ma 	if (index == le16_to_cpu(el->l_next_free_rec - 1) &&
2792677b9752STao Ma 	    le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count)) {
2793677b9752STao Ma 		/* we meet with a cross extent block merge. */
2794677b9752STao Ma 		ret = ocfs2_get_right_path(inode, left_path, &right_path);
2795677b9752STao Ma 		if (ret) {
2796677b9752STao Ma 			mlog_errno(ret);
2797677b9752STao Ma 			goto out;
2798677b9752STao Ma 		}
2799677b9752STao Ma 
2800677b9752STao Ma 		right_el = path_leaf_el(right_path);
2801677b9752STao Ma 		next_free = le16_to_cpu(right_el->l_next_free_rec);
2802677b9752STao Ma 		BUG_ON(next_free <= 0);
2803677b9752STao Ma 		right_rec = &right_el->l_recs[0];
2804677b9752STao Ma 		if (ocfs2_is_empty_extent(right_rec)) {
2805677b9752STao Ma 			BUG_ON(le16_to_cpu(next_free) <= 1);
2806677b9752STao Ma 			right_rec = &right_el->l_recs[1];
2807677b9752STao Ma 		}
2808677b9752STao Ma 
2809677b9752STao Ma 		BUG_ON(le32_to_cpu(left_rec->e_cpos) +
2810677b9752STao Ma 		       le16_to_cpu(left_rec->e_leaf_clusters) !=
2811677b9752STao Ma 		       le32_to_cpu(right_rec->e_cpos));
2812677b9752STao Ma 
2813677b9752STao Ma 		subtree_index = ocfs2_find_subtree_root(inode,
2814677b9752STao Ma 							left_path, right_path);
2815677b9752STao Ma 
2816677b9752STao Ma 		ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
2817677b9752STao Ma 						      handle->h_buffer_credits,
2818677b9752STao Ma 						      right_path);
2819677b9752STao Ma 		if (ret) {
2820677b9752STao Ma 			mlog_errno(ret);
2821677b9752STao Ma 			goto out;
2822677b9752STao Ma 		}
2823677b9752STao Ma 
2824677b9752STao Ma 		root_bh = left_path->p_node[subtree_index].bh;
2825677b9752STao Ma 		BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2826677b9752STao Ma 
2827677b9752STao Ma 		ret = ocfs2_journal_access(handle, inode, root_bh,
2828677b9752STao Ma 					   OCFS2_JOURNAL_ACCESS_WRITE);
2829677b9752STao Ma 		if (ret) {
2830677b9752STao Ma 			mlog_errno(ret);
2831677b9752STao Ma 			goto out;
2832677b9752STao Ma 		}
2833677b9752STao Ma 
2834677b9752STao Ma 		for (i = subtree_index + 1;
2835677b9752STao Ma 		     i < path_num_items(right_path); i++) {
2836677b9752STao Ma 			ret = ocfs2_journal_access(handle, inode,
2837677b9752STao Ma 						   right_path->p_node[i].bh,
2838677b9752STao Ma 						   OCFS2_JOURNAL_ACCESS_WRITE);
2839677b9752STao Ma 			if (ret) {
2840677b9752STao Ma 				mlog_errno(ret);
2841677b9752STao Ma 				goto out;
2842677b9752STao Ma 			}
2843677b9752STao Ma 
2844677b9752STao Ma 			ret = ocfs2_journal_access(handle, inode,
2845677b9752STao Ma 						   left_path->p_node[i].bh,
2846677b9752STao Ma 						   OCFS2_JOURNAL_ACCESS_WRITE);
2847677b9752STao Ma 			if (ret) {
2848677b9752STao Ma 				mlog_errno(ret);
2849677b9752STao Ma 				goto out;
2850677b9752STao Ma 			}
2851677b9752STao Ma 		}
2852677b9752STao Ma 
2853677b9752STao Ma 	} else {
2854677b9752STao Ma 		BUG_ON(index == le16_to_cpu(el->l_next_free_rec) - 1);
2855328d5752SMark Fasheh 		right_rec = &el->l_recs[index + 1];
2856677b9752STao Ma 	}
2857328d5752SMark Fasheh 
2858328d5752SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, bh,
2859328d5752SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
2860328d5752SMark Fasheh 	if (ret) {
2861328d5752SMark Fasheh 		mlog_errno(ret);
2862328d5752SMark Fasheh 		goto out;
2863328d5752SMark Fasheh 	}
2864328d5752SMark Fasheh 
2865328d5752SMark Fasheh 	le16_add_cpu(&left_rec->e_leaf_clusters, -split_clusters);
2866328d5752SMark Fasheh 
2867328d5752SMark Fasheh 	le32_add_cpu(&right_rec->e_cpos, -split_clusters);
2868328d5752SMark Fasheh 	le64_add_cpu(&right_rec->e_blkno,
2869328d5752SMark Fasheh 		     -ocfs2_clusters_to_blocks(inode->i_sb, split_clusters));
2870328d5752SMark Fasheh 	le16_add_cpu(&right_rec->e_leaf_clusters, split_clusters);
2871328d5752SMark Fasheh 
2872328d5752SMark Fasheh 	ocfs2_cleanup_merge(el, index);
2873328d5752SMark Fasheh 
2874328d5752SMark Fasheh 	ret = ocfs2_journal_dirty(handle, bh);
2875328d5752SMark Fasheh 	if (ret)
2876328d5752SMark Fasheh 		mlog_errno(ret);
2877328d5752SMark Fasheh 
2878677b9752STao Ma 	if (right_path) {
2879677b9752STao Ma 		ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
2880677b9752STao Ma 		if (ret)
2881677b9752STao Ma 			mlog_errno(ret);
2882677b9752STao Ma 
2883677b9752STao Ma 		ocfs2_complete_edge_insert(inode, handle, left_path,
2884677b9752STao Ma 					   right_path, subtree_index);
2885677b9752STao Ma 	}
2886328d5752SMark Fasheh out:
2887677b9752STao Ma 	if (right_path)
2888677b9752STao Ma 		ocfs2_free_path(right_path);
2889677b9752STao Ma 	return ret;
2890677b9752STao Ma }
2891677b9752STao Ma 
2892677b9752STao Ma static int ocfs2_get_left_path(struct inode *inode,
2893677b9752STao Ma 			       struct ocfs2_path *right_path,
2894677b9752STao Ma 			       struct ocfs2_path **ret_left_path)
2895677b9752STao Ma {
2896677b9752STao Ma 	int ret;
2897677b9752STao Ma 	u32 left_cpos;
2898677b9752STao Ma 	struct ocfs2_path *left_path = NULL;
2899677b9752STao Ma 
2900677b9752STao Ma 	*ret_left_path = NULL;
2901677b9752STao Ma 
2902677b9752STao Ma 	/* This function shouldn't be called for non-trees. */
2903677b9752STao Ma 	BUG_ON(right_path->p_tree_depth == 0);
2904677b9752STao Ma 
2905677b9752STao Ma 	ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb,
2906677b9752STao Ma 					    right_path, &left_cpos);
2907677b9752STao Ma 	if (ret) {
2908677b9752STao Ma 		mlog_errno(ret);
2909677b9752STao Ma 		goto out;
2910677b9752STao Ma 	}
2911677b9752STao Ma 
2912677b9752STao Ma 	/* This function shouldn't be called for the leftmost leaf. */
2913677b9752STao Ma 	BUG_ON(left_cpos == 0);
2914677b9752STao Ma 
2915677b9752STao Ma 	left_path = ocfs2_new_path(path_root_bh(right_path),
2916677b9752STao Ma 				   path_root_el(right_path));
2917677b9752STao Ma 	if (!left_path) {
2918677b9752STao Ma 		ret = -ENOMEM;
2919677b9752STao Ma 		mlog_errno(ret);
2920677b9752STao Ma 		goto out;
2921677b9752STao Ma 	}
2922677b9752STao Ma 
2923677b9752STao Ma 	ret = ocfs2_find_path(inode, left_path, left_cpos);
2924677b9752STao Ma 	if (ret) {
2925677b9752STao Ma 		mlog_errno(ret);
2926677b9752STao Ma 		goto out;
2927677b9752STao Ma 	}
2928677b9752STao Ma 
2929677b9752STao Ma 	*ret_left_path = left_path;
2930677b9752STao Ma out:
2931677b9752STao Ma 	if (ret)
2932677b9752STao Ma 		ocfs2_free_path(left_path);
2933328d5752SMark Fasheh 	return ret;
2934328d5752SMark Fasheh }
2935328d5752SMark Fasheh 
2936328d5752SMark Fasheh /*
2937328d5752SMark Fasheh  * Remove split_rec clusters from the record at index and merge them
2938677b9752STao Ma  * onto the tail of the record "before" it.
2939677b9752STao Ma  * For index > 0, the "before" means the extent rec at index - 1.
2940677b9752STao Ma  *
2941677b9752STao Ma  * For index == 0, the "before" means the last record of the previous
2942677b9752STao Ma  * extent block. And there is also a situation that we may need to
2943677b9752STao Ma  * remove the rightmost leaf extent block in the right_path and change
2944677b9752STao Ma  * the right path to indicate the new rightmost path.
2945328d5752SMark Fasheh  */
2946677b9752STao Ma static int ocfs2_merge_rec_left(struct inode *inode,
2947677b9752STao Ma 				struct ocfs2_path *right_path,
2948328d5752SMark Fasheh 				handle_t *handle,
2949328d5752SMark Fasheh 				struct ocfs2_extent_rec *split_rec,
2950677b9752STao Ma 				struct ocfs2_cached_dealloc_ctxt *dealloc,
2951677b9752STao Ma 				int index)
2952328d5752SMark Fasheh {
2953677b9752STao Ma 	int ret, i, subtree_index = 0, has_empty_extent = 0;
2954328d5752SMark Fasheh 	unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
2955328d5752SMark Fasheh 	struct ocfs2_extent_rec *left_rec;
2956328d5752SMark Fasheh 	struct ocfs2_extent_rec *right_rec;
2957677b9752STao Ma 	struct ocfs2_extent_list *el = path_leaf_el(right_path);
2958677b9752STao Ma 	struct buffer_head *bh = path_leaf_bh(right_path);
2959677b9752STao Ma 	struct buffer_head *root_bh = NULL;
2960677b9752STao Ma 	struct ocfs2_path *left_path = NULL;
2961677b9752STao Ma 	struct ocfs2_extent_list *left_el;
2962328d5752SMark Fasheh 
2963677b9752STao Ma 	BUG_ON(index < 0);
2964328d5752SMark Fasheh 
2965328d5752SMark Fasheh 	right_rec = &el->l_recs[index];
2966677b9752STao Ma 	if (index == 0) {
2967677b9752STao Ma 		/* we meet with a cross extent block merge. */
2968677b9752STao Ma 		ret = ocfs2_get_left_path(inode, right_path, &left_path);
2969677b9752STao Ma 		if (ret) {
2970677b9752STao Ma 			mlog_errno(ret);
2971677b9752STao Ma 			goto out;
2972677b9752STao Ma 		}
2973677b9752STao Ma 
2974677b9752STao Ma 		left_el = path_leaf_el(left_path);
2975677b9752STao Ma 		BUG_ON(le16_to_cpu(left_el->l_next_free_rec) !=
2976677b9752STao Ma 		       le16_to_cpu(left_el->l_count));
2977677b9752STao Ma 
2978677b9752STao Ma 		left_rec = &left_el->l_recs[
2979677b9752STao Ma 				le16_to_cpu(left_el->l_next_free_rec) - 1];
2980677b9752STao Ma 		BUG_ON(le32_to_cpu(left_rec->e_cpos) +
2981677b9752STao Ma 		       le16_to_cpu(left_rec->e_leaf_clusters) !=
2982677b9752STao Ma 		       le32_to_cpu(split_rec->e_cpos));
2983677b9752STao Ma 
2984677b9752STao Ma 		subtree_index = ocfs2_find_subtree_root(inode,
2985677b9752STao Ma 							left_path, right_path);
2986677b9752STao Ma 
2987677b9752STao Ma 		ret = ocfs2_extend_rotate_transaction(handle, subtree_index,
2988677b9752STao Ma 						      handle->h_buffer_credits,
2989677b9752STao Ma 						      left_path);
2990677b9752STao Ma 		if (ret) {
2991677b9752STao Ma 			mlog_errno(ret);
2992677b9752STao Ma 			goto out;
2993677b9752STao Ma 		}
2994677b9752STao Ma 
2995677b9752STao Ma 		root_bh = left_path->p_node[subtree_index].bh;
2996677b9752STao Ma 		BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2997677b9752STao Ma 
2998677b9752STao Ma 		ret = ocfs2_journal_access(handle, inode, root_bh,
2999677b9752STao Ma 					   OCFS2_JOURNAL_ACCESS_WRITE);
3000677b9752STao Ma 		if (ret) {
3001677b9752STao Ma 			mlog_errno(ret);
3002677b9752STao Ma 			goto out;
3003677b9752STao Ma 		}
3004677b9752STao Ma 
3005677b9752STao Ma 		for (i = subtree_index + 1;
3006677b9752STao Ma 		     i < path_num_items(right_path); i++) {
3007677b9752STao Ma 			ret = ocfs2_journal_access(handle, inode,
3008677b9752STao Ma 						   right_path->p_node[i].bh,
3009677b9752STao Ma 						   OCFS2_JOURNAL_ACCESS_WRITE);
3010677b9752STao Ma 			if (ret) {
3011677b9752STao Ma 				mlog_errno(ret);
3012677b9752STao Ma 				goto out;
3013677b9752STao Ma 			}
3014677b9752STao Ma 
3015677b9752STao Ma 			ret = ocfs2_journal_access(handle, inode,
3016677b9752STao Ma 						   left_path->p_node[i].bh,
3017677b9752STao Ma 						   OCFS2_JOURNAL_ACCESS_WRITE);
3018677b9752STao Ma 			if (ret) {
3019677b9752STao Ma 				mlog_errno(ret);
3020677b9752STao Ma 				goto out;
3021677b9752STao Ma 			}
3022677b9752STao Ma 		}
3023677b9752STao Ma 	} else {
3024677b9752STao Ma 		left_rec = &el->l_recs[index - 1];
3025328d5752SMark Fasheh 		if (ocfs2_is_empty_extent(&el->l_recs[0]))
3026328d5752SMark Fasheh 			has_empty_extent = 1;
3027677b9752STao Ma 	}
3028328d5752SMark Fasheh 
3029328d5752SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, bh,
3030328d5752SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
3031328d5752SMark Fasheh 	if (ret) {
3032328d5752SMark Fasheh 		mlog_errno(ret);
3033328d5752SMark Fasheh 		goto out;
3034328d5752SMark Fasheh 	}
3035328d5752SMark Fasheh 
3036328d5752SMark Fasheh 	if (has_empty_extent && index == 1) {
3037328d5752SMark Fasheh 		/*
3038328d5752SMark Fasheh 		 * The easy case - we can just plop the record right in.
3039328d5752SMark Fasheh 		 */
3040328d5752SMark Fasheh 		*left_rec = *split_rec;
3041328d5752SMark Fasheh 
3042328d5752SMark Fasheh 		has_empty_extent = 0;
3043677b9752STao Ma 	} else
3044328d5752SMark Fasheh 		le16_add_cpu(&left_rec->e_leaf_clusters, split_clusters);
3045328d5752SMark Fasheh 
3046328d5752SMark Fasheh 	le32_add_cpu(&right_rec->e_cpos, split_clusters);
3047328d5752SMark Fasheh 	le64_add_cpu(&right_rec->e_blkno,
3048328d5752SMark Fasheh 		     ocfs2_clusters_to_blocks(inode->i_sb, split_clusters));
3049328d5752SMark Fasheh 	le16_add_cpu(&right_rec->e_leaf_clusters, -split_clusters);
3050328d5752SMark Fasheh 
3051328d5752SMark Fasheh 	ocfs2_cleanup_merge(el, index);
3052328d5752SMark Fasheh 
3053328d5752SMark Fasheh 	ret = ocfs2_journal_dirty(handle, bh);
3054328d5752SMark Fasheh 	if (ret)
3055328d5752SMark Fasheh 		mlog_errno(ret);
3056328d5752SMark Fasheh 
3057677b9752STao Ma 	if (left_path) {
3058677b9752STao Ma 		ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
3059677b9752STao Ma 		if (ret)
3060677b9752STao Ma 			mlog_errno(ret);
3061677b9752STao Ma 
3062677b9752STao Ma 		/*
3063677b9752STao Ma 		 * In the situation that the right_rec is empty and the extent
3064677b9752STao Ma 		 * block is empty also,  ocfs2_complete_edge_insert can't handle
3065677b9752STao Ma 		 * it and we need to delete the right extent block.
3066677b9752STao Ma 		 */
3067677b9752STao Ma 		if (le16_to_cpu(right_rec->e_leaf_clusters) == 0 &&
3068677b9752STao Ma 		    le16_to_cpu(el->l_next_free_rec) == 1) {
3069677b9752STao Ma 
3070677b9752STao Ma 			ret = ocfs2_remove_rightmost_path(inode, handle,
3071677b9752STao Ma 							  right_path, dealloc);
3072677b9752STao Ma 			if (ret) {
3073677b9752STao Ma 				mlog_errno(ret);
3074677b9752STao Ma 				goto out;
3075677b9752STao Ma 			}
3076677b9752STao Ma 
3077677b9752STao Ma 			/* Now the rightmost extent block has been deleted.
3078677b9752STao Ma 			 * So we use the new rightmost path.
3079677b9752STao Ma 			 */
3080677b9752STao Ma 			ocfs2_mv_path(right_path, left_path);
3081677b9752STao Ma 			left_path = NULL;
3082677b9752STao Ma 		} else
3083677b9752STao Ma 			ocfs2_complete_edge_insert(inode, handle, left_path,
3084677b9752STao Ma 						   right_path, subtree_index);
3085677b9752STao Ma 	}
3086328d5752SMark Fasheh out:
3087677b9752STao Ma 	if (left_path)
3088677b9752STao Ma 		ocfs2_free_path(left_path);
3089328d5752SMark Fasheh 	return ret;
3090328d5752SMark Fasheh }
3091328d5752SMark Fasheh 
3092328d5752SMark Fasheh static int ocfs2_try_to_merge_extent(struct inode *inode,
3093328d5752SMark Fasheh 				     handle_t *handle,
3094677b9752STao Ma 				     struct ocfs2_path *path,
3095328d5752SMark Fasheh 				     int split_index,
3096328d5752SMark Fasheh 				     struct ocfs2_extent_rec *split_rec,
3097328d5752SMark Fasheh 				     struct ocfs2_cached_dealloc_ctxt *dealloc,
3098328d5752SMark Fasheh 				     struct ocfs2_merge_ctxt *ctxt)
3099328d5752SMark Fasheh 
3100328d5752SMark Fasheh {
3101518d7269STao Mao 	int ret = 0;
3102677b9752STao Ma 	struct ocfs2_extent_list *el = path_leaf_el(path);
3103328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
3104328d5752SMark Fasheh 
3105328d5752SMark Fasheh 	BUG_ON(ctxt->c_contig_type == CONTIG_NONE);
3106328d5752SMark Fasheh 
3107518d7269STao Mao 	if (ctxt->c_split_covers_rec && ctxt->c_has_empty_extent) {
3108328d5752SMark Fasheh 		/*
3109328d5752SMark Fasheh 		 * The merge code will need to create an empty
3110328d5752SMark Fasheh 		 * extent to take the place of the newly
3111328d5752SMark Fasheh 		 * emptied slot. Remove any pre-existing empty
3112328d5752SMark Fasheh 		 * extents - having more than one in a leaf is
3113328d5752SMark Fasheh 		 * illegal.
3114328d5752SMark Fasheh 		 */
3115677b9752STao Ma 		ret = ocfs2_rotate_tree_left(inode, handle, path,
3116328d5752SMark Fasheh 					     dealloc);
3117328d5752SMark Fasheh 		if (ret) {
3118328d5752SMark Fasheh 			mlog_errno(ret);
3119328d5752SMark Fasheh 			goto out;
3120328d5752SMark Fasheh 		}
3121328d5752SMark Fasheh 		split_index--;
3122328d5752SMark Fasheh 		rec = &el->l_recs[split_index];
3123328d5752SMark Fasheh 	}
3124328d5752SMark Fasheh 
3125328d5752SMark Fasheh 	if (ctxt->c_contig_type == CONTIG_LEFTRIGHT) {
3126328d5752SMark Fasheh 		/*
3127328d5752SMark Fasheh 		 * Left-right contig implies this.
3128328d5752SMark Fasheh 		 */
3129328d5752SMark Fasheh 		BUG_ON(!ctxt->c_split_covers_rec);
3130328d5752SMark Fasheh 
3131328d5752SMark Fasheh 		/*
3132328d5752SMark Fasheh 		 * Since the leftright insert always covers the entire
3133328d5752SMark Fasheh 		 * extent, this call will delete the insert record
3134328d5752SMark Fasheh 		 * entirely, resulting in an empty extent record added to
3135328d5752SMark Fasheh 		 * the extent block.
3136328d5752SMark Fasheh 		 *
3137328d5752SMark Fasheh 		 * Since the adding of an empty extent shifts
3138328d5752SMark Fasheh 		 * everything back to the right, there's no need to
3139328d5752SMark Fasheh 		 * update split_index here.
3140677b9752STao Ma 		 *
3141677b9752STao Ma 		 * When the split_index is zero, we need to merge it to the
3142677b9752STao Ma 		 * prevoius extent block. It is more efficient and easier
3143677b9752STao Ma 		 * if we do merge_right first and merge_left later.
3144328d5752SMark Fasheh 		 */
3145677b9752STao Ma 		ret = ocfs2_merge_rec_right(inode, path,
3146677b9752STao Ma 					    handle, split_rec,
3147677b9752STao Ma 					    split_index);
3148328d5752SMark Fasheh 		if (ret) {
3149328d5752SMark Fasheh 			mlog_errno(ret);
3150328d5752SMark Fasheh 			goto out;
3151328d5752SMark Fasheh 		}
3152328d5752SMark Fasheh 
3153328d5752SMark Fasheh 		/*
3154328d5752SMark Fasheh 		 * We can only get this from logic error above.
3155328d5752SMark Fasheh 		 */
3156328d5752SMark Fasheh 		BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0]));
3157328d5752SMark Fasheh 
3158677b9752STao Ma 		/* The merge left us with an empty extent, remove it. */
3159677b9752STao Ma 		ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc);
3160328d5752SMark Fasheh 		if (ret) {
3161328d5752SMark Fasheh 			mlog_errno(ret);
3162328d5752SMark Fasheh 			goto out;
3163328d5752SMark Fasheh 		}
3164677b9752STao Ma 
3165328d5752SMark Fasheh 		rec = &el->l_recs[split_index];
3166328d5752SMark Fasheh 
3167328d5752SMark Fasheh 		/*
3168328d5752SMark Fasheh 		 * Note that we don't pass split_rec here on purpose -
3169677b9752STao Ma 		 * we've merged it into the rec already.
3170328d5752SMark Fasheh 		 */
3171677b9752STao Ma 		ret = ocfs2_merge_rec_left(inode, path,
3172677b9752STao Ma 					   handle, rec,
3173677b9752STao Ma 					   dealloc,
3174677b9752STao Ma 					   split_index);
3175677b9752STao Ma 
3176328d5752SMark Fasheh 		if (ret) {
3177328d5752SMark Fasheh 			mlog_errno(ret);
3178328d5752SMark Fasheh 			goto out;
3179328d5752SMark Fasheh 		}
3180328d5752SMark Fasheh 
3181677b9752STao Ma 		ret = ocfs2_rotate_tree_left(inode, handle, path,
3182328d5752SMark Fasheh 					     dealloc);
3183328d5752SMark Fasheh 		/*
3184328d5752SMark Fasheh 		 * Error from this last rotate is not critical, so
3185328d5752SMark Fasheh 		 * print but don't bubble it up.
3186328d5752SMark Fasheh 		 */
3187328d5752SMark Fasheh 		if (ret)
3188328d5752SMark Fasheh 			mlog_errno(ret);
3189328d5752SMark Fasheh 		ret = 0;
3190328d5752SMark Fasheh 	} else {
3191328d5752SMark Fasheh 		/*
3192328d5752SMark Fasheh 		 * Merge a record to the left or right.
3193328d5752SMark Fasheh 		 *
3194328d5752SMark Fasheh 		 * 'contig_type' is relative to the existing record,
3195328d5752SMark Fasheh 		 * so for example, if we're "right contig", it's to
3196328d5752SMark Fasheh 		 * the record on the left (hence the left merge).
3197328d5752SMark Fasheh 		 */
3198328d5752SMark Fasheh 		if (ctxt->c_contig_type == CONTIG_RIGHT) {
3199328d5752SMark Fasheh 			ret = ocfs2_merge_rec_left(inode,
3200677b9752STao Ma 						   path,
3201677b9752STao Ma 						   handle, split_rec,
3202677b9752STao Ma 						   dealloc,
3203328d5752SMark Fasheh 						   split_index);
3204328d5752SMark Fasheh 			if (ret) {
3205328d5752SMark Fasheh 				mlog_errno(ret);
3206328d5752SMark Fasheh 				goto out;
3207328d5752SMark Fasheh 			}
3208328d5752SMark Fasheh 		} else {
3209328d5752SMark Fasheh 			ret = ocfs2_merge_rec_right(inode,
3210677b9752STao Ma 						    path,
3211677b9752STao Ma 						    handle, split_rec,
3212328d5752SMark Fasheh 						    split_index);
3213328d5752SMark Fasheh 			if (ret) {
3214328d5752SMark Fasheh 				mlog_errno(ret);
3215328d5752SMark Fasheh 				goto out;
3216328d5752SMark Fasheh 			}
3217328d5752SMark Fasheh 		}
3218328d5752SMark Fasheh 
3219328d5752SMark Fasheh 		if (ctxt->c_split_covers_rec) {
3220328d5752SMark Fasheh 			/*
3221328d5752SMark Fasheh 			 * The merge may have left an empty extent in
3222328d5752SMark Fasheh 			 * our leaf. Try to rotate it away.
3223328d5752SMark Fasheh 			 */
3224677b9752STao Ma 			ret = ocfs2_rotate_tree_left(inode, handle, path,
3225328d5752SMark Fasheh 						     dealloc);
3226328d5752SMark Fasheh 			if (ret)
3227328d5752SMark Fasheh 				mlog_errno(ret);
3228328d5752SMark Fasheh 			ret = 0;
3229328d5752SMark Fasheh 		}
3230328d5752SMark Fasheh 	}
3231328d5752SMark Fasheh 
3232328d5752SMark Fasheh out:
3233328d5752SMark Fasheh 	return ret;
3234328d5752SMark Fasheh }
3235328d5752SMark Fasheh 
3236328d5752SMark Fasheh static void ocfs2_subtract_from_rec(struct super_block *sb,
3237328d5752SMark Fasheh 				    enum ocfs2_split_type split,
3238328d5752SMark Fasheh 				    struct ocfs2_extent_rec *rec,
3239328d5752SMark Fasheh 				    struct ocfs2_extent_rec *split_rec)
3240328d5752SMark Fasheh {
3241328d5752SMark Fasheh 	u64 len_blocks;
3242328d5752SMark Fasheh 
3243328d5752SMark Fasheh 	len_blocks = ocfs2_clusters_to_blocks(sb,
3244328d5752SMark Fasheh 				le16_to_cpu(split_rec->e_leaf_clusters));
3245328d5752SMark Fasheh 
3246328d5752SMark Fasheh 	if (split == SPLIT_LEFT) {
3247328d5752SMark Fasheh 		/*
3248328d5752SMark Fasheh 		 * Region is on the left edge of the existing
3249328d5752SMark Fasheh 		 * record.
3250328d5752SMark Fasheh 		 */
3251328d5752SMark Fasheh 		le32_add_cpu(&rec->e_cpos,
3252328d5752SMark Fasheh 			     le16_to_cpu(split_rec->e_leaf_clusters));
3253328d5752SMark Fasheh 		le64_add_cpu(&rec->e_blkno, len_blocks);
3254328d5752SMark Fasheh 		le16_add_cpu(&rec->e_leaf_clusters,
3255328d5752SMark Fasheh 			     -le16_to_cpu(split_rec->e_leaf_clusters));
3256328d5752SMark Fasheh 	} else {
3257328d5752SMark Fasheh 		/*
3258328d5752SMark Fasheh 		 * Region is on the right edge of the existing
3259328d5752SMark Fasheh 		 * record.
3260328d5752SMark Fasheh 		 */
3261328d5752SMark Fasheh 		le16_add_cpu(&rec->e_leaf_clusters,
3262328d5752SMark Fasheh 			     -le16_to_cpu(split_rec->e_leaf_clusters));
3263328d5752SMark Fasheh 	}
3264328d5752SMark Fasheh }
3265328d5752SMark Fasheh 
3266dcd0538fSMark Fasheh /*
3267dcd0538fSMark Fasheh  * Do the final bits of extent record insertion at the target leaf
3268dcd0538fSMark Fasheh  * list. If this leaf is part of an allocation tree, it is assumed
3269dcd0538fSMark Fasheh  * that the tree above has been prepared.
3270dcd0538fSMark Fasheh  */
3271dcd0538fSMark Fasheh static void ocfs2_insert_at_leaf(struct ocfs2_extent_rec *insert_rec,
3272dcd0538fSMark Fasheh 				 struct ocfs2_extent_list *el,
3273dcd0538fSMark Fasheh 				 struct ocfs2_insert_type *insert,
3274dcd0538fSMark Fasheh 				 struct inode *inode)
3275dcd0538fSMark Fasheh {
3276dcd0538fSMark Fasheh 	int i = insert->ins_contig_index;
3277dcd0538fSMark Fasheh 	unsigned int range;
3278dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *rec;
3279dcd0538fSMark Fasheh 
3280e48edee2SMark Fasheh 	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
3281dcd0538fSMark Fasheh 
3282328d5752SMark Fasheh 	if (insert->ins_split != SPLIT_NONE) {
3283328d5752SMark Fasheh 		i = ocfs2_search_extent_list(el, le32_to_cpu(insert_rec->e_cpos));
3284328d5752SMark Fasheh 		BUG_ON(i == -1);
3285328d5752SMark Fasheh 		rec = &el->l_recs[i];
3286328d5752SMark Fasheh 		ocfs2_subtract_from_rec(inode->i_sb, insert->ins_split, rec,
3287328d5752SMark Fasheh 					insert_rec);
3288328d5752SMark Fasheh 		goto rotate;
3289328d5752SMark Fasheh 	}
3290328d5752SMark Fasheh 
3291dcd0538fSMark Fasheh 	/*
3292dcd0538fSMark Fasheh 	 * Contiguous insert - either left or right.
3293dcd0538fSMark Fasheh 	 */
3294dcd0538fSMark Fasheh 	if (insert->ins_contig != CONTIG_NONE) {
3295dcd0538fSMark Fasheh 		rec = &el->l_recs[i];
3296dcd0538fSMark Fasheh 		if (insert->ins_contig == CONTIG_LEFT) {
3297dcd0538fSMark Fasheh 			rec->e_blkno = insert_rec->e_blkno;
3298dcd0538fSMark Fasheh 			rec->e_cpos = insert_rec->e_cpos;
3299dcd0538fSMark Fasheh 		}
3300e48edee2SMark Fasheh 		le16_add_cpu(&rec->e_leaf_clusters,
3301e48edee2SMark Fasheh 			     le16_to_cpu(insert_rec->e_leaf_clusters));
3302dcd0538fSMark Fasheh 		return;
3303dcd0538fSMark Fasheh 	}
3304dcd0538fSMark Fasheh 
3305dcd0538fSMark Fasheh 	/*
3306dcd0538fSMark Fasheh 	 * Handle insert into an empty leaf.
3307dcd0538fSMark Fasheh 	 */
3308dcd0538fSMark Fasheh 	if (le16_to_cpu(el->l_next_free_rec) == 0 ||
3309dcd0538fSMark Fasheh 	    ((le16_to_cpu(el->l_next_free_rec) == 1) &&
3310dcd0538fSMark Fasheh 	     ocfs2_is_empty_extent(&el->l_recs[0]))) {
3311dcd0538fSMark Fasheh 		el->l_recs[0] = *insert_rec;
3312dcd0538fSMark Fasheh 		el->l_next_free_rec = cpu_to_le16(1);
3313dcd0538fSMark Fasheh 		return;
3314dcd0538fSMark Fasheh 	}
3315dcd0538fSMark Fasheh 
3316dcd0538fSMark Fasheh 	/*
3317dcd0538fSMark Fasheh 	 * Appending insert.
3318dcd0538fSMark Fasheh 	 */
3319dcd0538fSMark Fasheh 	if (insert->ins_appending == APPEND_TAIL) {
3320dcd0538fSMark Fasheh 		i = le16_to_cpu(el->l_next_free_rec) - 1;
3321dcd0538fSMark Fasheh 		rec = &el->l_recs[i];
3322e48edee2SMark Fasheh 		range = le32_to_cpu(rec->e_cpos)
3323e48edee2SMark Fasheh 			+ le16_to_cpu(rec->e_leaf_clusters);
3324dcd0538fSMark Fasheh 		BUG_ON(le32_to_cpu(insert_rec->e_cpos) < range);
3325dcd0538fSMark Fasheh 
3326dcd0538fSMark Fasheh 		mlog_bug_on_msg(le16_to_cpu(el->l_next_free_rec) >=
3327dcd0538fSMark Fasheh 				le16_to_cpu(el->l_count),
3328dcd0538fSMark Fasheh 				"inode %lu, depth %u, count %u, next free %u, "
3329dcd0538fSMark Fasheh 				"rec.cpos %u, rec.clusters %u, "
3330dcd0538fSMark Fasheh 				"insert.cpos %u, insert.clusters %u\n",
3331dcd0538fSMark Fasheh 				inode->i_ino,
3332dcd0538fSMark Fasheh 				le16_to_cpu(el->l_tree_depth),
3333dcd0538fSMark Fasheh 				le16_to_cpu(el->l_count),
3334dcd0538fSMark Fasheh 				le16_to_cpu(el->l_next_free_rec),
3335dcd0538fSMark Fasheh 				le32_to_cpu(el->l_recs[i].e_cpos),
3336e48edee2SMark Fasheh 				le16_to_cpu(el->l_recs[i].e_leaf_clusters),
3337dcd0538fSMark Fasheh 				le32_to_cpu(insert_rec->e_cpos),
3338e48edee2SMark Fasheh 				le16_to_cpu(insert_rec->e_leaf_clusters));
3339dcd0538fSMark Fasheh 		i++;
3340dcd0538fSMark Fasheh 		el->l_recs[i] = *insert_rec;
3341dcd0538fSMark Fasheh 		le16_add_cpu(&el->l_next_free_rec, 1);
3342dcd0538fSMark Fasheh 		return;
3343dcd0538fSMark Fasheh 	}
3344dcd0538fSMark Fasheh 
3345328d5752SMark Fasheh rotate:
3346dcd0538fSMark Fasheh 	/*
3347dcd0538fSMark Fasheh 	 * Ok, we have to rotate.
3348dcd0538fSMark Fasheh 	 *
3349dcd0538fSMark Fasheh 	 * At this point, it is safe to assume that inserting into an
3350dcd0538fSMark Fasheh 	 * empty leaf and appending to a leaf have both been handled
3351dcd0538fSMark Fasheh 	 * above.
3352dcd0538fSMark Fasheh 	 *
3353dcd0538fSMark Fasheh 	 * This leaf needs to have space, either by the empty 1st
3354dcd0538fSMark Fasheh 	 * extent record, or by virtue of an l_next_rec < l_count.
3355dcd0538fSMark Fasheh 	 */
3356dcd0538fSMark Fasheh 	ocfs2_rotate_leaf(el, insert_rec);
3357dcd0538fSMark Fasheh }
3358dcd0538fSMark Fasheh 
3359dcd0538fSMark Fasheh static inline void ocfs2_update_dinode_clusters(struct inode *inode,
3360dcd0538fSMark Fasheh 						struct ocfs2_dinode *di,
3361dcd0538fSMark Fasheh 						u32 clusters)
3362dcd0538fSMark Fasheh {
3363dcd0538fSMark Fasheh 	le32_add_cpu(&di->i_clusters, clusters);
3364dcd0538fSMark Fasheh 	spin_lock(&OCFS2_I(inode)->ip_lock);
3365dcd0538fSMark Fasheh 	OCFS2_I(inode)->ip_clusters = le32_to_cpu(di->i_clusters);
3366dcd0538fSMark Fasheh 	spin_unlock(&OCFS2_I(inode)->ip_lock);
3367dcd0538fSMark Fasheh }
3368dcd0538fSMark Fasheh 
3369328d5752SMark Fasheh static void ocfs2_adjust_rightmost_records(struct inode *inode,
3370328d5752SMark Fasheh 					   handle_t *handle,
3371328d5752SMark Fasheh 					   struct ocfs2_path *path,
3372328d5752SMark Fasheh 					   struct ocfs2_extent_rec *insert_rec)
3373328d5752SMark Fasheh {
3374328d5752SMark Fasheh 	int ret, i, next_free;
3375328d5752SMark Fasheh 	struct buffer_head *bh;
3376328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
3377328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec;
3378328d5752SMark Fasheh 
3379328d5752SMark Fasheh 	/*
3380328d5752SMark Fasheh 	 * Update everything except the leaf block.
3381328d5752SMark Fasheh 	 */
3382328d5752SMark Fasheh 	for (i = 0; i < path->p_tree_depth; i++) {
3383328d5752SMark Fasheh 		bh = path->p_node[i].bh;
3384328d5752SMark Fasheh 		el = path->p_node[i].el;
3385328d5752SMark Fasheh 
3386328d5752SMark Fasheh 		next_free = le16_to_cpu(el->l_next_free_rec);
3387328d5752SMark Fasheh 		if (next_free == 0) {
3388328d5752SMark Fasheh 			ocfs2_error(inode->i_sb,
3389328d5752SMark Fasheh 				    "Dinode %llu has a bad extent list",
3390328d5752SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno);
3391328d5752SMark Fasheh 			ret = -EIO;
3392328d5752SMark Fasheh 			return;
3393328d5752SMark Fasheh 		}
3394328d5752SMark Fasheh 
3395328d5752SMark Fasheh 		rec = &el->l_recs[next_free - 1];
3396328d5752SMark Fasheh 
3397328d5752SMark Fasheh 		rec->e_int_clusters = insert_rec->e_cpos;
3398328d5752SMark Fasheh 		le32_add_cpu(&rec->e_int_clusters,
3399328d5752SMark Fasheh 			     le16_to_cpu(insert_rec->e_leaf_clusters));
3400328d5752SMark Fasheh 		le32_add_cpu(&rec->e_int_clusters,
3401328d5752SMark Fasheh 			     -le32_to_cpu(rec->e_cpos));
3402328d5752SMark Fasheh 
3403328d5752SMark Fasheh 		ret = ocfs2_journal_dirty(handle, bh);
3404328d5752SMark Fasheh 		if (ret)
3405328d5752SMark Fasheh 			mlog_errno(ret);
3406328d5752SMark Fasheh 
3407328d5752SMark Fasheh 	}
3408328d5752SMark Fasheh }
3409328d5752SMark Fasheh 
3410dcd0538fSMark Fasheh static int ocfs2_append_rec_to_path(struct inode *inode, handle_t *handle,
3411dcd0538fSMark Fasheh 				    struct ocfs2_extent_rec *insert_rec,
3412dcd0538fSMark Fasheh 				    struct ocfs2_path *right_path,
3413dcd0538fSMark Fasheh 				    struct ocfs2_path **ret_left_path)
3414dcd0538fSMark Fasheh {
3415328d5752SMark Fasheh 	int ret, next_free;
3416dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el;
3417dcd0538fSMark Fasheh 	struct ocfs2_path *left_path = NULL;
3418dcd0538fSMark Fasheh 
3419dcd0538fSMark Fasheh 	*ret_left_path = NULL;
3420dcd0538fSMark Fasheh 
3421dcd0538fSMark Fasheh 	/*
3422e48edee2SMark Fasheh 	 * This shouldn't happen for non-trees. The extent rec cluster
3423e48edee2SMark Fasheh 	 * count manipulation below only works for interior nodes.
3424e48edee2SMark Fasheh 	 */
3425e48edee2SMark Fasheh 	BUG_ON(right_path->p_tree_depth == 0);
3426e48edee2SMark Fasheh 
3427e48edee2SMark Fasheh 	/*
3428dcd0538fSMark Fasheh 	 * If our appending insert is at the leftmost edge of a leaf,
3429dcd0538fSMark Fasheh 	 * then we might need to update the rightmost records of the
3430dcd0538fSMark Fasheh 	 * neighboring path.
3431dcd0538fSMark Fasheh 	 */
3432dcd0538fSMark Fasheh 	el = path_leaf_el(right_path);
3433dcd0538fSMark Fasheh 	next_free = le16_to_cpu(el->l_next_free_rec);
3434dcd0538fSMark Fasheh 	if (next_free == 0 ||
3435dcd0538fSMark Fasheh 	    (next_free == 1 && ocfs2_is_empty_extent(&el->l_recs[0]))) {
3436dcd0538fSMark Fasheh 		u32 left_cpos;
3437dcd0538fSMark Fasheh 
3438dcd0538fSMark Fasheh 		ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, right_path,
3439dcd0538fSMark Fasheh 						    &left_cpos);
3440dcd0538fSMark Fasheh 		if (ret) {
3441dcd0538fSMark Fasheh 			mlog_errno(ret);
3442dcd0538fSMark Fasheh 			goto out;
3443dcd0538fSMark Fasheh 		}
3444dcd0538fSMark Fasheh 
3445dcd0538fSMark Fasheh 		mlog(0, "Append may need a left path update. cpos: %u, "
3446dcd0538fSMark Fasheh 		     "left_cpos: %u\n", le32_to_cpu(insert_rec->e_cpos),
3447dcd0538fSMark Fasheh 		     left_cpos);
3448dcd0538fSMark Fasheh 
3449dcd0538fSMark Fasheh 		/*
3450dcd0538fSMark Fasheh 		 * No need to worry if the append is already in the
3451dcd0538fSMark Fasheh 		 * leftmost leaf.
3452dcd0538fSMark Fasheh 		 */
3453dcd0538fSMark Fasheh 		if (left_cpos) {
3454dcd0538fSMark Fasheh 			left_path = ocfs2_new_path(path_root_bh(right_path),
3455dcd0538fSMark Fasheh 						   path_root_el(right_path));
3456dcd0538fSMark Fasheh 			if (!left_path) {
3457dcd0538fSMark Fasheh 				ret = -ENOMEM;
3458dcd0538fSMark Fasheh 				mlog_errno(ret);
3459dcd0538fSMark Fasheh 				goto out;
3460dcd0538fSMark Fasheh 			}
3461dcd0538fSMark Fasheh 
3462dcd0538fSMark Fasheh 			ret = ocfs2_find_path(inode, left_path, left_cpos);
3463dcd0538fSMark Fasheh 			if (ret) {
3464dcd0538fSMark Fasheh 				mlog_errno(ret);
3465dcd0538fSMark Fasheh 				goto out;
3466dcd0538fSMark Fasheh 			}
3467dcd0538fSMark Fasheh 
3468dcd0538fSMark Fasheh 			/*
3469dcd0538fSMark Fasheh 			 * ocfs2_insert_path() will pass the left_path to the
3470dcd0538fSMark Fasheh 			 * journal for us.
3471dcd0538fSMark Fasheh 			 */
3472dcd0538fSMark Fasheh 		}
3473dcd0538fSMark Fasheh 	}
3474dcd0538fSMark Fasheh 
3475dcd0538fSMark Fasheh 	ret = ocfs2_journal_access_path(inode, handle, right_path);
3476dcd0538fSMark Fasheh 	if (ret) {
3477dcd0538fSMark Fasheh 		mlog_errno(ret);
3478dcd0538fSMark Fasheh 		goto out;
3479dcd0538fSMark Fasheh 	}
3480dcd0538fSMark Fasheh 
3481328d5752SMark Fasheh 	ocfs2_adjust_rightmost_records(inode, handle, right_path, insert_rec);
3482dcd0538fSMark Fasheh 
3483dcd0538fSMark Fasheh 	*ret_left_path = left_path;
3484dcd0538fSMark Fasheh 	ret = 0;
3485dcd0538fSMark Fasheh out:
3486dcd0538fSMark Fasheh 	if (ret != 0)
3487dcd0538fSMark Fasheh 		ocfs2_free_path(left_path);
3488dcd0538fSMark Fasheh 
3489dcd0538fSMark Fasheh 	return ret;
3490dcd0538fSMark Fasheh }
3491dcd0538fSMark Fasheh 
3492328d5752SMark Fasheh static void ocfs2_split_record(struct inode *inode,
3493328d5752SMark Fasheh 			       struct ocfs2_path *left_path,
3494328d5752SMark Fasheh 			       struct ocfs2_path *right_path,
3495328d5752SMark Fasheh 			       struct ocfs2_extent_rec *split_rec,
3496328d5752SMark Fasheh 			       enum ocfs2_split_type split)
3497328d5752SMark Fasheh {
3498328d5752SMark Fasheh 	int index;
3499328d5752SMark Fasheh 	u32 cpos = le32_to_cpu(split_rec->e_cpos);
3500328d5752SMark Fasheh 	struct ocfs2_extent_list *left_el = NULL, *right_el, *insert_el, *el;
3501328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec, *tmprec;
3502328d5752SMark Fasheh 
3503328d5752SMark Fasheh 	right_el = path_leaf_el(right_path);;
3504328d5752SMark Fasheh 	if (left_path)
3505328d5752SMark Fasheh 		left_el = path_leaf_el(left_path);
3506328d5752SMark Fasheh 
3507328d5752SMark Fasheh 	el = right_el;
3508328d5752SMark Fasheh 	insert_el = right_el;
3509328d5752SMark Fasheh 	index = ocfs2_search_extent_list(el, cpos);
3510328d5752SMark Fasheh 	if (index != -1) {
3511328d5752SMark Fasheh 		if (index == 0 && left_path) {
3512328d5752SMark Fasheh 			BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
3513328d5752SMark Fasheh 
3514328d5752SMark Fasheh 			/*
3515328d5752SMark Fasheh 			 * This typically means that the record
3516328d5752SMark Fasheh 			 * started in the left path but moved to the
3517328d5752SMark Fasheh 			 * right as a result of rotation. We either
3518328d5752SMark Fasheh 			 * move the existing record to the left, or we
3519328d5752SMark Fasheh 			 * do the later insert there.
3520328d5752SMark Fasheh 			 *
3521328d5752SMark Fasheh 			 * In this case, the left path should always
3522328d5752SMark Fasheh 			 * exist as the rotate code will have passed
3523328d5752SMark Fasheh 			 * it back for a post-insert update.
3524328d5752SMark Fasheh 			 */
3525328d5752SMark Fasheh 
3526328d5752SMark Fasheh 			if (split == SPLIT_LEFT) {
3527328d5752SMark Fasheh 				/*
3528328d5752SMark Fasheh 				 * It's a left split. Since we know
3529328d5752SMark Fasheh 				 * that the rotate code gave us an
3530328d5752SMark Fasheh 				 * empty extent in the left path, we
3531328d5752SMark Fasheh 				 * can just do the insert there.
3532328d5752SMark Fasheh 				 */
3533328d5752SMark Fasheh 				insert_el = left_el;
3534328d5752SMark Fasheh 			} else {
3535328d5752SMark Fasheh 				/*
3536328d5752SMark Fasheh 				 * Right split - we have to move the
3537328d5752SMark Fasheh 				 * existing record over to the left
3538328d5752SMark Fasheh 				 * leaf. The insert will be into the
3539328d5752SMark Fasheh 				 * newly created empty extent in the
3540328d5752SMark Fasheh 				 * right leaf.
3541328d5752SMark Fasheh 				 */
3542328d5752SMark Fasheh 				tmprec = &right_el->l_recs[index];
3543328d5752SMark Fasheh 				ocfs2_rotate_leaf(left_el, tmprec);
3544328d5752SMark Fasheh 				el = left_el;
3545328d5752SMark Fasheh 
3546328d5752SMark Fasheh 				memset(tmprec, 0, sizeof(*tmprec));
3547328d5752SMark Fasheh 				index = ocfs2_search_extent_list(left_el, cpos);
3548328d5752SMark Fasheh 				BUG_ON(index == -1);
3549328d5752SMark Fasheh 			}
3550328d5752SMark Fasheh 		}
3551328d5752SMark Fasheh 	} else {
3552328d5752SMark Fasheh 		BUG_ON(!left_path);
3553328d5752SMark Fasheh 		BUG_ON(!ocfs2_is_empty_extent(&left_el->l_recs[0]));
3554328d5752SMark Fasheh 		/*
3555328d5752SMark Fasheh 		 * Left path is easy - we can just allow the insert to
3556328d5752SMark Fasheh 		 * happen.
3557328d5752SMark Fasheh 		 */
3558328d5752SMark Fasheh 		el = left_el;
3559328d5752SMark Fasheh 		insert_el = left_el;
3560328d5752SMark Fasheh 		index = ocfs2_search_extent_list(el, cpos);
3561328d5752SMark Fasheh 		BUG_ON(index == -1);
3562328d5752SMark Fasheh 	}
3563328d5752SMark Fasheh 
3564328d5752SMark Fasheh 	rec = &el->l_recs[index];
3565328d5752SMark Fasheh 	ocfs2_subtract_from_rec(inode->i_sb, split, rec, split_rec);
3566328d5752SMark Fasheh 	ocfs2_rotate_leaf(insert_el, split_rec);
3567328d5752SMark Fasheh }
3568328d5752SMark Fasheh 
3569dcd0538fSMark Fasheh /*
3570dcd0538fSMark Fasheh  * This function only does inserts on an allocation b-tree. For dinode
3571dcd0538fSMark Fasheh  * lists, ocfs2_insert_at_leaf() is called directly.
3572dcd0538fSMark Fasheh  *
3573dcd0538fSMark Fasheh  * right_path is the path we want to do the actual insert
3574dcd0538fSMark Fasheh  * in. left_path should only be passed in if we need to update that
3575dcd0538fSMark Fasheh  * portion of the tree after an edge insert.
3576dcd0538fSMark Fasheh  */
3577dcd0538fSMark Fasheh static int ocfs2_insert_path(struct inode *inode,
3578dcd0538fSMark Fasheh 			     handle_t *handle,
3579dcd0538fSMark Fasheh 			     struct ocfs2_path *left_path,
3580dcd0538fSMark Fasheh 			     struct ocfs2_path *right_path,
3581dcd0538fSMark Fasheh 			     struct ocfs2_extent_rec *insert_rec,
3582dcd0538fSMark Fasheh 			     struct ocfs2_insert_type *insert)
3583dcd0538fSMark Fasheh {
3584dcd0538fSMark Fasheh 	int ret, subtree_index;
3585dcd0538fSMark Fasheh 	struct buffer_head *leaf_bh = path_leaf_bh(right_path);
3586dcd0538fSMark Fasheh 
3587dcd0538fSMark Fasheh 	if (left_path) {
3588dcd0538fSMark Fasheh 		int credits = handle->h_buffer_credits;
3589dcd0538fSMark Fasheh 
3590dcd0538fSMark Fasheh 		/*
3591dcd0538fSMark Fasheh 		 * There's a chance that left_path got passed back to
3592dcd0538fSMark Fasheh 		 * us without being accounted for in the
3593dcd0538fSMark Fasheh 		 * journal. Extend our transaction here to be sure we
3594dcd0538fSMark Fasheh 		 * can change those blocks.
3595dcd0538fSMark Fasheh 		 */
3596dcd0538fSMark Fasheh 		credits += left_path->p_tree_depth;
3597dcd0538fSMark Fasheh 
3598dcd0538fSMark Fasheh 		ret = ocfs2_extend_trans(handle, credits);
3599dcd0538fSMark Fasheh 		if (ret < 0) {
3600dcd0538fSMark Fasheh 			mlog_errno(ret);
3601dcd0538fSMark Fasheh 			goto out;
3602dcd0538fSMark Fasheh 		}
3603dcd0538fSMark Fasheh 
3604dcd0538fSMark Fasheh 		ret = ocfs2_journal_access_path(inode, handle, left_path);
3605dcd0538fSMark Fasheh 		if (ret < 0) {
3606dcd0538fSMark Fasheh 			mlog_errno(ret);
3607dcd0538fSMark Fasheh 			goto out;
3608dcd0538fSMark Fasheh 		}
3609dcd0538fSMark Fasheh 	}
3610dcd0538fSMark Fasheh 
3611e8aed345SMark Fasheh 	/*
3612e8aed345SMark Fasheh 	 * Pass both paths to the journal. The majority of inserts
3613e8aed345SMark Fasheh 	 * will be touching all components anyway.
3614e8aed345SMark Fasheh 	 */
3615e8aed345SMark Fasheh 	ret = ocfs2_journal_access_path(inode, handle, right_path);
3616e8aed345SMark Fasheh 	if (ret < 0) {
3617e8aed345SMark Fasheh 		mlog_errno(ret);
3618e8aed345SMark Fasheh 		goto out;
3619e8aed345SMark Fasheh 	}
3620e8aed345SMark Fasheh 
3621328d5752SMark Fasheh 	if (insert->ins_split != SPLIT_NONE) {
3622328d5752SMark Fasheh 		/*
3623328d5752SMark Fasheh 		 * We could call ocfs2_insert_at_leaf() for some types
3624c78bad11SJoe Perches 		 * of splits, but it's easier to just let one separate
3625328d5752SMark Fasheh 		 * function sort it all out.
3626328d5752SMark Fasheh 		 */
3627328d5752SMark Fasheh 		ocfs2_split_record(inode, left_path, right_path,
3628328d5752SMark Fasheh 				   insert_rec, insert->ins_split);
3629e8aed345SMark Fasheh 
3630e8aed345SMark Fasheh 		/*
3631e8aed345SMark Fasheh 		 * Split might have modified either leaf and we don't
3632e8aed345SMark Fasheh 		 * have a guarantee that the later edge insert will
3633e8aed345SMark Fasheh 		 * dirty this for us.
3634e8aed345SMark Fasheh 		 */
3635e8aed345SMark Fasheh 		if (left_path)
3636e8aed345SMark Fasheh 			ret = ocfs2_journal_dirty(handle,
3637e8aed345SMark Fasheh 						  path_leaf_bh(left_path));
3638e8aed345SMark Fasheh 			if (ret)
3639e8aed345SMark Fasheh 				mlog_errno(ret);
3640328d5752SMark Fasheh 	} else
3641328d5752SMark Fasheh 		ocfs2_insert_at_leaf(insert_rec, path_leaf_el(right_path),
3642328d5752SMark Fasheh 				     insert, inode);
3643dcd0538fSMark Fasheh 
3644dcd0538fSMark Fasheh 	ret = ocfs2_journal_dirty(handle, leaf_bh);
3645dcd0538fSMark Fasheh 	if (ret)
3646dcd0538fSMark Fasheh 		mlog_errno(ret);
3647dcd0538fSMark Fasheh 
3648dcd0538fSMark Fasheh 	if (left_path) {
3649dcd0538fSMark Fasheh 		/*
3650dcd0538fSMark Fasheh 		 * The rotate code has indicated that we need to fix
3651dcd0538fSMark Fasheh 		 * up portions of the tree after the insert.
3652dcd0538fSMark Fasheh 		 *
3653dcd0538fSMark Fasheh 		 * XXX: Should we extend the transaction here?
3654dcd0538fSMark Fasheh 		 */
3655dcd0538fSMark Fasheh 		subtree_index = ocfs2_find_subtree_root(inode, left_path,
3656dcd0538fSMark Fasheh 							right_path);
3657dcd0538fSMark Fasheh 		ocfs2_complete_edge_insert(inode, handle, left_path,
3658dcd0538fSMark Fasheh 					   right_path, subtree_index);
3659dcd0538fSMark Fasheh 	}
3660dcd0538fSMark Fasheh 
3661dcd0538fSMark Fasheh 	ret = 0;
3662dcd0538fSMark Fasheh out:
3663dcd0538fSMark Fasheh 	return ret;
3664dcd0538fSMark Fasheh }
3665dcd0538fSMark Fasheh 
3666dcd0538fSMark Fasheh static int ocfs2_do_insert_extent(struct inode *inode,
3667dcd0538fSMark Fasheh 				  handle_t *handle,
3668dcd0538fSMark Fasheh 				  struct buffer_head *di_bh,
3669dcd0538fSMark Fasheh 				  struct ocfs2_extent_rec *insert_rec,
3670dcd0538fSMark Fasheh 				  struct ocfs2_insert_type *type)
3671dcd0538fSMark Fasheh {
3672dcd0538fSMark Fasheh 	int ret, rotate = 0;
3673dcd0538fSMark Fasheh 	u32 cpos;
3674dcd0538fSMark Fasheh 	struct ocfs2_path *right_path = NULL;
3675dcd0538fSMark Fasheh 	struct ocfs2_path *left_path = NULL;
3676dcd0538fSMark Fasheh 	struct ocfs2_dinode *di;
3677dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el;
3678dcd0538fSMark Fasheh 
3679dcd0538fSMark Fasheh 	di = (struct ocfs2_dinode *) di_bh->b_data;
3680dcd0538fSMark Fasheh 	el = &di->id2.i_list;
3681dcd0538fSMark Fasheh 
3682dcd0538fSMark Fasheh 	ret = ocfs2_journal_access(handle, inode, di_bh,
3683dcd0538fSMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
3684dcd0538fSMark Fasheh 	if (ret) {
3685dcd0538fSMark Fasheh 		mlog_errno(ret);
3686dcd0538fSMark Fasheh 		goto out;
3687dcd0538fSMark Fasheh 	}
3688dcd0538fSMark Fasheh 
3689dcd0538fSMark Fasheh 	if (le16_to_cpu(el->l_tree_depth) == 0) {
3690dcd0538fSMark Fasheh 		ocfs2_insert_at_leaf(insert_rec, el, type, inode);
3691dcd0538fSMark Fasheh 		goto out_update_clusters;
3692dcd0538fSMark Fasheh 	}
3693dcd0538fSMark Fasheh 
3694dcd0538fSMark Fasheh 	right_path = ocfs2_new_inode_path(di_bh);
3695dcd0538fSMark Fasheh 	if (!right_path) {
3696dcd0538fSMark Fasheh 		ret = -ENOMEM;
3697dcd0538fSMark Fasheh 		mlog_errno(ret);
3698dcd0538fSMark Fasheh 		goto out;
3699dcd0538fSMark Fasheh 	}
3700dcd0538fSMark Fasheh 
3701dcd0538fSMark Fasheh 	/*
3702dcd0538fSMark Fasheh 	 * Determine the path to start with. Rotations need the
3703dcd0538fSMark Fasheh 	 * rightmost path, everything else can go directly to the
3704dcd0538fSMark Fasheh 	 * target leaf.
3705dcd0538fSMark Fasheh 	 */
3706dcd0538fSMark Fasheh 	cpos = le32_to_cpu(insert_rec->e_cpos);
3707dcd0538fSMark Fasheh 	if (type->ins_appending == APPEND_NONE &&
3708dcd0538fSMark Fasheh 	    type->ins_contig == CONTIG_NONE) {
3709dcd0538fSMark Fasheh 		rotate = 1;
3710dcd0538fSMark Fasheh 		cpos = UINT_MAX;
3711dcd0538fSMark Fasheh 	}
3712dcd0538fSMark Fasheh 
3713dcd0538fSMark Fasheh 	ret = ocfs2_find_path(inode, right_path, cpos);
3714dcd0538fSMark Fasheh 	if (ret) {
3715dcd0538fSMark Fasheh 		mlog_errno(ret);
3716dcd0538fSMark Fasheh 		goto out;
3717dcd0538fSMark Fasheh 	}
3718dcd0538fSMark Fasheh 
3719dcd0538fSMark Fasheh 	/*
3720dcd0538fSMark Fasheh 	 * Rotations and appends need special treatment - they modify
3721dcd0538fSMark Fasheh 	 * parts of the tree's above them.
3722dcd0538fSMark Fasheh 	 *
3723dcd0538fSMark Fasheh 	 * Both might pass back a path immediate to the left of the
3724dcd0538fSMark Fasheh 	 * one being inserted to. This will be cause
3725dcd0538fSMark Fasheh 	 * ocfs2_insert_path() to modify the rightmost records of
3726dcd0538fSMark Fasheh 	 * left_path to account for an edge insert.
3727dcd0538fSMark Fasheh 	 *
3728dcd0538fSMark Fasheh 	 * XXX: When modifying this code, keep in mind that an insert
3729dcd0538fSMark Fasheh 	 * can wind up skipping both of these two special cases...
3730dcd0538fSMark Fasheh 	 */
3731dcd0538fSMark Fasheh 	if (rotate) {
3732328d5752SMark Fasheh 		ret = ocfs2_rotate_tree_right(inode, handle, type->ins_split,
3733dcd0538fSMark Fasheh 					      le32_to_cpu(insert_rec->e_cpos),
3734dcd0538fSMark Fasheh 					      right_path, &left_path);
3735dcd0538fSMark Fasheh 		if (ret) {
3736dcd0538fSMark Fasheh 			mlog_errno(ret);
3737dcd0538fSMark Fasheh 			goto out;
3738dcd0538fSMark Fasheh 		}
3739e8aed345SMark Fasheh 
3740e8aed345SMark Fasheh 		/*
3741e8aed345SMark Fasheh 		 * ocfs2_rotate_tree_right() might have extended the
3742e8aed345SMark Fasheh 		 * transaction without re-journaling our tree root.
3743e8aed345SMark Fasheh 		 */
3744e8aed345SMark Fasheh 		ret = ocfs2_journal_access(handle, inode, di_bh,
3745e8aed345SMark Fasheh 					   OCFS2_JOURNAL_ACCESS_WRITE);
3746e8aed345SMark Fasheh 		if (ret) {
3747e8aed345SMark Fasheh 			mlog_errno(ret);
3748e8aed345SMark Fasheh 			goto out;
3749e8aed345SMark Fasheh 		}
3750dcd0538fSMark Fasheh 	} else if (type->ins_appending == APPEND_TAIL
3751dcd0538fSMark Fasheh 		   && type->ins_contig != CONTIG_LEFT) {
3752dcd0538fSMark Fasheh 		ret = ocfs2_append_rec_to_path(inode, handle, insert_rec,
3753dcd0538fSMark Fasheh 					       right_path, &left_path);
3754dcd0538fSMark Fasheh 		if (ret) {
3755dcd0538fSMark Fasheh 			mlog_errno(ret);
3756dcd0538fSMark Fasheh 			goto out;
3757dcd0538fSMark Fasheh 		}
3758dcd0538fSMark Fasheh 	}
3759dcd0538fSMark Fasheh 
3760dcd0538fSMark Fasheh 	ret = ocfs2_insert_path(inode, handle, left_path, right_path,
3761dcd0538fSMark Fasheh 				insert_rec, type);
3762dcd0538fSMark Fasheh 	if (ret) {
3763dcd0538fSMark Fasheh 		mlog_errno(ret);
3764dcd0538fSMark Fasheh 		goto out;
3765dcd0538fSMark Fasheh 	}
3766dcd0538fSMark Fasheh 
3767dcd0538fSMark Fasheh out_update_clusters:
3768328d5752SMark Fasheh 	if (type->ins_split == SPLIT_NONE)
3769dcd0538fSMark Fasheh 		ocfs2_update_dinode_clusters(inode, di,
3770e48edee2SMark Fasheh 					     le16_to_cpu(insert_rec->e_leaf_clusters));
3771dcd0538fSMark Fasheh 
3772dcd0538fSMark Fasheh 	ret = ocfs2_journal_dirty(handle, di_bh);
3773dcd0538fSMark Fasheh 	if (ret)
3774dcd0538fSMark Fasheh 		mlog_errno(ret);
3775dcd0538fSMark Fasheh 
3776dcd0538fSMark Fasheh out:
3777dcd0538fSMark Fasheh 	ocfs2_free_path(left_path);
3778dcd0538fSMark Fasheh 	ocfs2_free_path(right_path);
3779dcd0538fSMark Fasheh 
3780dcd0538fSMark Fasheh 	return ret;
3781dcd0538fSMark Fasheh }
3782dcd0538fSMark Fasheh 
3783328d5752SMark Fasheh static enum ocfs2_contig_type
3784ad5a4d70STao Ma ocfs2_figure_merge_contig_type(struct inode *inode, struct ocfs2_path *path,
3785328d5752SMark Fasheh 			       struct ocfs2_extent_list *el, int index,
3786328d5752SMark Fasheh 			       struct ocfs2_extent_rec *split_rec)
3787328d5752SMark Fasheh {
3788ad5a4d70STao Ma 	int status;
3789328d5752SMark Fasheh 	enum ocfs2_contig_type ret = CONTIG_NONE;
3790ad5a4d70STao Ma 	u32 left_cpos, right_cpos;
3791ad5a4d70STao Ma 	struct ocfs2_extent_rec *rec = NULL;
3792ad5a4d70STao Ma 	struct ocfs2_extent_list *new_el;
3793ad5a4d70STao Ma 	struct ocfs2_path *left_path = NULL, *right_path = NULL;
3794ad5a4d70STao Ma 	struct buffer_head *bh;
3795ad5a4d70STao Ma 	struct ocfs2_extent_block *eb;
3796ad5a4d70STao Ma 
3797ad5a4d70STao Ma 	if (index > 0) {
3798ad5a4d70STao Ma 		rec = &el->l_recs[index - 1];
3799ad5a4d70STao Ma 	} else if (path->p_tree_depth > 0) {
3800ad5a4d70STao Ma 		status = ocfs2_find_cpos_for_left_leaf(inode->i_sb,
3801ad5a4d70STao Ma 						       path, &left_cpos);
3802ad5a4d70STao Ma 		if (status)
3803ad5a4d70STao Ma 			goto out;
3804ad5a4d70STao Ma 
3805ad5a4d70STao Ma 		if (left_cpos != 0) {
3806ad5a4d70STao Ma 			left_path = ocfs2_new_path(path_root_bh(path),
3807ad5a4d70STao Ma 						   path_root_el(path));
3808ad5a4d70STao Ma 			if (!left_path)
3809ad5a4d70STao Ma 				goto out;
3810ad5a4d70STao Ma 
3811ad5a4d70STao Ma 			status = ocfs2_find_path(inode, left_path, left_cpos);
3812ad5a4d70STao Ma 			if (status)
3813ad5a4d70STao Ma 				goto out;
3814ad5a4d70STao Ma 
3815ad5a4d70STao Ma 			new_el = path_leaf_el(left_path);
3816ad5a4d70STao Ma 
3817ad5a4d70STao Ma 			if (le16_to_cpu(new_el->l_next_free_rec) !=
3818ad5a4d70STao Ma 			    le16_to_cpu(new_el->l_count)) {
3819ad5a4d70STao Ma 				bh = path_leaf_bh(left_path);
3820ad5a4d70STao Ma 				eb = (struct ocfs2_extent_block *)bh->b_data;
3821ad5a4d70STao Ma 				OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb,
3822ad5a4d70STao Ma 								 eb);
3823ad5a4d70STao Ma 				goto out;
3824ad5a4d70STao Ma 			}
3825ad5a4d70STao Ma 			rec = &new_el->l_recs[
3826ad5a4d70STao Ma 				le16_to_cpu(new_el->l_next_free_rec) - 1];
3827ad5a4d70STao Ma 		}
3828ad5a4d70STao Ma 	}
3829328d5752SMark Fasheh 
3830328d5752SMark Fasheh 	/*
3831328d5752SMark Fasheh 	 * We're careful to check for an empty extent record here -
3832328d5752SMark Fasheh 	 * the merge code will know what to do if it sees one.
3833328d5752SMark Fasheh 	 */
3834ad5a4d70STao Ma 	if (rec) {
3835328d5752SMark Fasheh 		if (index == 1 && ocfs2_is_empty_extent(rec)) {
3836328d5752SMark Fasheh 			if (split_rec->e_cpos == el->l_recs[index].e_cpos)
3837328d5752SMark Fasheh 				ret = CONTIG_RIGHT;
3838328d5752SMark Fasheh 		} else {
3839328d5752SMark Fasheh 			ret = ocfs2_extent_contig(inode, rec, split_rec);
3840328d5752SMark Fasheh 		}
3841328d5752SMark Fasheh 	}
3842328d5752SMark Fasheh 
3843ad5a4d70STao Ma 	rec = NULL;
3844ad5a4d70STao Ma 	if (index < (le16_to_cpu(el->l_next_free_rec) - 1))
3845ad5a4d70STao Ma 		rec = &el->l_recs[index + 1];
3846ad5a4d70STao Ma 	else if (le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count) &&
3847ad5a4d70STao Ma 		 path->p_tree_depth > 0) {
3848ad5a4d70STao Ma 		status = ocfs2_find_cpos_for_right_leaf(inode->i_sb,
3849ad5a4d70STao Ma 							path, &right_cpos);
3850ad5a4d70STao Ma 		if (status)
3851ad5a4d70STao Ma 			goto out;
3852ad5a4d70STao Ma 
3853ad5a4d70STao Ma 		if (right_cpos == 0)
3854ad5a4d70STao Ma 			goto out;
3855ad5a4d70STao Ma 
3856ad5a4d70STao Ma 		right_path = ocfs2_new_path(path_root_bh(path),
3857ad5a4d70STao Ma 					    path_root_el(path));
3858ad5a4d70STao Ma 		if (!right_path)
3859ad5a4d70STao Ma 			goto out;
3860ad5a4d70STao Ma 
3861ad5a4d70STao Ma 		status = ocfs2_find_path(inode, right_path, right_cpos);
3862ad5a4d70STao Ma 		if (status)
3863ad5a4d70STao Ma 			goto out;
3864ad5a4d70STao Ma 
3865ad5a4d70STao Ma 		new_el = path_leaf_el(right_path);
3866ad5a4d70STao Ma 		rec = &new_el->l_recs[0];
3867ad5a4d70STao Ma 		if (ocfs2_is_empty_extent(rec)) {
3868ad5a4d70STao Ma 			if (le16_to_cpu(new_el->l_next_free_rec) <= 1) {
3869ad5a4d70STao Ma 				bh = path_leaf_bh(right_path);
3870ad5a4d70STao Ma 				eb = (struct ocfs2_extent_block *)bh->b_data;
3871ad5a4d70STao Ma 				OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb,
3872ad5a4d70STao Ma 								 eb);
3873ad5a4d70STao Ma 				goto out;
3874ad5a4d70STao Ma 			}
3875ad5a4d70STao Ma 			rec = &new_el->l_recs[1];
3876ad5a4d70STao Ma 		}
3877ad5a4d70STao Ma 	}
3878ad5a4d70STao Ma 
3879ad5a4d70STao Ma 	if (rec) {
3880328d5752SMark Fasheh 		enum ocfs2_contig_type contig_type;
3881328d5752SMark Fasheh 
3882328d5752SMark Fasheh 		contig_type = ocfs2_extent_contig(inode, rec, split_rec);
3883328d5752SMark Fasheh 
3884328d5752SMark Fasheh 		if (contig_type == CONTIG_LEFT && ret == CONTIG_RIGHT)
3885328d5752SMark Fasheh 			ret = CONTIG_LEFTRIGHT;
3886328d5752SMark Fasheh 		else if (ret == CONTIG_NONE)
3887328d5752SMark Fasheh 			ret = contig_type;
3888328d5752SMark Fasheh 	}
3889328d5752SMark Fasheh 
3890ad5a4d70STao Ma out:
3891ad5a4d70STao Ma 	if (left_path)
3892ad5a4d70STao Ma 		ocfs2_free_path(left_path);
3893ad5a4d70STao Ma 	if (right_path)
3894ad5a4d70STao Ma 		ocfs2_free_path(right_path);
3895ad5a4d70STao Ma 
3896328d5752SMark Fasheh 	return ret;
3897328d5752SMark Fasheh }
3898328d5752SMark Fasheh 
3899dcd0538fSMark Fasheh static void ocfs2_figure_contig_type(struct inode *inode,
3900dcd0538fSMark Fasheh 				     struct ocfs2_insert_type *insert,
3901dcd0538fSMark Fasheh 				     struct ocfs2_extent_list *el,
3902dcd0538fSMark Fasheh 				     struct ocfs2_extent_rec *insert_rec)
3903dcd0538fSMark Fasheh {
3904dcd0538fSMark Fasheh 	int i;
3905dcd0538fSMark Fasheh 	enum ocfs2_contig_type contig_type = CONTIG_NONE;
3906dcd0538fSMark Fasheh 
3907e48edee2SMark Fasheh 	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
3908e48edee2SMark Fasheh 
3909dcd0538fSMark Fasheh 	for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
3910dcd0538fSMark Fasheh 		contig_type = ocfs2_extent_contig(inode, &el->l_recs[i],
3911dcd0538fSMark Fasheh 						  insert_rec);
3912dcd0538fSMark Fasheh 		if (contig_type != CONTIG_NONE) {
3913dcd0538fSMark Fasheh 			insert->ins_contig_index = i;
3914dcd0538fSMark Fasheh 			break;
3915dcd0538fSMark Fasheh 		}
3916dcd0538fSMark Fasheh 	}
3917dcd0538fSMark Fasheh 	insert->ins_contig = contig_type;
3918dcd0538fSMark Fasheh }
3919dcd0538fSMark Fasheh 
3920dcd0538fSMark Fasheh /*
3921dcd0538fSMark Fasheh  * This should only be called against the righmost leaf extent list.
3922dcd0538fSMark Fasheh  *
3923dcd0538fSMark Fasheh  * ocfs2_figure_appending_type() will figure out whether we'll have to
3924dcd0538fSMark Fasheh  * insert at the tail of the rightmost leaf.
3925dcd0538fSMark Fasheh  *
3926dcd0538fSMark Fasheh  * This should also work against the dinode list for tree's with 0
3927dcd0538fSMark Fasheh  * depth. If we consider the dinode list to be the rightmost leaf node
3928dcd0538fSMark Fasheh  * then the logic here makes sense.
3929dcd0538fSMark Fasheh  */
3930dcd0538fSMark Fasheh static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert,
3931dcd0538fSMark Fasheh 					struct ocfs2_extent_list *el,
3932dcd0538fSMark Fasheh 					struct ocfs2_extent_rec *insert_rec)
3933dcd0538fSMark Fasheh {
3934dcd0538fSMark Fasheh 	int i;
3935dcd0538fSMark Fasheh 	u32 cpos = le32_to_cpu(insert_rec->e_cpos);
3936dcd0538fSMark Fasheh 	struct ocfs2_extent_rec *rec;
3937dcd0538fSMark Fasheh 
3938dcd0538fSMark Fasheh 	insert->ins_appending = APPEND_NONE;
3939dcd0538fSMark Fasheh 
3940e48edee2SMark Fasheh 	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
3941dcd0538fSMark Fasheh 
3942dcd0538fSMark Fasheh 	if (!el->l_next_free_rec)
3943dcd0538fSMark Fasheh 		goto set_tail_append;
3944dcd0538fSMark Fasheh 
3945dcd0538fSMark Fasheh 	if (ocfs2_is_empty_extent(&el->l_recs[0])) {
3946dcd0538fSMark Fasheh 		/* Were all records empty? */
3947dcd0538fSMark Fasheh 		if (le16_to_cpu(el->l_next_free_rec) == 1)
3948dcd0538fSMark Fasheh 			goto set_tail_append;
3949dcd0538fSMark Fasheh 	}
3950dcd0538fSMark Fasheh 
3951dcd0538fSMark Fasheh 	i = le16_to_cpu(el->l_next_free_rec) - 1;
3952dcd0538fSMark Fasheh 	rec = &el->l_recs[i];
3953dcd0538fSMark Fasheh 
3954e48edee2SMark Fasheh 	if (cpos >=
3955e48edee2SMark Fasheh 	    (le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)))
3956dcd0538fSMark Fasheh 		goto set_tail_append;
3957dcd0538fSMark Fasheh 
3958dcd0538fSMark Fasheh 	return;
3959dcd0538fSMark Fasheh 
3960dcd0538fSMark Fasheh set_tail_append:
3961dcd0538fSMark Fasheh 	insert->ins_appending = APPEND_TAIL;
3962dcd0538fSMark Fasheh }
3963dcd0538fSMark Fasheh 
3964dcd0538fSMark Fasheh /*
3965dcd0538fSMark Fasheh  * Helper function called at the begining of an insert.
3966dcd0538fSMark Fasheh  *
3967dcd0538fSMark Fasheh  * This computes a few things that are commonly used in the process of
3968dcd0538fSMark Fasheh  * inserting into the btree:
3969dcd0538fSMark Fasheh  *   - Whether the new extent is contiguous with an existing one.
3970dcd0538fSMark Fasheh  *   - The current tree depth.
3971dcd0538fSMark Fasheh  *   - Whether the insert is an appending one.
3972dcd0538fSMark Fasheh  *   - The total # of free records in the tree.
3973dcd0538fSMark Fasheh  *
3974dcd0538fSMark Fasheh  * All of the information is stored on the ocfs2_insert_type
3975dcd0538fSMark Fasheh  * structure.
3976dcd0538fSMark Fasheh  */
3977dcd0538fSMark Fasheh static int ocfs2_figure_insert_type(struct inode *inode,
3978dcd0538fSMark Fasheh 				    struct buffer_head *di_bh,
3979dcd0538fSMark Fasheh 				    struct buffer_head **last_eb_bh,
3980dcd0538fSMark Fasheh 				    struct ocfs2_extent_rec *insert_rec,
3981c77534f6STao Mao 				    int *free_records,
3982dcd0538fSMark Fasheh 				    struct ocfs2_insert_type *insert)
3983dcd0538fSMark Fasheh {
3984dcd0538fSMark Fasheh 	int ret;
3985dcd0538fSMark Fasheh 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
3986dcd0538fSMark Fasheh 	struct ocfs2_extent_block *eb;
3987dcd0538fSMark Fasheh 	struct ocfs2_extent_list *el;
3988dcd0538fSMark Fasheh 	struct ocfs2_path *path = NULL;
3989dcd0538fSMark Fasheh 	struct buffer_head *bh = NULL;
3990dcd0538fSMark Fasheh 
3991328d5752SMark Fasheh 	insert->ins_split = SPLIT_NONE;
3992328d5752SMark Fasheh 
3993dcd0538fSMark Fasheh 	el = &di->id2.i_list;
3994dcd0538fSMark Fasheh 	insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth);
3995dcd0538fSMark Fasheh 
3996dcd0538fSMark Fasheh 	if (el->l_tree_depth) {
3997dcd0538fSMark Fasheh 		/*
3998dcd0538fSMark Fasheh 		 * If we have tree depth, we read in the
3999dcd0538fSMark Fasheh 		 * rightmost extent block ahead of time as
4000dcd0538fSMark Fasheh 		 * ocfs2_figure_insert_type() and ocfs2_add_branch()
4001dcd0538fSMark Fasheh 		 * may want it later.
4002dcd0538fSMark Fasheh 		 */
4003dcd0538fSMark Fasheh 		ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
4004dcd0538fSMark Fasheh 				       le64_to_cpu(di->i_last_eb_blk), &bh,
4005dcd0538fSMark Fasheh 				       OCFS2_BH_CACHED, inode);
4006dcd0538fSMark Fasheh 		if (ret) {
4007dcd0538fSMark Fasheh 			mlog_exit(ret);
4008dcd0538fSMark Fasheh 			goto out;
4009dcd0538fSMark Fasheh 		}
4010dcd0538fSMark Fasheh 		eb = (struct ocfs2_extent_block *) bh->b_data;
4011dcd0538fSMark Fasheh 		el = &eb->h_list;
4012dcd0538fSMark Fasheh 	}
4013dcd0538fSMark Fasheh 
4014dcd0538fSMark Fasheh 	/*
4015dcd0538fSMark Fasheh 	 * Unless we have a contiguous insert, we'll need to know if
4016dcd0538fSMark Fasheh 	 * there is room left in our allocation tree for another
4017dcd0538fSMark Fasheh 	 * extent record.
4018dcd0538fSMark Fasheh 	 *
4019dcd0538fSMark Fasheh 	 * XXX: This test is simplistic, we can search for empty
4020dcd0538fSMark Fasheh 	 * extent records too.
4021dcd0538fSMark Fasheh 	 */
4022c77534f6STao Mao 	*free_records = le16_to_cpu(el->l_count) -
4023dcd0538fSMark Fasheh 		le16_to_cpu(el->l_next_free_rec);
4024dcd0538fSMark Fasheh 
4025dcd0538fSMark Fasheh 	if (!insert->ins_tree_depth) {
4026dcd0538fSMark Fasheh 		ocfs2_figure_contig_type(inode, insert, el, insert_rec);
4027dcd0538fSMark Fasheh 		ocfs2_figure_appending_type(insert, el, insert_rec);
4028dcd0538fSMark Fasheh 		return 0;
4029dcd0538fSMark Fasheh 	}
4030dcd0538fSMark Fasheh 
4031dcd0538fSMark Fasheh 	path = ocfs2_new_inode_path(di_bh);
4032dcd0538fSMark Fasheh 	if (!path) {
4033dcd0538fSMark Fasheh 		ret = -ENOMEM;
4034dcd0538fSMark Fasheh 		mlog_errno(ret);
4035dcd0538fSMark Fasheh 		goto out;
4036dcd0538fSMark Fasheh 	}
4037dcd0538fSMark Fasheh 
4038dcd0538fSMark Fasheh 	/*
4039dcd0538fSMark Fasheh 	 * In the case that we're inserting past what the tree
4040dcd0538fSMark Fasheh 	 * currently accounts for, ocfs2_find_path() will return for
4041dcd0538fSMark Fasheh 	 * us the rightmost tree path. This is accounted for below in
4042dcd0538fSMark Fasheh 	 * the appending code.
4043dcd0538fSMark Fasheh 	 */
4044dcd0538fSMark Fasheh 	ret = ocfs2_find_path(inode, path, le32_to_cpu(insert_rec->e_cpos));
4045dcd0538fSMark Fasheh 	if (ret) {
4046dcd0538fSMark Fasheh 		mlog_errno(ret);
4047dcd0538fSMark Fasheh 		goto out;
4048dcd0538fSMark Fasheh 	}
4049dcd0538fSMark Fasheh 
4050dcd0538fSMark Fasheh 	el = path_leaf_el(path);
4051dcd0538fSMark Fasheh 
4052dcd0538fSMark Fasheh 	/*
4053dcd0538fSMark Fasheh 	 * Now that we have the path, there's two things we want to determine:
4054dcd0538fSMark Fasheh 	 * 1) Contiguousness (also set contig_index if this is so)
4055dcd0538fSMark Fasheh 	 *
4056dcd0538fSMark Fasheh 	 * 2) Are we doing an append? We can trivially break this up
4057dcd0538fSMark Fasheh          *     into two types of appends: simple record append, or a
4058dcd0538fSMark Fasheh          *     rotate inside the tail leaf.
4059dcd0538fSMark Fasheh 	 */
4060dcd0538fSMark Fasheh 	ocfs2_figure_contig_type(inode, insert, el, insert_rec);
4061dcd0538fSMark Fasheh 
4062dcd0538fSMark Fasheh 	/*
4063dcd0538fSMark Fasheh 	 * The insert code isn't quite ready to deal with all cases of
4064dcd0538fSMark Fasheh 	 * left contiguousness. Specifically, if it's an insert into
4065dcd0538fSMark Fasheh 	 * the 1st record in a leaf, it will require the adjustment of
4066e48edee2SMark Fasheh 	 * cluster count on the last record of the path directly to it's
4067dcd0538fSMark Fasheh 	 * left. For now, just catch that case and fool the layers
4068dcd0538fSMark Fasheh 	 * above us. This works just fine for tree_depth == 0, which
4069dcd0538fSMark Fasheh 	 * is why we allow that above.
4070dcd0538fSMark Fasheh 	 */
4071dcd0538fSMark Fasheh 	if (insert->ins_contig == CONTIG_LEFT &&
4072dcd0538fSMark Fasheh 	    insert->ins_contig_index == 0)
4073dcd0538fSMark Fasheh 		insert->ins_contig = CONTIG_NONE;
4074dcd0538fSMark Fasheh 
4075dcd0538fSMark Fasheh 	/*
4076dcd0538fSMark Fasheh 	 * Ok, so we can simply compare against last_eb to figure out
4077dcd0538fSMark Fasheh 	 * whether the path doesn't exist. This will only happen in
4078dcd0538fSMark Fasheh 	 * the case that we're doing a tail append, so maybe we can
4079dcd0538fSMark Fasheh 	 * take advantage of that information somehow.
4080dcd0538fSMark Fasheh 	 */
4081dcd0538fSMark Fasheh 	if (le64_to_cpu(di->i_last_eb_blk) == path_leaf_bh(path)->b_blocknr) {
4082dcd0538fSMark Fasheh 		/*
4083dcd0538fSMark Fasheh 		 * Ok, ocfs2_find_path() returned us the rightmost
4084dcd0538fSMark Fasheh 		 * tree path. This might be an appending insert. There are
4085dcd0538fSMark Fasheh 		 * two cases:
4086dcd0538fSMark Fasheh 		 *    1) We're doing a true append at the tail:
4087dcd0538fSMark Fasheh 		 *	-This might even be off the end of the leaf
4088dcd0538fSMark Fasheh 		 *    2) We're "appending" by rotating in the tail
4089dcd0538fSMark Fasheh 		 */
4090dcd0538fSMark Fasheh 		ocfs2_figure_appending_type(insert, el, insert_rec);
4091dcd0538fSMark Fasheh 	}
4092dcd0538fSMark Fasheh 
4093dcd0538fSMark Fasheh out:
4094dcd0538fSMark Fasheh 	ocfs2_free_path(path);
4095dcd0538fSMark Fasheh 
4096dcd0538fSMark Fasheh 	if (ret == 0)
4097dcd0538fSMark Fasheh 		*last_eb_bh = bh;
4098dcd0538fSMark Fasheh 	else
4099dcd0538fSMark Fasheh 		brelse(bh);
4100dcd0538fSMark Fasheh 	return ret;
4101dcd0538fSMark Fasheh }
4102dcd0538fSMark Fasheh 
4103dcd0538fSMark Fasheh /*
4104dcd0538fSMark Fasheh  * Insert an extent into an inode btree.
4105dcd0538fSMark Fasheh  *
4106dcd0538fSMark Fasheh  * The caller needs to update fe->i_clusters
4107dcd0538fSMark Fasheh  */
4108ccd979bdSMark Fasheh int ocfs2_insert_extent(struct ocfs2_super *osb,
41091fabe148SMark Fasheh 			handle_t *handle,
4110ccd979bdSMark Fasheh 			struct inode *inode,
4111ccd979bdSMark Fasheh 			struct buffer_head *fe_bh,
4112dcd0538fSMark Fasheh 			u32 cpos,
4113ccd979bdSMark Fasheh 			u64 start_blk,
4114ccd979bdSMark Fasheh 			u32 new_clusters,
41152ae99a60SMark Fasheh 			u8 flags,
4116ccd979bdSMark Fasheh 			struct ocfs2_alloc_context *meta_ac)
4117ccd979bdSMark Fasheh {
4118c3afcbb3SMark Fasheh 	int status;
4119c77534f6STao Mao 	int uninitialized_var(free_records);
4120ccd979bdSMark Fasheh 	struct buffer_head *last_eb_bh = NULL;
4121dcd0538fSMark Fasheh 	struct ocfs2_insert_type insert = {0, };
4122dcd0538fSMark Fasheh 	struct ocfs2_extent_rec rec;
4123ccd979bdSMark Fasheh 
41241afc32b9SMark Fasheh 	BUG_ON(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL);
41251afc32b9SMark Fasheh 
4126dcd0538fSMark Fasheh 	mlog(0, "add %u clusters at position %u to inode %llu\n",
4127dcd0538fSMark Fasheh 	     new_clusters, cpos, (unsigned long long)OCFS2_I(inode)->ip_blkno);
4128ccd979bdSMark Fasheh 
4129dcd0538fSMark Fasheh 	mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) &&
4130dcd0538fSMark Fasheh 			(OCFS2_I(inode)->ip_clusters != cpos),
4131dcd0538fSMark Fasheh 			"Device %s, asking for sparse allocation: inode %llu, "
4132dcd0538fSMark Fasheh 			"cpos %u, clusters %u\n",
4133dcd0538fSMark Fasheh 			osb->dev_str,
4134dcd0538fSMark Fasheh 			(unsigned long long)OCFS2_I(inode)->ip_blkno, cpos,
4135dcd0538fSMark Fasheh 			OCFS2_I(inode)->ip_clusters);
4136ccd979bdSMark Fasheh 
4137e48edee2SMark Fasheh 	memset(&rec, 0, sizeof(rec));
4138dcd0538fSMark Fasheh 	rec.e_cpos = cpu_to_le32(cpos);
4139dcd0538fSMark Fasheh 	rec.e_blkno = cpu_to_le64(start_blk);
4140e48edee2SMark Fasheh 	rec.e_leaf_clusters = cpu_to_le16(new_clusters);
41412ae99a60SMark Fasheh 	rec.e_flags = flags;
4142ccd979bdSMark Fasheh 
4143dcd0538fSMark Fasheh 	status = ocfs2_figure_insert_type(inode, fe_bh, &last_eb_bh, &rec,
4144c77534f6STao Mao 					  &free_records, &insert);
4145ccd979bdSMark Fasheh 	if (status < 0) {
4146dcd0538fSMark Fasheh 		mlog_errno(status);
4147ccd979bdSMark Fasheh 		goto bail;
4148ccd979bdSMark Fasheh 	}
4149ccd979bdSMark Fasheh 
4150dcd0538fSMark Fasheh 	mlog(0, "Insert.appending: %u, Insert.Contig: %u, "
4151dcd0538fSMark Fasheh 	     "Insert.contig_index: %d, Insert.free_records: %d, "
4152dcd0538fSMark Fasheh 	     "Insert.tree_depth: %d\n",
4153dcd0538fSMark Fasheh 	     insert.ins_appending, insert.ins_contig, insert.ins_contig_index,
4154c77534f6STao Mao 	     free_records, insert.ins_tree_depth);
4155dcd0538fSMark Fasheh 
4156c77534f6STao Mao 	if (insert.ins_contig == CONTIG_NONE && free_records == 0) {
4157c3afcbb3SMark Fasheh 		status = ocfs2_grow_tree(inode, handle, fe_bh,
4158328d5752SMark Fasheh 					 &insert.ins_tree_depth, &last_eb_bh,
4159ccd979bdSMark Fasheh 					 meta_ac);
4160c3afcbb3SMark Fasheh 		if (status) {
4161ccd979bdSMark Fasheh 			mlog_errno(status);
4162ccd979bdSMark Fasheh 			goto bail;
4163ccd979bdSMark Fasheh 		}
4164c3afcbb3SMark Fasheh 	}
4165ccd979bdSMark Fasheh 
4166dcd0538fSMark Fasheh 	/* Finally, we can add clusters. This might rotate the tree for us. */
4167dcd0538fSMark Fasheh 	status = ocfs2_do_insert_extent(inode, handle, fe_bh, &rec, &insert);
4168ccd979bdSMark Fasheh 	if (status < 0)
4169ccd979bdSMark Fasheh 		mlog_errno(status);
417083418978SMark Fasheh 	else
417183418978SMark Fasheh 		ocfs2_extent_map_insert_rec(inode, &rec);
4172ccd979bdSMark Fasheh 
4173ccd979bdSMark Fasheh bail:
4174ccd979bdSMark Fasheh 	if (last_eb_bh)
4175ccd979bdSMark Fasheh 		brelse(last_eb_bh);
4176ccd979bdSMark Fasheh 
4177ccd979bdSMark Fasheh 	mlog_exit(status);
4178ccd979bdSMark Fasheh 	return status;
4179ccd979bdSMark Fasheh }
4180ccd979bdSMark Fasheh 
4181328d5752SMark Fasheh static void ocfs2_make_right_split_rec(struct super_block *sb,
4182328d5752SMark Fasheh 				       struct ocfs2_extent_rec *split_rec,
4183328d5752SMark Fasheh 				       u32 cpos,
4184328d5752SMark Fasheh 				       struct ocfs2_extent_rec *rec)
4185328d5752SMark Fasheh {
4186328d5752SMark Fasheh 	u32 rec_cpos = le32_to_cpu(rec->e_cpos);
4187328d5752SMark Fasheh 	u32 rec_range = rec_cpos + le16_to_cpu(rec->e_leaf_clusters);
4188328d5752SMark Fasheh 
4189328d5752SMark Fasheh 	memset(split_rec, 0, sizeof(struct ocfs2_extent_rec));
4190328d5752SMark Fasheh 
4191328d5752SMark Fasheh 	split_rec->e_cpos = cpu_to_le32(cpos);
4192328d5752SMark Fasheh 	split_rec->e_leaf_clusters = cpu_to_le16(rec_range - cpos);
4193328d5752SMark Fasheh 
4194328d5752SMark Fasheh 	split_rec->e_blkno = rec->e_blkno;
4195328d5752SMark Fasheh 	le64_add_cpu(&split_rec->e_blkno,
4196328d5752SMark Fasheh 		     ocfs2_clusters_to_blocks(sb, cpos - rec_cpos));
4197328d5752SMark Fasheh 
4198328d5752SMark Fasheh 	split_rec->e_flags = rec->e_flags;
4199328d5752SMark Fasheh }
4200328d5752SMark Fasheh 
4201328d5752SMark Fasheh static int ocfs2_split_and_insert(struct inode *inode,
4202328d5752SMark Fasheh 				  handle_t *handle,
4203328d5752SMark Fasheh 				  struct ocfs2_path *path,
4204328d5752SMark Fasheh 				  struct buffer_head *di_bh,
4205328d5752SMark Fasheh 				  struct buffer_head **last_eb_bh,
4206328d5752SMark Fasheh 				  int split_index,
4207328d5752SMark Fasheh 				  struct ocfs2_extent_rec *orig_split_rec,
4208328d5752SMark Fasheh 				  struct ocfs2_alloc_context *meta_ac)
4209328d5752SMark Fasheh {
4210328d5752SMark Fasheh 	int ret = 0, depth;
4211328d5752SMark Fasheh 	unsigned int insert_range, rec_range, do_leftright = 0;
4212328d5752SMark Fasheh 	struct ocfs2_extent_rec tmprec;
4213328d5752SMark Fasheh 	struct ocfs2_extent_list *rightmost_el;
4214328d5752SMark Fasheh 	struct ocfs2_extent_rec rec;
4215328d5752SMark Fasheh 	struct ocfs2_extent_rec split_rec = *orig_split_rec;
4216328d5752SMark Fasheh 	struct ocfs2_insert_type insert;
4217328d5752SMark Fasheh 	struct ocfs2_extent_block *eb;
4218328d5752SMark Fasheh 	struct ocfs2_dinode *di;
4219328d5752SMark Fasheh 
4220328d5752SMark Fasheh leftright:
4221328d5752SMark Fasheh 	/*
4222328d5752SMark Fasheh 	 * Store a copy of the record on the stack - it might move
4223328d5752SMark Fasheh 	 * around as the tree is manipulated below.
4224328d5752SMark Fasheh 	 */
4225328d5752SMark Fasheh 	rec = path_leaf_el(path)->l_recs[split_index];
4226328d5752SMark Fasheh 
4227328d5752SMark Fasheh 	di = (struct ocfs2_dinode *)di_bh->b_data;
4228328d5752SMark Fasheh 	rightmost_el = &di->id2.i_list;
4229328d5752SMark Fasheh 
4230328d5752SMark Fasheh 	depth = le16_to_cpu(rightmost_el->l_tree_depth);
4231328d5752SMark Fasheh 	if (depth) {
4232328d5752SMark Fasheh 		BUG_ON(!(*last_eb_bh));
4233328d5752SMark Fasheh 		eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
4234328d5752SMark Fasheh 		rightmost_el = &eb->h_list;
4235328d5752SMark Fasheh 	}
4236328d5752SMark Fasheh 
4237328d5752SMark Fasheh 	if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
4238328d5752SMark Fasheh 	    le16_to_cpu(rightmost_el->l_count)) {
4239328d5752SMark Fasheh 		ret = ocfs2_grow_tree(inode, handle, di_bh, &depth, last_eb_bh,
4240328d5752SMark Fasheh 				      meta_ac);
4241328d5752SMark Fasheh 		if (ret) {
4242328d5752SMark Fasheh 			mlog_errno(ret);
4243328d5752SMark Fasheh 			goto out;
4244328d5752SMark Fasheh 		}
4245328d5752SMark Fasheh 	}
4246328d5752SMark Fasheh 
4247328d5752SMark Fasheh 	memset(&insert, 0, sizeof(struct ocfs2_insert_type));
4248328d5752SMark Fasheh 	insert.ins_appending = APPEND_NONE;
4249328d5752SMark Fasheh 	insert.ins_contig = CONTIG_NONE;
4250328d5752SMark Fasheh 	insert.ins_tree_depth = depth;
4251328d5752SMark Fasheh 
4252328d5752SMark Fasheh 	insert_range = le32_to_cpu(split_rec.e_cpos) +
4253328d5752SMark Fasheh 		le16_to_cpu(split_rec.e_leaf_clusters);
4254328d5752SMark Fasheh 	rec_range = le32_to_cpu(rec.e_cpos) +
4255328d5752SMark Fasheh 		le16_to_cpu(rec.e_leaf_clusters);
4256328d5752SMark Fasheh 
4257328d5752SMark Fasheh 	if (split_rec.e_cpos == rec.e_cpos) {
4258328d5752SMark Fasheh 		insert.ins_split = SPLIT_LEFT;
4259328d5752SMark Fasheh 	} else if (insert_range == rec_range) {
4260328d5752SMark Fasheh 		insert.ins_split = SPLIT_RIGHT;
4261328d5752SMark Fasheh 	} else {
4262328d5752SMark Fasheh 		/*
4263328d5752SMark Fasheh 		 * Left/right split. We fake this as a right split
4264328d5752SMark Fasheh 		 * first and then make a second pass as a left split.
4265328d5752SMark Fasheh 		 */
4266328d5752SMark Fasheh 		insert.ins_split = SPLIT_RIGHT;
4267328d5752SMark Fasheh 
4268328d5752SMark Fasheh 		ocfs2_make_right_split_rec(inode->i_sb, &tmprec, insert_range,
4269328d5752SMark Fasheh 					   &rec);
4270328d5752SMark Fasheh 
4271328d5752SMark Fasheh 		split_rec = tmprec;
4272328d5752SMark Fasheh 
4273328d5752SMark Fasheh 		BUG_ON(do_leftright);
4274328d5752SMark Fasheh 		do_leftright = 1;
4275328d5752SMark Fasheh 	}
4276328d5752SMark Fasheh 
4277328d5752SMark Fasheh 	ret = ocfs2_do_insert_extent(inode, handle, di_bh, &split_rec,
4278328d5752SMark Fasheh 				     &insert);
4279328d5752SMark Fasheh 	if (ret) {
4280328d5752SMark Fasheh 		mlog_errno(ret);
4281328d5752SMark Fasheh 		goto out;
4282328d5752SMark Fasheh 	}
4283328d5752SMark Fasheh 
4284328d5752SMark Fasheh 	if (do_leftright == 1) {
4285328d5752SMark Fasheh 		u32 cpos;
4286328d5752SMark Fasheh 		struct ocfs2_extent_list *el;
4287328d5752SMark Fasheh 
4288328d5752SMark Fasheh 		do_leftright++;
4289328d5752SMark Fasheh 		split_rec = *orig_split_rec;
4290328d5752SMark Fasheh 
4291328d5752SMark Fasheh 		ocfs2_reinit_path(path, 1);
4292328d5752SMark Fasheh 
4293328d5752SMark Fasheh 		cpos = le32_to_cpu(split_rec.e_cpos);
4294328d5752SMark Fasheh 		ret = ocfs2_find_path(inode, path, cpos);
4295328d5752SMark Fasheh 		if (ret) {
4296328d5752SMark Fasheh 			mlog_errno(ret);
4297328d5752SMark Fasheh 			goto out;
4298328d5752SMark Fasheh 		}
4299328d5752SMark Fasheh 
4300328d5752SMark Fasheh 		el = path_leaf_el(path);
4301328d5752SMark Fasheh 		split_index = ocfs2_search_extent_list(el, cpos);
4302328d5752SMark Fasheh 		goto leftright;
4303328d5752SMark Fasheh 	}
4304328d5752SMark Fasheh out:
4305328d5752SMark Fasheh 
4306328d5752SMark Fasheh 	return ret;
4307328d5752SMark Fasheh }
4308328d5752SMark Fasheh 
4309328d5752SMark Fasheh /*
4310328d5752SMark Fasheh  * Mark part or all of the extent record at split_index in the leaf
4311328d5752SMark Fasheh  * pointed to by path as written. This removes the unwritten
4312328d5752SMark Fasheh  * extent flag.
4313328d5752SMark Fasheh  *
4314328d5752SMark Fasheh  * Care is taken to handle contiguousness so as to not grow the tree.
4315328d5752SMark Fasheh  *
4316328d5752SMark Fasheh  * meta_ac is not strictly necessary - we only truly need it if growth
4317328d5752SMark Fasheh  * of the tree is required. All other cases will degrade into a less
4318328d5752SMark Fasheh  * optimal tree layout.
4319328d5752SMark Fasheh  *
4320328d5752SMark Fasheh  * last_eb_bh should be the rightmost leaf block for any inode with a
4321328d5752SMark Fasheh  * btree. Since a split may grow the tree or a merge might shrink it, the caller cannot trust the contents of that buffer after this call.
4322328d5752SMark Fasheh  *
4323328d5752SMark Fasheh  * This code is optimized for readability - several passes might be
4324328d5752SMark Fasheh  * made over certain portions of the tree. All of those blocks will
4325328d5752SMark Fasheh  * have been brought into cache (and pinned via the journal), so the
4326328d5752SMark Fasheh  * extra overhead is not expressed in terms of disk reads.
4327328d5752SMark Fasheh  */
4328328d5752SMark Fasheh static int __ocfs2_mark_extent_written(struct inode *inode,
4329328d5752SMark Fasheh 				       struct buffer_head *di_bh,
4330328d5752SMark Fasheh 				       handle_t *handle,
4331328d5752SMark Fasheh 				       struct ocfs2_path *path,
4332328d5752SMark Fasheh 				       int split_index,
4333328d5752SMark Fasheh 				       struct ocfs2_extent_rec *split_rec,
4334328d5752SMark Fasheh 				       struct ocfs2_alloc_context *meta_ac,
4335328d5752SMark Fasheh 				       struct ocfs2_cached_dealloc_ctxt *dealloc)
4336328d5752SMark Fasheh {
4337328d5752SMark Fasheh 	int ret = 0;
4338328d5752SMark Fasheh 	struct ocfs2_extent_list *el = path_leaf_el(path);
4339e8aed345SMark Fasheh 	struct buffer_head *last_eb_bh = NULL;
4340328d5752SMark Fasheh 	struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
4341328d5752SMark Fasheh 	struct ocfs2_merge_ctxt ctxt;
4342328d5752SMark Fasheh 	struct ocfs2_extent_list *rightmost_el;
4343328d5752SMark Fasheh 
43443cf0c507SRoel Kluin 	if (!(rec->e_flags & OCFS2_EXT_UNWRITTEN)) {
4345328d5752SMark Fasheh 		ret = -EIO;
4346328d5752SMark Fasheh 		mlog_errno(ret);
4347328d5752SMark Fasheh 		goto out;
4348328d5752SMark Fasheh 	}
4349328d5752SMark Fasheh 
4350328d5752SMark Fasheh 	if (le32_to_cpu(rec->e_cpos) > le32_to_cpu(split_rec->e_cpos) ||
4351328d5752SMark Fasheh 	    ((le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)) <
4352328d5752SMark Fasheh 	     (le32_to_cpu(split_rec->e_cpos) + le16_to_cpu(split_rec->e_leaf_clusters)))) {
4353328d5752SMark Fasheh 		ret = -EIO;
4354328d5752SMark Fasheh 		mlog_errno(ret);
4355328d5752SMark Fasheh 		goto out;
4356328d5752SMark Fasheh 	}
4357328d5752SMark Fasheh 
4358ad5a4d70STao Ma 	ctxt.c_contig_type = ocfs2_figure_merge_contig_type(inode, path, el,
4359328d5752SMark Fasheh 							    split_index,
4360328d5752SMark Fasheh 							    split_rec);
4361328d5752SMark Fasheh 
4362328d5752SMark Fasheh 	/*
4363328d5752SMark Fasheh 	 * The core merge / split code wants to know how much room is
4364328d5752SMark Fasheh 	 * left in this inodes allocation tree, so we pass the
4365328d5752SMark Fasheh 	 * rightmost extent list.
4366328d5752SMark Fasheh 	 */
4367328d5752SMark Fasheh 	if (path->p_tree_depth) {
4368328d5752SMark Fasheh 		struct ocfs2_extent_block *eb;
4369328d5752SMark Fasheh 		struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
4370328d5752SMark Fasheh 
4371328d5752SMark Fasheh 		ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
4372328d5752SMark Fasheh 				       le64_to_cpu(di->i_last_eb_blk),
4373328d5752SMark Fasheh 				       &last_eb_bh, OCFS2_BH_CACHED, inode);
4374328d5752SMark Fasheh 		if (ret) {
4375328d5752SMark Fasheh 			mlog_exit(ret);
4376328d5752SMark Fasheh 			goto out;
4377328d5752SMark Fasheh 		}
4378328d5752SMark Fasheh 
4379328d5752SMark Fasheh 		eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
4380328d5752SMark Fasheh 		if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
4381328d5752SMark Fasheh 			OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
4382328d5752SMark Fasheh 			ret = -EROFS;
4383328d5752SMark Fasheh 			goto out;
4384328d5752SMark Fasheh 		}
4385328d5752SMark Fasheh 
4386328d5752SMark Fasheh 		rightmost_el = &eb->h_list;
4387328d5752SMark Fasheh 	} else
4388328d5752SMark Fasheh 		rightmost_el = path_root_el(path);
4389328d5752SMark Fasheh 
4390328d5752SMark Fasheh 	if (rec->e_cpos == split_rec->e_cpos &&
4391328d5752SMark Fasheh 	    rec->e_leaf_clusters == split_rec->e_leaf_clusters)
4392328d5752SMark Fasheh 		ctxt.c_split_covers_rec = 1;
4393328d5752SMark Fasheh 	else
4394328d5752SMark Fasheh 		ctxt.c_split_covers_rec = 0;
4395328d5752SMark Fasheh 
4396328d5752SMark Fasheh 	ctxt.c_has_empty_extent = ocfs2_is_empty_extent(&el->l_recs[0]);
4397328d5752SMark Fasheh 
4398015452b1SMark Fasheh 	mlog(0, "index: %d, contig: %u, has_empty: %u, split_covers: %u\n",
4399015452b1SMark Fasheh 	     split_index, ctxt.c_contig_type, ctxt.c_has_empty_extent,
4400015452b1SMark Fasheh 	     ctxt.c_split_covers_rec);
4401328d5752SMark Fasheh 
4402328d5752SMark Fasheh 	if (ctxt.c_contig_type == CONTIG_NONE) {
4403328d5752SMark Fasheh 		if (ctxt.c_split_covers_rec)
4404328d5752SMark Fasheh 			el->l_recs[split_index] = *split_rec;
4405328d5752SMark Fasheh 		else
4406328d5752SMark Fasheh 			ret = ocfs2_split_and_insert(inode, handle, path, di_bh,
4407328d5752SMark Fasheh 						     &last_eb_bh, split_index,
4408328d5752SMark Fasheh 						     split_rec, meta_ac);
4409328d5752SMark Fasheh 		if (ret)
4410328d5752SMark Fasheh 			mlog_errno(ret);
4411328d5752SMark Fasheh 	} else {
4412328d5752SMark Fasheh 		ret = ocfs2_try_to_merge_extent(inode, handle, path,
4413328d5752SMark Fasheh 						split_index, split_rec,
4414328d5752SMark Fasheh 						dealloc, &ctxt);
4415328d5752SMark Fasheh 		if (ret)
4416328d5752SMark Fasheh 			mlog_errno(ret);
4417328d5752SMark Fasheh 	}
4418328d5752SMark Fasheh 
4419328d5752SMark Fasheh out:
4420328d5752SMark Fasheh 	brelse(last_eb_bh);
4421328d5752SMark Fasheh 	return ret;
4422328d5752SMark Fasheh }
4423328d5752SMark Fasheh 
4424328d5752SMark Fasheh /*
4425328d5752SMark Fasheh  * Mark the already-existing extent at cpos as written for len clusters.
4426328d5752SMark Fasheh  *
4427328d5752SMark Fasheh  * If the existing extent is larger than the request, initiate a
4428328d5752SMark Fasheh  * split. An attempt will be made at merging with adjacent extents.
4429328d5752SMark Fasheh  *
4430328d5752SMark Fasheh  * The caller is responsible for passing down meta_ac if we'll need it.
4431328d5752SMark Fasheh  */
4432328d5752SMark Fasheh int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *di_bh,
4433328d5752SMark Fasheh 			      handle_t *handle, u32 cpos, u32 len, u32 phys,
4434328d5752SMark Fasheh 			      struct ocfs2_alloc_context *meta_ac,
4435328d5752SMark Fasheh 			      struct ocfs2_cached_dealloc_ctxt *dealloc)
4436328d5752SMark Fasheh {
4437328d5752SMark Fasheh 	int ret, index;
4438328d5752SMark Fasheh 	u64 start_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys);
4439328d5752SMark Fasheh 	struct ocfs2_extent_rec split_rec;
4440328d5752SMark Fasheh 	struct ocfs2_path *left_path = NULL;
4441328d5752SMark Fasheh 	struct ocfs2_extent_list *el;
4442328d5752SMark Fasheh 
4443328d5752SMark Fasheh 	mlog(0, "Inode %lu cpos %u, len %u, phys %u (%llu)\n",
4444328d5752SMark Fasheh 	     inode->i_ino, cpos, len, phys, (unsigned long long)start_blkno);
4445328d5752SMark Fasheh 
4446328d5752SMark Fasheh 	if (!ocfs2_writes_unwritten_extents(OCFS2_SB(inode->i_sb))) {
4447328d5752SMark Fasheh 		ocfs2_error(inode->i_sb, "Inode %llu has unwritten extents "
4448328d5752SMark Fasheh 			    "that are being written to, but the feature bit "
4449328d5752SMark Fasheh 			    "is not set in the super block.",
4450328d5752SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno);
4451328d5752SMark Fasheh 		ret = -EROFS;
4452328d5752SMark Fasheh 		goto out;
4453328d5752SMark Fasheh 	}
4454328d5752SMark Fasheh 
4455328d5752SMark Fasheh 	/*
4456328d5752SMark Fasheh 	 * XXX: This should be fixed up so that we just re-insert the
4457328d5752SMark Fasheh 	 * next extent records.
4458328d5752SMark Fasheh 	 */
4459328d5752SMark Fasheh 	ocfs2_extent_map_trunc(inode, 0);
4460328d5752SMark Fasheh 
4461328d5752SMark Fasheh 	left_path = ocfs2_new_inode_path(di_bh);
4462328d5752SMark Fasheh 	if (!left_path) {
4463328d5752SMark Fasheh 		ret = -ENOMEM;
4464328d5752SMark Fasheh 		mlog_errno(ret);
4465328d5752SMark Fasheh 		goto out;
4466328d5752SMark Fasheh 	}
4467328d5752SMark Fasheh 
4468328d5752SMark Fasheh 	ret = ocfs2_find_path(inode, left_path, cpos);
4469328d5752SMark Fasheh 	if (ret) {
4470328d5752SMark Fasheh 		mlog_errno(ret);
4471328d5752SMark Fasheh 		goto out;
4472328d5752SMark Fasheh 	}
4473328d5752SMark Fasheh 	el = path_leaf_el(left_path);
4474328d5752SMark Fasheh 
4475328d5752SMark Fasheh 	index = ocfs2_search_extent_list(el, cpos);
4476328d5752SMark Fasheh 	if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
4477328d5752SMark Fasheh 		ocfs2_error(inode->i_sb,
4478328d5752SMark Fasheh 			    "Inode %llu has an extent at cpos %u which can no "
4479328d5752SMark Fasheh 			    "longer be found.\n",
4480328d5752SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos);
4481328d5752SMark Fasheh 		ret = -EROFS;
4482328d5752SMark Fasheh 		goto out;
4483328d5752SMark Fasheh 	}
4484328d5752SMark Fasheh 
4485328d5752SMark Fasheh 	memset(&split_rec, 0, sizeof(struct ocfs2_extent_rec));
4486328d5752SMark Fasheh 	split_rec.e_cpos = cpu_to_le32(cpos);
4487328d5752SMark Fasheh 	split_rec.e_leaf_clusters = cpu_to_le16(len);
4488328d5752SMark Fasheh 	split_rec.e_blkno = cpu_to_le64(start_blkno);
4489328d5752SMark Fasheh 	split_rec.e_flags = path_leaf_el(left_path)->l_recs[index].e_flags;
4490328d5752SMark Fasheh 	split_rec.e_flags &= ~OCFS2_EXT_UNWRITTEN;
4491328d5752SMark Fasheh 
4492328d5752SMark Fasheh 	ret = __ocfs2_mark_extent_written(inode, di_bh, handle, left_path,
4493328d5752SMark Fasheh 					  index, &split_rec, meta_ac, dealloc);
4494328d5752SMark Fasheh 	if (ret)
4495328d5752SMark Fasheh 		mlog_errno(ret);
4496328d5752SMark Fasheh 
4497328d5752SMark Fasheh out:
4498328d5752SMark Fasheh 	ocfs2_free_path(left_path);
4499328d5752SMark Fasheh 	return ret;
4500328d5752SMark Fasheh }
4501328d5752SMark Fasheh 
4502d0c7d708SMark Fasheh static int ocfs2_split_tree(struct inode *inode, struct buffer_head *di_bh,
4503d0c7d708SMark Fasheh 			    handle_t *handle, struct ocfs2_path *path,
4504d0c7d708SMark Fasheh 			    int index, u32 new_range,
4505d0c7d708SMark Fasheh 			    struct ocfs2_alloc_context *meta_ac)
4506d0c7d708SMark Fasheh {
4507d0c7d708SMark Fasheh 	int ret, depth, credits = handle->h_buffer_credits;
4508d0c7d708SMark Fasheh 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
4509d0c7d708SMark Fasheh 	struct buffer_head *last_eb_bh = NULL;
4510d0c7d708SMark Fasheh 	struct ocfs2_extent_block *eb;
4511d0c7d708SMark Fasheh 	struct ocfs2_extent_list *rightmost_el, *el;
4512d0c7d708SMark Fasheh 	struct ocfs2_extent_rec split_rec;
4513d0c7d708SMark Fasheh 	struct ocfs2_extent_rec *rec;
4514d0c7d708SMark Fasheh 	struct ocfs2_insert_type insert;
4515d0c7d708SMark Fasheh 
4516d0c7d708SMark Fasheh 	/*
4517d0c7d708SMark Fasheh 	 * Setup the record to split before we grow the tree.
4518d0c7d708SMark Fasheh 	 */
4519d0c7d708SMark Fasheh 	el = path_leaf_el(path);
4520d0c7d708SMark Fasheh 	rec = &el->l_recs[index];
4521d0c7d708SMark Fasheh 	ocfs2_make_right_split_rec(inode->i_sb, &split_rec, new_range, rec);
4522d0c7d708SMark Fasheh 
4523d0c7d708SMark Fasheh 	depth = path->p_tree_depth;
4524d0c7d708SMark Fasheh 	if (depth > 0) {
4525d0c7d708SMark Fasheh 		ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
4526d0c7d708SMark Fasheh 				       le64_to_cpu(di->i_last_eb_blk),
4527d0c7d708SMark Fasheh 				       &last_eb_bh, OCFS2_BH_CACHED, inode);
4528d0c7d708SMark Fasheh 		if (ret < 0) {
4529d0c7d708SMark Fasheh 			mlog_errno(ret);
4530d0c7d708SMark Fasheh 			goto out;
4531d0c7d708SMark Fasheh 		}
4532d0c7d708SMark Fasheh 
4533d0c7d708SMark Fasheh 		eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
4534d0c7d708SMark Fasheh 		rightmost_el = &eb->h_list;
4535d0c7d708SMark Fasheh 	} else
4536d0c7d708SMark Fasheh 		rightmost_el = path_leaf_el(path);
4537d0c7d708SMark Fasheh 
4538d0c7d708SMark Fasheh 	credits += path->p_tree_depth + ocfs2_extend_meta_needed(di);
4539d0c7d708SMark Fasheh 	ret = ocfs2_extend_trans(handle, credits);
4540d0c7d708SMark Fasheh 	if (ret) {
4541d0c7d708SMark Fasheh 		mlog_errno(ret);
4542d0c7d708SMark Fasheh 		goto out;
4543d0c7d708SMark Fasheh 	}
4544d0c7d708SMark Fasheh 
4545d0c7d708SMark Fasheh 	if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
4546d0c7d708SMark Fasheh 	    le16_to_cpu(rightmost_el->l_count)) {
4547d0c7d708SMark Fasheh 		ret = ocfs2_grow_tree(inode, handle, di_bh, &depth, &last_eb_bh,
4548d0c7d708SMark Fasheh 				      meta_ac);
4549d0c7d708SMark Fasheh 		if (ret) {
4550d0c7d708SMark Fasheh 			mlog_errno(ret);
4551d0c7d708SMark Fasheh 			goto out;
4552d0c7d708SMark Fasheh 		}
4553d0c7d708SMark Fasheh 	}
4554d0c7d708SMark Fasheh 
4555d0c7d708SMark Fasheh 	memset(&insert, 0, sizeof(struct ocfs2_insert_type));
4556d0c7d708SMark Fasheh 	insert.ins_appending = APPEND_NONE;
4557d0c7d708SMark Fasheh 	insert.ins_contig = CONTIG_NONE;
4558d0c7d708SMark Fasheh 	insert.ins_split = SPLIT_RIGHT;
4559d0c7d708SMark Fasheh 	insert.ins_tree_depth = depth;
4560d0c7d708SMark Fasheh 
4561d0c7d708SMark Fasheh 	ret = ocfs2_do_insert_extent(inode, handle, di_bh, &split_rec, &insert);
4562d0c7d708SMark Fasheh 	if (ret)
4563d0c7d708SMark Fasheh 		mlog_errno(ret);
4564d0c7d708SMark Fasheh 
4565d0c7d708SMark Fasheh out:
4566d0c7d708SMark Fasheh 	brelse(last_eb_bh);
4567d0c7d708SMark Fasheh 	return ret;
4568d0c7d708SMark Fasheh }
4569d0c7d708SMark Fasheh 
4570d0c7d708SMark Fasheh static int ocfs2_truncate_rec(struct inode *inode, handle_t *handle,
4571d0c7d708SMark Fasheh 			      struct ocfs2_path *path, int index,
4572d0c7d708SMark Fasheh 			      struct ocfs2_cached_dealloc_ctxt *dealloc,
4573d0c7d708SMark Fasheh 			      u32 cpos, u32 len)
4574d0c7d708SMark Fasheh {
4575d0c7d708SMark Fasheh 	int ret;
4576d0c7d708SMark Fasheh 	u32 left_cpos, rec_range, trunc_range;
4577d0c7d708SMark Fasheh 	int wants_rotate = 0, is_rightmost_tree_rec = 0;
4578d0c7d708SMark Fasheh 	struct super_block *sb = inode->i_sb;
4579d0c7d708SMark Fasheh 	struct ocfs2_path *left_path = NULL;
4580d0c7d708SMark Fasheh 	struct ocfs2_extent_list *el = path_leaf_el(path);
4581d0c7d708SMark Fasheh 	struct ocfs2_extent_rec *rec;
4582d0c7d708SMark Fasheh 	struct ocfs2_extent_block *eb;
4583d0c7d708SMark Fasheh 
4584d0c7d708SMark Fasheh 	if (ocfs2_is_empty_extent(&el->l_recs[0]) && index > 0) {
4585d0c7d708SMark Fasheh 		ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc);
4586d0c7d708SMark Fasheh 		if (ret) {
4587d0c7d708SMark Fasheh 			mlog_errno(ret);
4588d0c7d708SMark Fasheh 			goto out;
4589d0c7d708SMark Fasheh 		}
4590d0c7d708SMark Fasheh 
4591d0c7d708SMark Fasheh 		index--;
4592d0c7d708SMark Fasheh 	}
4593d0c7d708SMark Fasheh 
4594d0c7d708SMark Fasheh 	if (index == (le16_to_cpu(el->l_next_free_rec) - 1) &&
4595d0c7d708SMark Fasheh 	    path->p_tree_depth) {
4596d0c7d708SMark Fasheh 		/*
4597d0c7d708SMark Fasheh 		 * Check whether this is the rightmost tree record. If
4598d0c7d708SMark Fasheh 		 * we remove all of this record or part of its right
4599d0c7d708SMark Fasheh 		 * edge then an update of the record lengths above it
4600d0c7d708SMark Fasheh 		 * will be required.
4601d0c7d708SMark Fasheh 		 */
4602d0c7d708SMark Fasheh 		eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
4603d0c7d708SMark Fasheh 		if (eb->h_next_leaf_blk == 0)
4604d0c7d708SMark Fasheh 			is_rightmost_tree_rec = 1;
4605d0c7d708SMark Fasheh 	}
4606d0c7d708SMark Fasheh 
4607d0c7d708SMark Fasheh 	rec = &el->l_recs[index];
4608d0c7d708SMark Fasheh 	if (index == 0 && path->p_tree_depth &&
4609d0c7d708SMark Fasheh 	    le32_to_cpu(rec->e_cpos) == cpos) {
4610d0c7d708SMark Fasheh 		/*
4611d0c7d708SMark Fasheh 		 * Changing the leftmost offset (via partial or whole
4612d0c7d708SMark Fasheh 		 * record truncate) of an interior (or rightmost) path
4613d0c7d708SMark Fasheh 		 * means we have to update the subtree that is formed
4614d0c7d708SMark Fasheh 		 * by this leaf and the one to it's left.
4615d0c7d708SMark Fasheh 		 *
4616d0c7d708SMark Fasheh 		 * There are two cases we can skip:
4617d0c7d708SMark Fasheh 		 *   1) Path is the leftmost one in our inode tree.
4618d0c7d708SMark Fasheh 		 *   2) The leaf is rightmost and will be empty after
4619d0c7d708SMark Fasheh 		 *      we remove the extent record - the rotate code
4620d0c7d708SMark Fasheh 		 *      knows how to update the newly formed edge.
4621d0c7d708SMark Fasheh 		 */
4622d0c7d708SMark Fasheh 
4623d0c7d708SMark Fasheh 		ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path,
4624d0c7d708SMark Fasheh 						    &left_cpos);
4625d0c7d708SMark Fasheh 		if (ret) {
4626d0c7d708SMark Fasheh 			mlog_errno(ret);
4627d0c7d708SMark Fasheh 			goto out;
4628d0c7d708SMark Fasheh 		}
4629d0c7d708SMark Fasheh 
4630d0c7d708SMark Fasheh 		if (left_cpos && le16_to_cpu(el->l_next_free_rec) > 1) {
4631d0c7d708SMark Fasheh 			left_path = ocfs2_new_path(path_root_bh(path),
4632d0c7d708SMark Fasheh 						   path_root_el(path));
4633d0c7d708SMark Fasheh 			if (!left_path) {
4634d0c7d708SMark Fasheh 				ret = -ENOMEM;
4635d0c7d708SMark Fasheh 				mlog_errno(ret);
4636d0c7d708SMark Fasheh 				goto out;
4637d0c7d708SMark Fasheh 			}
4638d0c7d708SMark Fasheh 
4639d0c7d708SMark Fasheh 			ret = ocfs2_find_path(inode, left_path, left_cpos);
4640d0c7d708SMark Fasheh 			if (ret) {
4641d0c7d708SMark Fasheh 				mlog_errno(ret);
4642d0c7d708SMark Fasheh 				goto out;
4643d0c7d708SMark Fasheh 			}
4644d0c7d708SMark Fasheh 		}
4645d0c7d708SMark Fasheh 	}
4646d0c7d708SMark Fasheh 
4647d0c7d708SMark Fasheh 	ret = ocfs2_extend_rotate_transaction(handle, 0,
4648d0c7d708SMark Fasheh 					      handle->h_buffer_credits,
4649d0c7d708SMark Fasheh 					      path);
4650d0c7d708SMark Fasheh 	if (ret) {
4651d0c7d708SMark Fasheh 		mlog_errno(ret);
4652d0c7d708SMark Fasheh 		goto out;
4653d0c7d708SMark Fasheh 	}
4654d0c7d708SMark Fasheh 
4655d0c7d708SMark Fasheh 	ret = ocfs2_journal_access_path(inode, handle, path);
4656d0c7d708SMark Fasheh 	if (ret) {
4657d0c7d708SMark Fasheh 		mlog_errno(ret);
4658d0c7d708SMark Fasheh 		goto out;
4659d0c7d708SMark Fasheh 	}
4660d0c7d708SMark Fasheh 
4661d0c7d708SMark Fasheh 	ret = ocfs2_journal_access_path(inode, handle, left_path);
4662d0c7d708SMark Fasheh 	if (ret) {
4663d0c7d708SMark Fasheh 		mlog_errno(ret);
4664d0c7d708SMark Fasheh 		goto out;
4665d0c7d708SMark Fasheh 	}
4666d0c7d708SMark Fasheh 
4667d0c7d708SMark Fasheh 	rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
4668d0c7d708SMark Fasheh 	trunc_range = cpos + len;
4669d0c7d708SMark Fasheh 
4670d0c7d708SMark Fasheh 	if (le32_to_cpu(rec->e_cpos) == cpos && rec_range == trunc_range) {
4671d0c7d708SMark Fasheh 		int next_free;
4672d0c7d708SMark Fasheh 
4673d0c7d708SMark Fasheh 		memset(rec, 0, sizeof(*rec));
4674d0c7d708SMark Fasheh 		ocfs2_cleanup_merge(el, index);
4675d0c7d708SMark Fasheh 		wants_rotate = 1;
4676d0c7d708SMark Fasheh 
4677d0c7d708SMark Fasheh 		next_free = le16_to_cpu(el->l_next_free_rec);
4678d0c7d708SMark Fasheh 		if (is_rightmost_tree_rec && next_free > 1) {
4679d0c7d708SMark Fasheh 			/*
4680d0c7d708SMark Fasheh 			 * We skip the edge update if this path will
4681d0c7d708SMark Fasheh 			 * be deleted by the rotate code.
4682d0c7d708SMark Fasheh 			 */
4683d0c7d708SMark Fasheh 			rec = &el->l_recs[next_free - 1];
4684d0c7d708SMark Fasheh 			ocfs2_adjust_rightmost_records(inode, handle, path,
4685d0c7d708SMark Fasheh 						       rec);
4686d0c7d708SMark Fasheh 		}
4687d0c7d708SMark Fasheh 	} else if (le32_to_cpu(rec->e_cpos) == cpos) {
4688d0c7d708SMark Fasheh 		/* Remove leftmost portion of the record. */
4689d0c7d708SMark Fasheh 		le32_add_cpu(&rec->e_cpos, len);
4690d0c7d708SMark Fasheh 		le64_add_cpu(&rec->e_blkno, ocfs2_clusters_to_blocks(sb, len));
4691d0c7d708SMark Fasheh 		le16_add_cpu(&rec->e_leaf_clusters, -len);
4692d0c7d708SMark Fasheh 	} else if (rec_range == trunc_range) {
4693d0c7d708SMark Fasheh 		/* Remove rightmost portion of the record */
4694d0c7d708SMark Fasheh 		le16_add_cpu(&rec->e_leaf_clusters, -len);
4695d0c7d708SMark Fasheh 		if (is_rightmost_tree_rec)
4696d0c7d708SMark Fasheh 			ocfs2_adjust_rightmost_records(inode, handle, path, rec);
4697d0c7d708SMark Fasheh 	} else {
4698d0c7d708SMark Fasheh 		/* Caller should have trapped this. */
4699d0c7d708SMark Fasheh 		mlog(ML_ERROR, "Inode %llu: Invalid record truncate: (%u, %u) "
4700d0c7d708SMark Fasheh 		     "(%u, %u)\n", (unsigned long long)OCFS2_I(inode)->ip_blkno,
4701d0c7d708SMark Fasheh 		     le32_to_cpu(rec->e_cpos),
4702d0c7d708SMark Fasheh 		     le16_to_cpu(rec->e_leaf_clusters), cpos, len);
4703d0c7d708SMark Fasheh 		BUG();
4704d0c7d708SMark Fasheh 	}
4705d0c7d708SMark Fasheh 
4706d0c7d708SMark Fasheh 	if (left_path) {
4707d0c7d708SMark Fasheh 		int subtree_index;
4708d0c7d708SMark Fasheh 
4709d0c7d708SMark Fasheh 		subtree_index = ocfs2_find_subtree_root(inode, left_path, path);
4710d0c7d708SMark Fasheh 		ocfs2_complete_edge_insert(inode, handle, left_path, path,
4711d0c7d708SMark Fasheh 					   subtree_index);
4712d0c7d708SMark Fasheh 	}
4713d0c7d708SMark Fasheh 
4714d0c7d708SMark Fasheh 	ocfs2_journal_dirty(handle, path_leaf_bh(path));
4715d0c7d708SMark Fasheh 
4716d0c7d708SMark Fasheh 	ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc);
4717d0c7d708SMark Fasheh 	if (ret) {
4718d0c7d708SMark Fasheh 		mlog_errno(ret);
4719d0c7d708SMark Fasheh 		goto out;
4720d0c7d708SMark Fasheh 	}
4721d0c7d708SMark Fasheh 
4722d0c7d708SMark Fasheh out:
4723d0c7d708SMark Fasheh 	ocfs2_free_path(left_path);
4724d0c7d708SMark Fasheh 	return ret;
4725d0c7d708SMark Fasheh }
4726d0c7d708SMark Fasheh 
4727063c4561SMark Fasheh int ocfs2_remove_extent(struct inode *inode, struct buffer_head *di_bh,
4728d0c7d708SMark Fasheh 			u32 cpos, u32 len, handle_t *handle,
4729d0c7d708SMark Fasheh 			struct ocfs2_alloc_context *meta_ac,
4730d0c7d708SMark Fasheh 			struct ocfs2_cached_dealloc_ctxt *dealloc)
4731d0c7d708SMark Fasheh {
4732d0c7d708SMark Fasheh 	int ret, index;
4733d0c7d708SMark Fasheh 	u32 rec_range, trunc_range;
4734d0c7d708SMark Fasheh 	struct ocfs2_extent_rec *rec;
4735d0c7d708SMark Fasheh 	struct ocfs2_extent_list *el;
4736d0c7d708SMark Fasheh 	struct ocfs2_path *path;
4737d0c7d708SMark Fasheh 
4738d0c7d708SMark Fasheh 	ocfs2_extent_map_trunc(inode, 0);
4739d0c7d708SMark Fasheh 
4740d0c7d708SMark Fasheh 	path = ocfs2_new_inode_path(di_bh);
4741d0c7d708SMark Fasheh 	if (!path) {
4742d0c7d708SMark Fasheh 		ret = -ENOMEM;
4743d0c7d708SMark Fasheh 		mlog_errno(ret);
4744d0c7d708SMark Fasheh 		goto out;
4745d0c7d708SMark Fasheh 	}
4746d0c7d708SMark Fasheh 
4747d0c7d708SMark Fasheh 	ret = ocfs2_find_path(inode, path, cpos);
4748d0c7d708SMark Fasheh 	if (ret) {
4749d0c7d708SMark Fasheh 		mlog_errno(ret);
4750d0c7d708SMark Fasheh 		goto out;
4751d0c7d708SMark Fasheh 	}
4752d0c7d708SMark Fasheh 
4753d0c7d708SMark Fasheh 	el = path_leaf_el(path);
4754d0c7d708SMark Fasheh 	index = ocfs2_search_extent_list(el, cpos);
4755d0c7d708SMark Fasheh 	if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
4756d0c7d708SMark Fasheh 		ocfs2_error(inode->i_sb,
4757d0c7d708SMark Fasheh 			    "Inode %llu has an extent at cpos %u which can no "
4758d0c7d708SMark Fasheh 			    "longer be found.\n",
4759d0c7d708SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos);
4760d0c7d708SMark Fasheh 		ret = -EROFS;
4761d0c7d708SMark Fasheh 		goto out;
4762d0c7d708SMark Fasheh 	}
4763d0c7d708SMark Fasheh 
4764d0c7d708SMark Fasheh 	/*
4765d0c7d708SMark Fasheh 	 * We have 3 cases of extent removal:
4766d0c7d708SMark Fasheh 	 *   1) Range covers the entire extent rec
4767d0c7d708SMark Fasheh 	 *   2) Range begins or ends on one edge of the extent rec
4768d0c7d708SMark Fasheh 	 *   3) Range is in the middle of the extent rec (no shared edges)
4769d0c7d708SMark Fasheh 	 *
4770d0c7d708SMark Fasheh 	 * For case 1 we remove the extent rec and left rotate to
4771d0c7d708SMark Fasheh 	 * fill the hole.
4772d0c7d708SMark Fasheh 	 *
4773d0c7d708SMark Fasheh 	 * For case 2 we just shrink the existing extent rec, with a
4774d0c7d708SMark Fasheh 	 * tree update if the shrinking edge is also the edge of an
4775d0c7d708SMark Fasheh 	 * extent block.
4776d0c7d708SMark Fasheh 	 *
4777d0c7d708SMark Fasheh 	 * For case 3 we do a right split to turn the extent rec into
4778d0c7d708SMark Fasheh 	 * something case 2 can handle.
4779d0c7d708SMark Fasheh 	 */
4780d0c7d708SMark Fasheh 	rec = &el->l_recs[index];
4781d0c7d708SMark Fasheh 	rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
4782d0c7d708SMark Fasheh 	trunc_range = cpos + len;
4783d0c7d708SMark Fasheh 
4784d0c7d708SMark Fasheh 	BUG_ON(cpos < le32_to_cpu(rec->e_cpos) || trunc_range > rec_range);
4785d0c7d708SMark Fasheh 
4786d0c7d708SMark Fasheh 	mlog(0, "Inode %llu, remove (cpos %u, len %u). Existing index %d "
4787d0c7d708SMark Fasheh 	     "(cpos %u, len %u)\n",
4788d0c7d708SMark Fasheh 	     (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos, len, index,
4789d0c7d708SMark Fasheh 	     le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec));
4790d0c7d708SMark Fasheh 
4791d0c7d708SMark Fasheh 	if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) {
4792d0c7d708SMark Fasheh 		ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc,
4793d0c7d708SMark Fasheh 					 cpos, len);
4794d0c7d708SMark Fasheh 		if (ret) {
4795d0c7d708SMark Fasheh 			mlog_errno(ret);
4796d0c7d708SMark Fasheh 			goto out;
4797d0c7d708SMark Fasheh 		}
4798d0c7d708SMark Fasheh 	} else {
4799d0c7d708SMark Fasheh 		ret = ocfs2_split_tree(inode, di_bh, handle, path, index,
4800d0c7d708SMark Fasheh 				       trunc_range, meta_ac);
4801d0c7d708SMark Fasheh 		if (ret) {
4802d0c7d708SMark Fasheh 			mlog_errno(ret);
4803d0c7d708SMark Fasheh 			goto out;
4804d0c7d708SMark Fasheh 		}
4805d0c7d708SMark Fasheh 
4806d0c7d708SMark Fasheh 		/*
4807d0c7d708SMark Fasheh 		 * The split could have manipulated the tree enough to
4808d0c7d708SMark Fasheh 		 * move the record location, so we have to look for it again.
4809d0c7d708SMark Fasheh 		 */
4810d0c7d708SMark Fasheh 		ocfs2_reinit_path(path, 1);
4811d0c7d708SMark Fasheh 
4812d0c7d708SMark Fasheh 		ret = ocfs2_find_path(inode, path, cpos);
4813d0c7d708SMark Fasheh 		if (ret) {
4814d0c7d708SMark Fasheh 			mlog_errno(ret);
4815d0c7d708SMark Fasheh 			goto out;
4816d0c7d708SMark Fasheh 		}
4817d0c7d708SMark Fasheh 
4818d0c7d708SMark Fasheh 		el = path_leaf_el(path);
4819d0c7d708SMark Fasheh 		index = ocfs2_search_extent_list(el, cpos);
4820d0c7d708SMark Fasheh 		if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
4821d0c7d708SMark Fasheh 			ocfs2_error(inode->i_sb,
4822d0c7d708SMark Fasheh 				    "Inode %llu: split at cpos %u lost record.",
4823d0c7d708SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno,
4824d0c7d708SMark Fasheh 				    cpos);
4825d0c7d708SMark Fasheh 			ret = -EROFS;
4826d0c7d708SMark Fasheh 			goto out;
4827d0c7d708SMark Fasheh 		}
4828d0c7d708SMark Fasheh 
4829d0c7d708SMark Fasheh 		/*
4830d0c7d708SMark Fasheh 		 * Double check our values here. If anything is fishy,
4831d0c7d708SMark Fasheh 		 * it's easier to catch it at the top level.
4832d0c7d708SMark Fasheh 		 */
4833d0c7d708SMark Fasheh 		rec = &el->l_recs[index];
4834d0c7d708SMark Fasheh 		rec_range = le32_to_cpu(rec->e_cpos) +
4835d0c7d708SMark Fasheh 			ocfs2_rec_clusters(el, rec);
4836d0c7d708SMark Fasheh 		if (rec_range != trunc_range) {
4837d0c7d708SMark Fasheh 			ocfs2_error(inode->i_sb,
4838d0c7d708SMark Fasheh 				    "Inode %llu: error after split at cpos %u"
4839d0c7d708SMark Fasheh 				    "trunc len %u, existing record is (%u,%u)",
4840d0c7d708SMark Fasheh 				    (unsigned long long)OCFS2_I(inode)->ip_blkno,
4841d0c7d708SMark Fasheh 				    cpos, len, le32_to_cpu(rec->e_cpos),
4842d0c7d708SMark Fasheh 				    ocfs2_rec_clusters(el, rec));
4843d0c7d708SMark Fasheh 			ret = -EROFS;
4844d0c7d708SMark Fasheh 			goto out;
4845d0c7d708SMark Fasheh 		}
4846d0c7d708SMark Fasheh 
4847d0c7d708SMark Fasheh 		ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc,
4848d0c7d708SMark Fasheh 					 cpos, len);
4849d0c7d708SMark Fasheh 		if (ret) {
4850d0c7d708SMark Fasheh 			mlog_errno(ret);
4851d0c7d708SMark Fasheh 			goto out;
4852d0c7d708SMark Fasheh 		}
4853d0c7d708SMark Fasheh 	}
4854d0c7d708SMark Fasheh 
4855d0c7d708SMark Fasheh out:
4856d0c7d708SMark Fasheh 	ocfs2_free_path(path);
4857d0c7d708SMark Fasheh 	return ret;
4858d0c7d708SMark Fasheh }
4859d0c7d708SMark Fasheh 
4860063c4561SMark Fasheh int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb)
4861ccd979bdSMark Fasheh {
4862ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = osb->osb_tl_bh;
4863ccd979bdSMark Fasheh 	struct ocfs2_dinode *di;
4864ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
4865ccd979bdSMark Fasheh 
4866ccd979bdSMark Fasheh 	di = (struct ocfs2_dinode *) tl_bh->b_data;
4867ccd979bdSMark Fasheh 	tl = &di->id2.i_dealloc;
4868ccd979bdSMark Fasheh 
4869ccd979bdSMark Fasheh 	mlog_bug_on_msg(le16_to_cpu(tl->tl_used) > le16_to_cpu(tl->tl_count),
4870ccd979bdSMark Fasheh 			"slot %d, invalid truncate log parameters: used = "
4871ccd979bdSMark Fasheh 			"%u, count = %u\n", osb->slot_num,
4872ccd979bdSMark Fasheh 			le16_to_cpu(tl->tl_used), le16_to_cpu(tl->tl_count));
4873ccd979bdSMark Fasheh 	return le16_to_cpu(tl->tl_used) == le16_to_cpu(tl->tl_count);
4874ccd979bdSMark Fasheh }
4875ccd979bdSMark Fasheh 
4876ccd979bdSMark Fasheh static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl,
4877ccd979bdSMark Fasheh 					   unsigned int new_start)
4878ccd979bdSMark Fasheh {
4879ccd979bdSMark Fasheh 	unsigned int tail_index;
4880ccd979bdSMark Fasheh 	unsigned int current_tail;
4881ccd979bdSMark Fasheh 
4882ccd979bdSMark Fasheh 	/* No records, nothing to coalesce */
4883ccd979bdSMark Fasheh 	if (!le16_to_cpu(tl->tl_used))
4884ccd979bdSMark Fasheh 		return 0;
4885ccd979bdSMark Fasheh 
4886ccd979bdSMark Fasheh 	tail_index = le16_to_cpu(tl->tl_used) - 1;
4887ccd979bdSMark Fasheh 	current_tail = le32_to_cpu(tl->tl_recs[tail_index].t_start);
4888ccd979bdSMark Fasheh 	current_tail += le32_to_cpu(tl->tl_recs[tail_index].t_clusters);
4889ccd979bdSMark Fasheh 
4890ccd979bdSMark Fasheh 	return current_tail == new_start;
4891ccd979bdSMark Fasheh }
4892ccd979bdSMark Fasheh 
4893063c4561SMark Fasheh int ocfs2_truncate_log_append(struct ocfs2_super *osb,
48941fabe148SMark Fasheh 			      handle_t *handle,
4895ccd979bdSMark Fasheh 			      u64 start_blk,
4896ccd979bdSMark Fasheh 			      unsigned int num_clusters)
4897ccd979bdSMark Fasheh {
4898ccd979bdSMark Fasheh 	int status, index;
4899ccd979bdSMark Fasheh 	unsigned int start_cluster, tl_count;
4900ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
4901ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = osb->osb_tl_bh;
4902ccd979bdSMark Fasheh 	struct ocfs2_dinode *di;
4903ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
4904ccd979bdSMark Fasheh 
4905b0697053SMark Fasheh 	mlog_entry("start_blk = %llu, num_clusters = %u\n",
4906b0697053SMark Fasheh 		   (unsigned long long)start_blk, num_clusters);
4907ccd979bdSMark Fasheh 
49081b1dcc1bSJes Sorensen 	BUG_ON(mutex_trylock(&tl_inode->i_mutex));
4909ccd979bdSMark Fasheh 
4910ccd979bdSMark Fasheh 	start_cluster = ocfs2_blocks_to_clusters(osb->sb, start_blk);
4911ccd979bdSMark Fasheh 
4912ccd979bdSMark Fasheh 	di = (struct ocfs2_dinode *) tl_bh->b_data;
4913ccd979bdSMark Fasheh 	tl = &di->id2.i_dealloc;
4914ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_DINODE(di)) {
4915ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_DINODE(osb->sb, di);
4916ccd979bdSMark Fasheh 		status = -EIO;
4917ccd979bdSMark Fasheh 		goto bail;
4918ccd979bdSMark Fasheh 	}
4919ccd979bdSMark Fasheh 
4920ccd979bdSMark Fasheh 	tl_count = le16_to_cpu(tl->tl_count);
4921ccd979bdSMark Fasheh 	mlog_bug_on_msg(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) ||
4922ccd979bdSMark Fasheh 			tl_count == 0,
4923b0697053SMark Fasheh 			"Truncate record count on #%llu invalid "
4924b0697053SMark Fasheh 			"wanted %u, actual %u\n",
4925b0697053SMark Fasheh 			(unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
4926ccd979bdSMark Fasheh 			ocfs2_truncate_recs_per_inode(osb->sb),
4927ccd979bdSMark Fasheh 			le16_to_cpu(tl->tl_count));
4928ccd979bdSMark Fasheh 
4929ccd979bdSMark Fasheh 	/* Caller should have known to flush before calling us. */
4930ccd979bdSMark Fasheh 	index = le16_to_cpu(tl->tl_used);
4931ccd979bdSMark Fasheh 	if (index >= tl_count) {
4932ccd979bdSMark Fasheh 		status = -ENOSPC;
4933ccd979bdSMark Fasheh 		mlog_errno(status);
4934ccd979bdSMark Fasheh 		goto bail;
4935ccd979bdSMark Fasheh 	}
4936ccd979bdSMark Fasheh 
4937ccd979bdSMark Fasheh 	status = ocfs2_journal_access(handle, tl_inode, tl_bh,
4938ccd979bdSMark Fasheh 				      OCFS2_JOURNAL_ACCESS_WRITE);
4939ccd979bdSMark Fasheh 	if (status < 0) {
4940ccd979bdSMark Fasheh 		mlog_errno(status);
4941ccd979bdSMark Fasheh 		goto bail;
4942ccd979bdSMark Fasheh 	}
4943ccd979bdSMark Fasheh 
4944ccd979bdSMark Fasheh 	mlog(0, "Log truncate of %u clusters starting at cluster %u to "
4945b0697053SMark Fasheh 	     "%llu (index = %d)\n", num_clusters, start_cluster,
4946b0697053SMark Fasheh 	     (unsigned long long)OCFS2_I(tl_inode)->ip_blkno, index);
4947ccd979bdSMark Fasheh 
4948ccd979bdSMark Fasheh 	if (ocfs2_truncate_log_can_coalesce(tl, start_cluster)) {
4949ccd979bdSMark Fasheh 		/*
4950ccd979bdSMark Fasheh 		 * Move index back to the record we are coalescing with.
4951ccd979bdSMark Fasheh 		 * ocfs2_truncate_log_can_coalesce() guarantees nonzero
4952ccd979bdSMark Fasheh 		 */
4953ccd979bdSMark Fasheh 		index--;
4954ccd979bdSMark Fasheh 
4955ccd979bdSMark Fasheh 		num_clusters += le32_to_cpu(tl->tl_recs[index].t_clusters);
4956ccd979bdSMark Fasheh 		mlog(0, "Coalesce with index %u (start = %u, clusters = %u)\n",
4957ccd979bdSMark Fasheh 		     index, le32_to_cpu(tl->tl_recs[index].t_start),
4958ccd979bdSMark Fasheh 		     num_clusters);
4959ccd979bdSMark Fasheh 	} else {
4960ccd979bdSMark Fasheh 		tl->tl_recs[index].t_start = cpu_to_le32(start_cluster);
4961ccd979bdSMark Fasheh 		tl->tl_used = cpu_to_le16(index + 1);
4962ccd979bdSMark Fasheh 	}
4963ccd979bdSMark Fasheh 	tl->tl_recs[index].t_clusters = cpu_to_le32(num_clusters);
4964ccd979bdSMark Fasheh 
4965ccd979bdSMark Fasheh 	status = ocfs2_journal_dirty(handle, tl_bh);
4966ccd979bdSMark Fasheh 	if (status < 0) {
4967ccd979bdSMark Fasheh 		mlog_errno(status);
4968ccd979bdSMark Fasheh 		goto bail;
4969ccd979bdSMark Fasheh 	}
4970ccd979bdSMark Fasheh 
4971ccd979bdSMark Fasheh bail:
4972ccd979bdSMark Fasheh 	mlog_exit(status);
4973ccd979bdSMark Fasheh 	return status;
4974ccd979bdSMark Fasheh }
4975ccd979bdSMark Fasheh 
4976ccd979bdSMark Fasheh static int ocfs2_replay_truncate_records(struct ocfs2_super *osb,
49771fabe148SMark Fasheh 					 handle_t *handle,
4978ccd979bdSMark Fasheh 					 struct inode *data_alloc_inode,
4979ccd979bdSMark Fasheh 					 struct buffer_head *data_alloc_bh)
4980ccd979bdSMark Fasheh {
4981ccd979bdSMark Fasheh 	int status = 0;
4982ccd979bdSMark Fasheh 	int i;
4983ccd979bdSMark Fasheh 	unsigned int num_clusters;
4984ccd979bdSMark Fasheh 	u64 start_blk;
4985ccd979bdSMark Fasheh 	struct ocfs2_truncate_rec rec;
4986ccd979bdSMark Fasheh 	struct ocfs2_dinode *di;
4987ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
4988ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
4989ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = osb->osb_tl_bh;
4990ccd979bdSMark Fasheh 
4991ccd979bdSMark Fasheh 	mlog_entry_void();
4992ccd979bdSMark Fasheh 
4993ccd979bdSMark Fasheh 	di = (struct ocfs2_dinode *) tl_bh->b_data;
4994ccd979bdSMark Fasheh 	tl = &di->id2.i_dealloc;
4995ccd979bdSMark Fasheh 	i = le16_to_cpu(tl->tl_used) - 1;
4996ccd979bdSMark Fasheh 	while (i >= 0) {
4997ccd979bdSMark Fasheh 		/* Caller has given us at least enough credits to
4998ccd979bdSMark Fasheh 		 * update the truncate log dinode */
4999ccd979bdSMark Fasheh 		status = ocfs2_journal_access(handle, tl_inode, tl_bh,
5000ccd979bdSMark Fasheh 					      OCFS2_JOURNAL_ACCESS_WRITE);
5001ccd979bdSMark Fasheh 		if (status < 0) {
5002ccd979bdSMark Fasheh 			mlog_errno(status);
5003ccd979bdSMark Fasheh 			goto bail;
5004ccd979bdSMark Fasheh 		}
5005ccd979bdSMark Fasheh 
5006ccd979bdSMark Fasheh 		tl->tl_used = cpu_to_le16(i);
5007ccd979bdSMark Fasheh 
5008ccd979bdSMark Fasheh 		status = ocfs2_journal_dirty(handle, tl_bh);
5009ccd979bdSMark Fasheh 		if (status < 0) {
5010ccd979bdSMark Fasheh 			mlog_errno(status);
5011ccd979bdSMark Fasheh 			goto bail;
5012ccd979bdSMark Fasheh 		}
5013ccd979bdSMark Fasheh 
5014ccd979bdSMark Fasheh 		/* TODO: Perhaps we can calculate the bulk of the
5015ccd979bdSMark Fasheh 		 * credits up front rather than extending like
5016ccd979bdSMark Fasheh 		 * this. */
5017ccd979bdSMark Fasheh 		status = ocfs2_extend_trans(handle,
5018ccd979bdSMark Fasheh 					    OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC);
5019ccd979bdSMark Fasheh 		if (status < 0) {
5020ccd979bdSMark Fasheh 			mlog_errno(status);
5021ccd979bdSMark Fasheh 			goto bail;
5022ccd979bdSMark Fasheh 		}
5023ccd979bdSMark Fasheh 
5024ccd979bdSMark Fasheh 		rec = tl->tl_recs[i];
5025ccd979bdSMark Fasheh 		start_blk = ocfs2_clusters_to_blocks(data_alloc_inode->i_sb,
5026ccd979bdSMark Fasheh 						    le32_to_cpu(rec.t_start));
5027ccd979bdSMark Fasheh 		num_clusters = le32_to_cpu(rec.t_clusters);
5028ccd979bdSMark Fasheh 
5029ccd979bdSMark Fasheh 		/* if start_blk is not set, we ignore the record as
5030ccd979bdSMark Fasheh 		 * invalid. */
5031ccd979bdSMark Fasheh 		if (start_blk) {
5032ccd979bdSMark Fasheh 			mlog(0, "free record %d, start = %u, clusters = %u\n",
5033ccd979bdSMark Fasheh 			     i, le32_to_cpu(rec.t_start), num_clusters);
5034ccd979bdSMark Fasheh 
5035ccd979bdSMark Fasheh 			status = ocfs2_free_clusters(handle, data_alloc_inode,
5036ccd979bdSMark Fasheh 						     data_alloc_bh, start_blk,
5037ccd979bdSMark Fasheh 						     num_clusters);
5038ccd979bdSMark Fasheh 			if (status < 0) {
5039ccd979bdSMark Fasheh 				mlog_errno(status);
5040ccd979bdSMark Fasheh 				goto bail;
5041ccd979bdSMark Fasheh 			}
5042ccd979bdSMark Fasheh 		}
5043ccd979bdSMark Fasheh 		i--;
5044ccd979bdSMark Fasheh 	}
5045ccd979bdSMark Fasheh 
5046ccd979bdSMark Fasheh bail:
5047ccd979bdSMark Fasheh 	mlog_exit(status);
5048ccd979bdSMark Fasheh 	return status;
5049ccd979bdSMark Fasheh }
5050ccd979bdSMark Fasheh 
50511b1dcc1bSJes Sorensen /* Expects you to already be holding tl_inode->i_mutex */
5052063c4561SMark Fasheh int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
5053ccd979bdSMark Fasheh {
5054ccd979bdSMark Fasheh 	int status;
5055ccd979bdSMark Fasheh 	unsigned int num_to_flush;
50561fabe148SMark Fasheh 	handle_t *handle;
5057ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
5058ccd979bdSMark Fasheh 	struct inode *data_alloc_inode = NULL;
5059ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = osb->osb_tl_bh;
5060ccd979bdSMark Fasheh 	struct buffer_head *data_alloc_bh = NULL;
5061ccd979bdSMark Fasheh 	struct ocfs2_dinode *di;
5062ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
5063ccd979bdSMark Fasheh 
5064ccd979bdSMark Fasheh 	mlog_entry_void();
5065ccd979bdSMark Fasheh 
50661b1dcc1bSJes Sorensen 	BUG_ON(mutex_trylock(&tl_inode->i_mutex));
5067ccd979bdSMark Fasheh 
5068ccd979bdSMark Fasheh 	di = (struct ocfs2_dinode *) tl_bh->b_data;
5069ccd979bdSMark Fasheh 	tl = &di->id2.i_dealloc;
5070ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_DINODE(di)) {
5071ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_DINODE(osb->sb, di);
5072ccd979bdSMark Fasheh 		status = -EIO;
5073e08dc8b9SMark Fasheh 		goto out;
5074ccd979bdSMark Fasheh 	}
5075ccd979bdSMark Fasheh 
5076ccd979bdSMark Fasheh 	num_to_flush = le16_to_cpu(tl->tl_used);
5077b0697053SMark Fasheh 	mlog(0, "Flush %u records from truncate log #%llu\n",
5078b0697053SMark Fasheh 	     num_to_flush, (unsigned long long)OCFS2_I(tl_inode)->ip_blkno);
5079ccd979bdSMark Fasheh 	if (!num_to_flush) {
5080ccd979bdSMark Fasheh 		status = 0;
5081e08dc8b9SMark Fasheh 		goto out;
5082ccd979bdSMark Fasheh 	}
5083ccd979bdSMark Fasheh 
5084ccd979bdSMark Fasheh 	data_alloc_inode = ocfs2_get_system_file_inode(osb,
5085ccd979bdSMark Fasheh 						       GLOBAL_BITMAP_SYSTEM_INODE,
5086ccd979bdSMark Fasheh 						       OCFS2_INVALID_SLOT);
5087ccd979bdSMark Fasheh 	if (!data_alloc_inode) {
5088ccd979bdSMark Fasheh 		status = -EINVAL;
5089ccd979bdSMark Fasheh 		mlog(ML_ERROR, "Could not get bitmap inode!\n");
5090e08dc8b9SMark Fasheh 		goto out;
5091ccd979bdSMark Fasheh 	}
5092ccd979bdSMark Fasheh 
5093e08dc8b9SMark Fasheh 	mutex_lock(&data_alloc_inode->i_mutex);
5094e08dc8b9SMark Fasheh 
5095e63aecb6SMark Fasheh 	status = ocfs2_inode_lock(data_alloc_inode, &data_alloc_bh, 1);
5096ccd979bdSMark Fasheh 	if (status < 0) {
5097ccd979bdSMark Fasheh 		mlog_errno(status);
5098e08dc8b9SMark Fasheh 		goto out_mutex;
5099ccd979bdSMark Fasheh 	}
5100ccd979bdSMark Fasheh 
510165eff9ccSMark Fasheh 	handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
5102ccd979bdSMark Fasheh 	if (IS_ERR(handle)) {
5103ccd979bdSMark Fasheh 		status = PTR_ERR(handle);
5104ccd979bdSMark Fasheh 		mlog_errno(status);
5105e08dc8b9SMark Fasheh 		goto out_unlock;
5106ccd979bdSMark Fasheh 	}
5107ccd979bdSMark Fasheh 
5108ccd979bdSMark Fasheh 	status = ocfs2_replay_truncate_records(osb, handle, data_alloc_inode,
5109ccd979bdSMark Fasheh 					       data_alloc_bh);
5110e08dc8b9SMark Fasheh 	if (status < 0)
5111ccd979bdSMark Fasheh 		mlog_errno(status);
5112ccd979bdSMark Fasheh 
511302dc1af4SMark Fasheh 	ocfs2_commit_trans(osb, handle);
5114ccd979bdSMark Fasheh 
5115e08dc8b9SMark Fasheh out_unlock:
5116e08dc8b9SMark Fasheh 	brelse(data_alloc_bh);
5117e63aecb6SMark Fasheh 	ocfs2_inode_unlock(data_alloc_inode, 1);
5118e08dc8b9SMark Fasheh 
5119e08dc8b9SMark Fasheh out_mutex:
5120e08dc8b9SMark Fasheh 	mutex_unlock(&data_alloc_inode->i_mutex);
5121ccd979bdSMark Fasheh 	iput(data_alloc_inode);
5122ccd979bdSMark Fasheh 
5123e08dc8b9SMark Fasheh out:
5124ccd979bdSMark Fasheh 	mlog_exit(status);
5125ccd979bdSMark Fasheh 	return status;
5126ccd979bdSMark Fasheh }
5127ccd979bdSMark Fasheh 
5128ccd979bdSMark Fasheh int ocfs2_flush_truncate_log(struct ocfs2_super *osb)
5129ccd979bdSMark Fasheh {
5130ccd979bdSMark Fasheh 	int status;
5131ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
5132ccd979bdSMark Fasheh 
51331b1dcc1bSJes Sorensen 	mutex_lock(&tl_inode->i_mutex);
5134ccd979bdSMark Fasheh 	status = __ocfs2_flush_truncate_log(osb);
51351b1dcc1bSJes Sorensen 	mutex_unlock(&tl_inode->i_mutex);
5136ccd979bdSMark Fasheh 
5137ccd979bdSMark Fasheh 	return status;
5138ccd979bdSMark Fasheh }
5139ccd979bdSMark Fasheh 
5140c4028958SDavid Howells static void ocfs2_truncate_log_worker(struct work_struct *work)
5141ccd979bdSMark Fasheh {
5142ccd979bdSMark Fasheh 	int status;
5143c4028958SDavid Howells 	struct ocfs2_super *osb =
5144c4028958SDavid Howells 		container_of(work, struct ocfs2_super,
5145c4028958SDavid Howells 			     osb_truncate_log_wq.work);
5146ccd979bdSMark Fasheh 
5147ccd979bdSMark Fasheh 	mlog_entry_void();
5148ccd979bdSMark Fasheh 
5149ccd979bdSMark Fasheh 	status = ocfs2_flush_truncate_log(osb);
5150ccd979bdSMark Fasheh 	if (status < 0)
5151ccd979bdSMark Fasheh 		mlog_errno(status);
51524d0ddb2cSTao Ma 	else
51534d0ddb2cSTao Ma 		ocfs2_init_inode_steal_slot(osb);
5154ccd979bdSMark Fasheh 
5155ccd979bdSMark Fasheh 	mlog_exit(status);
5156ccd979bdSMark Fasheh }
5157ccd979bdSMark Fasheh 
5158ccd979bdSMark Fasheh #define OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL (2 * HZ)
5159ccd979bdSMark Fasheh void ocfs2_schedule_truncate_log_flush(struct ocfs2_super *osb,
5160ccd979bdSMark Fasheh 				       int cancel)
5161ccd979bdSMark Fasheh {
5162ccd979bdSMark Fasheh 	if (osb->osb_tl_inode) {
5163ccd979bdSMark Fasheh 		/* We want to push off log flushes while truncates are
5164ccd979bdSMark Fasheh 		 * still running. */
5165ccd979bdSMark Fasheh 		if (cancel)
5166ccd979bdSMark Fasheh 			cancel_delayed_work(&osb->osb_truncate_log_wq);
5167ccd979bdSMark Fasheh 
5168ccd979bdSMark Fasheh 		queue_delayed_work(ocfs2_wq, &osb->osb_truncate_log_wq,
5169ccd979bdSMark Fasheh 				   OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL);
5170ccd979bdSMark Fasheh 	}
5171ccd979bdSMark Fasheh }
5172ccd979bdSMark Fasheh 
5173ccd979bdSMark Fasheh static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb,
5174ccd979bdSMark Fasheh 				       int slot_num,
5175ccd979bdSMark Fasheh 				       struct inode **tl_inode,
5176ccd979bdSMark Fasheh 				       struct buffer_head **tl_bh)
5177ccd979bdSMark Fasheh {
5178ccd979bdSMark Fasheh 	int status;
5179ccd979bdSMark Fasheh 	struct inode *inode = NULL;
5180ccd979bdSMark Fasheh 	struct buffer_head *bh = NULL;
5181ccd979bdSMark Fasheh 
5182ccd979bdSMark Fasheh 	inode = ocfs2_get_system_file_inode(osb,
5183ccd979bdSMark Fasheh 					   TRUNCATE_LOG_SYSTEM_INODE,
5184ccd979bdSMark Fasheh 					   slot_num);
5185ccd979bdSMark Fasheh 	if (!inode) {
5186ccd979bdSMark Fasheh 		status = -EINVAL;
5187ccd979bdSMark Fasheh 		mlog(ML_ERROR, "Could not get load truncate log inode!\n");
5188ccd979bdSMark Fasheh 		goto bail;
5189ccd979bdSMark Fasheh 	}
5190ccd979bdSMark Fasheh 
5191ccd979bdSMark Fasheh 	status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &bh,
5192ccd979bdSMark Fasheh 				  OCFS2_BH_CACHED, inode);
5193ccd979bdSMark Fasheh 	if (status < 0) {
5194ccd979bdSMark Fasheh 		iput(inode);
5195ccd979bdSMark Fasheh 		mlog_errno(status);
5196ccd979bdSMark Fasheh 		goto bail;
5197ccd979bdSMark Fasheh 	}
5198ccd979bdSMark Fasheh 
5199ccd979bdSMark Fasheh 	*tl_inode = inode;
5200ccd979bdSMark Fasheh 	*tl_bh    = bh;
5201ccd979bdSMark Fasheh bail:
5202ccd979bdSMark Fasheh 	mlog_exit(status);
5203ccd979bdSMark Fasheh 	return status;
5204ccd979bdSMark Fasheh }
5205ccd979bdSMark Fasheh 
5206ccd979bdSMark Fasheh /* called during the 1st stage of node recovery. we stamp a clean
5207ccd979bdSMark Fasheh  * truncate log and pass back a copy for processing later. if the
5208ccd979bdSMark Fasheh  * truncate log does not require processing, a *tl_copy is set to
5209ccd979bdSMark Fasheh  * NULL. */
5210ccd979bdSMark Fasheh int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
5211ccd979bdSMark Fasheh 				      int slot_num,
5212ccd979bdSMark Fasheh 				      struct ocfs2_dinode **tl_copy)
5213ccd979bdSMark Fasheh {
5214ccd979bdSMark Fasheh 	int status;
5215ccd979bdSMark Fasheh 	struct inode *tl_inode = NULL;
5216ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = NULL;
5217ccd979bdSMark Fasheh 	struct ocfs2_dinode *di;
5218ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
5219ccd979bdSMark Fasheh 
5220ccd979bdSMark Fasheh 	*tl_copy = NULL;
5221ccd979bdSMark Fasheh 
5222ccd979bdSMark Fasheh 	mlog(0, "recover truncate log from slot %d\n", slot_num);
5223ccd979bdSMark Fasheh 
5224ccd979bdSMark Fasheh 	status = ocfs2_get_truncate_log_info(osb, slot_num, &tl_inode, &tl_bh);
5225ccd979bdSMark Fasheh 	if (status < 0) {
5226ccd979bdSMark Fasheh 		mlog_errno(status);
5227ccd979bdSMark Fasheh 		goto bail;
5228ccd979bdSMark Fasheh 	}
5229ccd979bdSMark Fasheh 
5230ccd979bdSMark Fasheh 	di = (struct ocfs2_dinode *) tl_bh->b_data;
5231ccd979bdSMark Fasheh 	tl = &di->id2.i_dealloc;
5232ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_DINODE(di)) {
5233ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_DINODE(tl_inode->i_sb, di);
5234ccd979bdSMark Fasheh 		status = -EIO;
5235ccd979bdSMark Fasheh 		goto bail;
5236ccd979bdSMark Fasheh 	}
5237ccd979bdSMark Fasheh 
5238ccd979bdSMark Fasheh 	if (le16_to_cpu(tl->tl_used)) {
5239ccd979bdSMark Fasheh 		mlog(0, "We'll have %u logs to recover\n",
5240ccd979bdSMark Fasheh 		     le16_to_cpu(tl->tl_used));
5241ccd979bdSMark Fasheh 
5242ccd979bdSMark Fasheh 		*tl_copy = kmalloc(tl_bh->b_size, GFP_KERNEL);
5243ccd979bdSMark Fasheh 		if (!(*tl_copy)) {
5244ccd979bdSMark Fasheh 			status = -ENOMEM;
5245ccd979bdSMark Fasheh 			mlog_errno(status);
5246ccd979bdSMark Fasheh 			goto bail;
5247ccd979bdSMark Fasheh 		}
5248ccd979bdSMark Fasheh 
5249ccd979bdSMark Fasheh 		/* Assuming the write-out below goes well, this copy
5250ccd979bdSMark Fasheh 		 * will be passed back to recovery for processing. */
5251ccd979bdSMark Fasheh 		memcpy(*tl_copy, tl_bh->b_data, tl_bh->b_size);
5252ccd979bdSMark Fasheh 
5253ccd979bdSMark Fasheh 		/* All we need to do to clear the truncate log is set
5254ccd979bdSMark Fasheh 		 * tl_used. */
5255ccd979bdSMark Fasheh 		tl->tl_used = 0;
5256ccd979bdSMark Fasheh 
5257ccd979bdSMark Fasheh 		status = ocfs2_write_block(osb, tl_bh, tl_inode);
5258ccd979bdSMark Fasheh 		if (status < 0) {
5259ccd979bdSMark Fasheh 			mlog_errno(status);
5260ccd979bdSMark Fasheh 			goto bail;
5261ccd979bdSMark Fasheh 		}
5262ccd979bdSMark Fasheh 	}
5263ccd979bdSMark Fasheh 
5264ccd979bdSMark Fasheh bail:
5265ccd979bdSMark Fasheh 	if (tl_inode)
5266ccd979bdSMark Fasheh 		iput(tl_inode);
5267ccd979bdSMark Fasheh 	if (tl_bh)
5268ccd979bdSMark Fasheh 		brelse(tl_bh);
5269ccd979bdSMark Fasheh 
5270ccd979bdSMark Fasheh 	if (status < 0 && (*tl_copy)) {
5271ccd979bdSMark Fasheh 		kfree(*tl_copy);
5272ccd979bdSMark Fasheh 		*tl_copy = NULL;
5273ccd979bdSMark Fasheh 	}
5274ccd979bdSMark Fasheh 
5275ccd979bdSMark Fasheh 	mlog_exit(status);
5276ccd979bdSMark Fasheh 	return status;
5277ccd979bdSMark Fasheh }
5278ccd979bdSMark Fasheh 
5279ccd979bdSMark Fasheh int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
5280ccd979bdSMark Fasheh 					 struct ocfs2_dinode *tl_copy)
5281ccd979bdSMark Fasheh {
5282ccd979bdSMark Fasheh 	int status = 0;
5283ccd979bdSMark Fasheh 	int i;
5284ccd979bdSMark Fasheh 	unsigned int clusters, num_recs, start_cluster;
5285ccd979bdSMark Fasheh 	u64 start_blk;
52861fabe148SMark Fasheh 	handle_t *handle;
5287ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
5288ccd979bdSMark Fasheh 	struct ocfs2_truncate_log *tl;
5289ccd979bdSMark Fasheh 
5290ccd979bdSMark Fasheh 	mlog_entry_void();
5291ccd979bdSMark Fasheh 
5292ccd979bdSMark Fasheh 	if (OCFS2_I(tl_inode)->ip_blkno == le64_to_cpu(tl_copy->i_blkno)) {
5293ccd979bdSMark Fasheh 		mlog(ML_ERROR, "Asked to recover my own truncate log!\n");
5294ccd979bdSMark Fasheh 		return -EINVAL;
5295ccd979bdSMark Fasheh 	}
5296ccd979bdSMark Fasheh 
5297ccd979bdSMark Fasheh 	tl = &tl_copy->id2.i_dealloc;
5298ccd979bdSMark Fasheh 	num_recs = le16_to_cpu(tl->tl_used);
5299b0697053SMark Fasheh 	mlog(0, "cleanup %u records from %llu\n", num_recs,
53001ca1a111SMark Fasheh 	     (unsigned long long)le64_to_cpu(tl_copy->i_blkno));
5301ccd979bdSMark Fasheh 
53021b1dcc1bSJes Sorensen 	mutex_lock(&tl_inode->i_mutex);
5303ccd979bdSMark Fasheh 	for(i = 0; i < num_recs; i++) {
5304ccd979bdSMark Fasheh 		if (ocfs2_truncate_log_needs_flush(osb)) {
5305ccd979bdSMark Fasheh 			status = __ocfs2_flush_truncate_log(osb);
5306ccd979bdSMark Fasheh 			if (status < 0) {
5307ccd979bdSMark Fasheh 				mlog_errno(status);
5308ccd979bdSMark Fasheh 				goto bail_up;
5309ccd979bdSMark Fasheh 			}
5310ccd979bdSMark Fasheh 		}
5311ccd979bdSMark Fasheh 
531265eff9ccSMark Fasheh 		handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
5313ccd979bdSMark Fasheh 		if (IS_ERR(handle)) {
5314ccd979bdSMark Fasheh 			status = PTR_ERR(handle);
5315ccd979bdSMark Fasheh 			mlog_errno(status);
5316ccd979bdSMark Fasheh 			goto bail_up;
5317ccd979bdSMark Fasheh 		}
5318ccd979bdSMark Fasheh 
5319ccd979bdSMark Fasheh 		clusters = le32_to_cpu(tl->tl_recs[i].t_clusters);
5320ccd979bdSMark Fasheh 		start_cluster = le32_to_cpu(tl->tl_recs[i].t_start);
5321ccd979bdSMark Fasheh 		start_blk = ocfs2_clusters_to_blocks(osb->sb, start_cluster);
5322ccd979bdSMark Fasheh 
5323ccd979bdSMark Fasheh 		status = ocfs2_truncate_log_append(osb, handle,
5324ccd979bdSMark Fasheh 						   start_blk, clusters);
532502dc1af4SMark Fasheh 		ocfs2_commit_trans(osb, handle);
5326ccd979bdSMark Fasheh 		if (status < 0) {
5327ccd979bdSMark Fasheh 			mlog_errno(status);
5328ccd979bdSMark Fasheh 			goto bail_up;
5329ccd979bdSMark Fasheh 		}
5330ccd979bdSMark Fasheh 	}
5331ccd979bdSMark Fasheh 
5332ccd979bdSMark Fasheh bail_up:
53331b1dcc1bSJes Sorensen 	mutex_unlock(&tl_inode->i_mutex);
5334ccd979bdSMark Fasheh 
5335ccd979bdSMark Fasheh 	mlog_exit(status);
5336ccd979bdSMark Fasheh 	return status;
5337ccd979bdSMark Fasheh }
5338ccd979bdSMark Fasheh 
5339ccd979bdSMark Fasheh void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb)
5340ccd979bdSMark Fasheh {
5341ccd979bdSMark Fasheh 	int status;
5342ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
5343ccd979bdSMark Fasheh 
5344ccd979bdSMark Fasheh 	mlog_entry_void();
5345ccd979bdSMark Fasheh 
5346ccd979bdSMark Fasheh 	if (tl_inode) {
5347ccd979bdSMark Fasheh 		cancel_delayed_work(&osb->osb_truncate_log_wq);
5348ccd979bdSMark Fasheh 		flush_workqueue(ocfs2_wq);
5349ccd979bdSMark Fasheh 
5350ccd979bdSMark Fasheh 		status = ocfs2_flush_truncate_log(osb);
5351ccd979bdSMark Fasheh 		if (status < 0)
5352ccd979bdSMark Fasheh 			mlog_errno(status);
5353ccd979bdSMark Fasheh 
5354ccd979bdSMark Fasheh 		brelse(osb->osb_tl_bh);
5355ccd979bdSMark Fasheh 		iput(osb->osb_tl_inode);
5356ccd979bdSMark Fasheh 	}
5357ccd979bdSMark Fasheh 
5358ccd979bdSMark Fasheh 	mlog_exit_void();
5359ccd979bdSMark Fasheh }
5360ccd979bdSMark Fasheh 
5361ccd979bdSMark Fasheh int ocfs2_truncate_log_init(struct ocfs2_super *osb)
5362ccd979bdSMark Fasheh {
5363ccd979bdSMark Fasheh 	int status;
5364ccd979bdSMark Fasheh 	struct inode *tl_inode = NULL;
5365ccd979bdSMark Fasheh 	struct buffer_head *tl_bh = NULL;
5366ccd979bdSMark Fasheh 
5367ccd979bdSMark Fasheh 	mlog_entry_void();
5368ccd979bdSMark Fasheh 
5369ccd979bdSMark Fasheh 	status = ocfs2_get_truncate_log_info(osb,
5370ccd979bdSMark Fasheh 					     osb->slot_num,
5371ccd979bdSMark Fasheh 					     &tl_inode,
5372ccd979bdSMark Fasheh 					     &tl_bh);
5373ccd979bdSMark Fasheh 	if (status < 0)
5374ccd979bdSMark Fasheh 		mlog_errno(status);
5375ccd979bdSMark Fasheh 
5376ccd979bdSMark Fasheh 	/* ocfs2_truncate_log_shutdown keys on the existence of
5377ccd979bdSMark Fasheh 	 * osb->osb_tl_inode so we don't set any of the osb variables
5378ccd979bdSMark Fasheh 	 * until we're sure all is well. */
5379c4028958SDavid Howells 	INIT_DELAYED_WORK(&osb->osb_truncate_log_wq,
5380c4028958SDavid Howells 			  ocfs2_truncate_log_worker);
5381ccd979bdSMark Fasheh 	osb->osb_tl_bh    = tl_bh;
5382ccd979bdSMark Fasheh 	osb->osb_tl_inode = tl_inode;
5383ccd979bdSMark Fasheh 
5384ccd979bdSMark Fasheh 	mlog_exit(status);
5385ccd979bdSMark Fasheh 	return status;
5386ccd979bdSMark Fasheh }
5387ccd979bdSMark Fasheh 
53882b604351SMark Fasheh /*
53892b604351SMark Fasheh  * Delayed de-allocation of suballocator blocks.
53902b604351SMark Fasheh  *
53912b604351SMark Fasheh  * Some sets of block de-allocations might involve multiple suballocator inodes.
53922b604351SMark Fasheh  *
53932b604351SMark Fasheh  * The locking for this can get extremely complicated, especially when
53942b604351SMark Fasheh  * the suballocator inodes to delete from aren't known until deep
53952b604351SMark Fasheh  * within an unrelated codepath.
53962b604351SMark Fasheh  *
53972b604351SMark Fasheh  * ocfs2_extent_block structures are a good example of this - an inode
53982b604351SMark Fasheh  * btree could have been grown by any number of nodes each allocating
53992b604351SMark Fasheh  * out of their own suballoc inode.
54002b604351SMark Fasheh  *
54012b604351SMark Fasheh  * These structures allow the delay of block de-allocation until a
54022b604351SMark Fasheh  * later time, when locking of multiple cluster inodes won't cause
54032b604351SMark Fasheh  * deadlock.
54042b604351SMark Fasheh  */
54052b604351SMark Fasheh 
54062b604351SMark Fasheh /*
54072b604351SMark Fasheh  * Describes a single block free from a suballocator
54082b604351SMark Fasheh  */
54092b604351SMark Fasheh struct ocfs2_cached_block_free {
54102b604351SMark Fasheh 	struct ocfs2_cached_block_free		*free_next;
54112b604351SMark Fasheh 	u64					free_blk;
54122b604351SMark Fasheh 	unsigned int				free_bit;
54132b604351SMark Fasheh };
54142b604351SMark Fasheh 
54152b604351SMark Fasheh struct ocfs2_per_slot_free_list {
54162b604351SMark Fasheh 	struct ocfs2_per_slot_free_list		*f_next_suballocator;
54172b604351SMark Fasheh 	int					f_inode_type;
54182b604351SMark Fasheh 	int					f_slot;
54192b604351SMark Fasheh 	struct ocfs2_cached_block_free		*f_first;
54202b604351SMark Fasheh };
54212b604351SMark Fasheh 
54222b604351SMark Fasheh static int ocfs2_free_cached_items(struct ocfs2_super *osb,
54232b604351SMark Fasheh 				   int sysfile_type,
54242b604351SMark Fasheh 				   int slot,
54252b604351SMark Fasheh 				   struct ocfs2_cached_block_free *head)
54262b604351SMark Fasheh {
54272b604351SMark Fasheh 	int ret;
54282b604351SMark Fasheh 	u64 bg_blkno;
54292b604351SMark Fasheh 	handle_t *handle;
54302b604351SMark Fasheh 	struct inode *inode;
54312b604351SMark Fasheh 	struct buffer_head *di_bh = NULL;
54322b604351SMark Fasheh 	struct ocfs2_cached_block_free *tmp;
54332b604351SMark Fasheh 
54342b604351SMark Fasheh 	inode = ocfs2_get_system_file_inode(osb, sysfile_type, slot);
54352b604351SMark Fasheh 	if (!inode) {
54362b604351SMark Fasheh 		ret = -EINVAL;
54372b604351SMark Fasheh 		mlog_errno(ret);
54382b604351SMark Fasheh 		goto out;
54392b604351SMark Fasheh 	}
54402b604351SMark Fasheh 
54412b604351SMark Fasheh 	mutex_lock(&inode->i_mutex);
54422b604351SMark Fasheh 
5443e63aecb6SMark Fasheh 	ret = ocfs2_inode_lock(inode, &di_bh, 1);
54442b604351SMark Fasheh 	if (ret) {
54452b604351SMark Fasheh 		mlog_errno(ret);
54462b604351SMark Fasheh 		goto out_mutex;
54472b604351SMark Fasheh 	}
54482b604351SMark Fasheh 
54492b604351SMark Fasheh 	handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
54502b604351SMark Fasheh 	if (IS_ERR(handle)) {
54512b604351SMark Fasheh 		ret = PTR_ERR(handle);
54522b604351SMark Fasheh 		mlog_errno(ret);
54532b604351SMark Fasheh 		goto out_unlock;
54542b604351SMark Fasheh 	}
54552b604351SMark Fasheh 
54562b604351SMark Fasheh 	while (head) {
54572b604351SMark Fasheh 		bg_blkno = ocfs2_which_suballoc_group(head->free_blk,
54582b604351SMark Fasheh 						      head->free_bit);
54592b604351SMark Fasheh 		mlog(0, "Free bit: (bit %u, blkno %llu)\n",
54602b604351SMark Fasheh 		     head->free_bit, (unsigned long long)head->free_blk);
54612b604351SMark Fasheh 
54622b604351SMark Fasheh 		ret = ocfs2_free_suballoc_bits(handle, inode, di_bh,
54632b604351SMark Fasheh 					       head->free_bit, bg_blkno, 1);
54642b604351SMark Fasheh 		if (ret) {
54652b604351SMark Fasheh 			mlog_errno(ret);
54662b604351SMark Fasheh 			goto out_journal;
54672b604351SMark Fasheh 		}
54682b604351SMark Fasheh 
54692b604351SMark Fasheh 		ret = ocfs2_extend_trans(handle, OCFS2_SUBALLOC_FREE);
54702b604351SMark Fasheh 		if (ret) {
54712b604351SMark Fasheh 			mlog_errno(ret);
54722b604351SMark Fasheh 			goto out_journal;
54732b604351SMark Fasheh 		}
54742b604351SMark Fasheh 
54752b604351SMark Fasheh 		tmp = head;
54762b604351SMark Fasheh 		head = head->free_next;
54772b604351SMark Fasheh 		kfree(tmp);
54782b604351SMark Fasheh 	}
54792b604351SMark Fasheh 
54802b604351SMark Fasheh out_journal:
54812b604351SMark Fasheh 	ocfs2_commit_trans(osb, handle);
54822b604351SMark Fasheh 
54832b604351SMark Fasheh out_unlock:
5484e63aecb6SMark Fasheh 	ocfs2_inode_unlock(inode, 1);
54852b604351SMark Fasheh 	brelse(di_bh);
54862b604351SMark Fasheh out_mutex:
54872b604351SMark Fasheh 	mutex_unlock(&inode->i_mutex);
54882b604351SMark Fasheh 	iput(inode);
54892b604351SMark Fasheh out:
54902b604351SMark Fasheh 	while(head) {
54912b604351SMark Fasheh 		/* Premature exit may have left some dangling items. */
54922b604351SMark Fasheh 		tmp = head;
54932b604351SMark Fasheh 		head = head->free_next;
54942b604351SMark Fasheh 		kfree(tmp);
54952b604351SMark Fasheh 	}
54962b604351SMark Fasheh 
54972b604351SMark Fasheh 	return ret;
54982b604351SMark Fasheh }
54992b604351SMark Fasheh 
55002b604351SMark Fasheh int ocfs2_run_deallocs(struct ocfs2_super *osb,
55012b604351SMark Fasheh 		       struct ocfs2_cached_dealloc_ctxt *ctxt)
55022b604351SMark Fasheh {
55032b604351SMark Fasheh 	int ret = 0, ret2;
55042b604351SMark Fasheh 	struct ocfs2_per_slot_free_list *fl;
55052b604351SMark Fasheh 
55062b604351SMark Fasheh 	if (!ctxt)
55072b604351SMark Fasheh 		return 0;
55082b604351SMark Fasheh 
55092b604351SMark Fasheh 	while (ctxt->c_first_suballocator) {
55102b604351SMark Fasheh 		fl = ctxt->c_first_suballocator;
55112b604351SMark Fasheh 
55122b604351SMark Fasheh 		if (fl->f_first) {
55132b604351SMark Fasheh 			mlog(0, "Free items: (type %u, slot %d)\n",
55142b604351SMark Fasheh 			     fl->f_inode_type, fl->f_slot);
55152b604351SMark Fasheh 			ret2 = ocfs2_free_cached_items(osb, fl->f_inode_type,
55162b604351SMark Fasheh 						       fl->f_slot, fl->f_first);
55172b604351SMark Fasheh 			if (ret2)
55182b604351SMark Fasheh 				mlog_errno(ret2);
55192b604351SMark Fasheh 			if (!ret)
55202b604351SMark Fasheh 				ret = ret2;
55212b604351SMark Fasheh 		}
55222b604351SMark Fasheh 
55232b604351SMark Fasheh 		ctxt->c_first_suballocator = fl->f_next_suballocator;
55242b604351SMark Fasheh 		kfree(fl);
55252b604351SMark Fasheh 	}
55262b604351SMark Fasheh 
55272b604351SMark Fasheh 	return ret;
55282b604351SMark Fasheh }
55292b604351SMark Fasheh 
55302b604351SMark Fasheh static struct ocfs2_per_slot_free_list *
55312b604351SMark Fasheh ocfs2_find_per_slot_free_list(int type,
55322b604351SMark Fasheh 			      int slot,
55332b604351SMark Fasheh 			      struct ocfs2_cached_dealloc_ctxt *ctxt)
55342b604351SMark Fasheh {
55352b604351SMark Fasheh 	struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
55362b604351SMark Fasheh 
55372b604351SMark Fasheh 	while (fl) {
55382b604351SMark Fasheh 		if (fl->f_inode_type == type && fl->f_slot == slot)
55392b604351SMark Fasheh 			return fl;
55402b604351SMark Fasheh 
55412b604351SMark Fasheh 		fl = fl->f_next_suballocator;
55422b604351SMark Fasheh 	}
55432b604351SMark Fasheh 
55442b604351SMark Fasheh 	fl = kmalloc(sizeof(*fl), GFP_NOFS);
55452b604351SMark Fasheh 	if (fl) {
55462b604351SMark Fasheh 		fl->f_inode_type = type;
55472b604351SMark Fasheh 		fl->f_slot = slot;
55482b604351SMark Fasheh 		fl->f_first = NULL;
55492b604351SMark Fasheh 		fl->f_next_suballocator = ctxt->c_first_suballocator;
55502b604351SMark Fasheh 
55512b604351SMark Fasheh 		ctxt->c_first_suballocator = fl;
55522b604351SMark Fasheh 	}
55532b604351SMark Fasheh 	return fl;
55542b604351SMark Fasheh }
55552b604351SMark Fasheh 
55562b604351SMark Fasheh static int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
55572b604351SMark Fasheh 				     int type, int slot, u64 blkno,
55582b604351SMark Fasheh 				     unsigned int bit)
55592b604351SMark Fasheh {
55602b604351SMark Fasheh 	int ret;
55612b604351SMark Fasheh 	struct ocfs2_per_slot_free_list *fl;
55622b604351SMark Fasheh 	struct ocfs2_cached_block_free *item;
55632b604351SMark Fasheh 
55642b604351SMark Fasheh 	fl = ocfs2_find_per_slot_free_list(type, slot, ctxt);
55652b604351SMark Fasheh 	if (fl == NULL) {
55662b604351SMark Fasheh 		ret = -ENOMEM;
55672b604351SMark Fasheh 		mlog_errno(ret);
55682b604351SMark Fasheh 		goto out;
55692b604351SMark Fasheh 	}
55702b604351SMark Fasheh 
55712b604351SMark Fasheh 	item = kmalloc(sizeof(*item), GFP_NOFS);
55722b604351SMark Fasheh 	if (item == NULL) {
55732b604351SMark Fasheh 		ret = -ENOMEM;
55742b604351SMark Fasheh 		mlog_errno(ret);
55752b604351SMark Fasheh 		goto out;
55762b604351SMark Fasheh 	}
55772b604351SMark Fasheh 
55782b604351SMark Fasheh 	mlog(0, "Insert: (type %d, slot %u, bit %u, blk %llu)\n",
55792b604351SMark Fasheh 	     type, slot, bit, (unsigned long long)blkno);
55802b604351SMark Fasheh 
55812b604351SMark Fasheh 	item->free_blk = blkno;
55822b604351SMark Fasheh 	item->free_bit = bit;
55832b604351SMark Fasheh 	item->free_next = fl->f_first;
55842b604351SMark Fasheh 
55852b604351SMark Fasheh 	fl->f_first = item;
55862b604351SMark Fasheh 
55872b604351SMark Fasheh 	ret = 0;
55882b604351SMark Fasheh out:
55892b604351SMark Fasheh 	return ret;
55902b604351SMark Fasheh }
55912b604351SMark Fasheh 
559259a5e416SMark Fasheh static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
559359a5e416SMark Fasheh 					 struct ocfs2_extent_block *eb)
559459a5e416SMark Fasheh {
559559a5e416SMark Fasheh 	return ocfs2_cache_block_dealloc(ctxt, EXTENT_ALLOC_SYSTEM_INODE,
559659a5e416SMark Fasheh 					 le16_to_cpu(eb->h_suballoc_slot),
559759a5e416SMark Fasheh 					 le64_to_cpu(eb->h_blkno),
559859a5e416SMark Fasheh 					 le16_to_cpu(eb->h_suballoc_bit));
559959a5e416SMark Fasheh }
560059a5e416SMark Fasheh 
5601ccd979bdSMark Fasheh /* This function will figure out whether the currently last extent
5602ccd979bdSMark Fasheh  * block will be deleted, and if it will, what the new last extent
5603ccd979bdSMark Fasheh  * block will be so we can update his h_next_leaf_blk field, as well
5604ccd979bdSMark Fasheh  * as the dinodes i_last_eb_blk */
5605dcd0538fSMark Fasheh static int ocfs2_find_new_last_ext_blk(struct inode *inode,
56063a0782d0SMark Fasheh 				       unsigned int clusters_to_del,
5607dcd0538fSMark Fasheh 				       struct ocfs2_path *path,
5608ccd979bdSMark Fasheh 				       struct buffer_head **new_last_eb)
5609ccd979bdSMark Fasheh {
56103a0782d0SMark Fasheh 	int next_free, ret = 0;
5611dcd0538fSMark Fasheh 	u32 cpos;
56123a0782d0SMark Fasheh 	struct ocfs2_extent_rec *rec;
5613ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
5614ccd979bdSMark Fasheh 	struct ocfs2_extent_list *el;
5615ccd979bdSMark Fasheh 	struct buffer_head *bh = NULL;
5616ccd979bdSMark Fasheh 
5617ccd979bdSMark Fasheh 	*new_last_eb = NULL;
5618ccd979bdSMark Fasheh 
5619ccd979bdSMark Fasheh 	/* we have no tree, so of course, no last_eb. */
5620dcd0538fSMark Fasheh 	if (!path->p_tree_depth)
5621dcd0538fSMark Fasheh 		goto out;
5622ccd979bdSMark Fasheh 
5623ccd979bdSMark Fasheh 	/* trunc to zero special case - this makes tree_depth = 0
5624ccd979bdSMark Fasheh 	 * regardless of what it is.  */
56253a0782d0SMark Fasheh 	if (OCFS2_I(inode)->ip_clusters == clusters_to_del)
5626dcd0538fSMark Fasheh 		goto out;
5627ccd979bdSMark Fasheh 
5628dcd0538fSMark Fasheh 	el = path_leaf_el(path);
5629ccd979bdSMark Fasheh 	BUG_ON(!el->l_next_free_rec);
5630ccd979bdSMark Fasheh 
56313a0782d0SMark Fasheh 	/*
56323a0782d0SMark Fasheh 	 * Make sure that this extent list will actually be empty
56333a0782d0SMark Fasheh 	 * after we clear away the data. We can shortcut out if
56343a0782d0SMark Fasheh 	 * there's more than one non-empty extent in the
56353a0782d0SMark Fasheh 	 * list. Otherwise, a check of the remaining extent is
56363a0782d0SMark Fasheh 	 * necessary.
56373a0782d0SMark Fasheh 	 */
56383a0782d0SMark Fasheh 	next_free = le16_to_cpu(el->l_next_free_rec);
56393a0782d0SMark Fasheh 	rec = NULL;
5640dcd0538fSMark Fasheh 	if (ocfs2_is_empty_extent(&el->l_recs[0])) {
56413a0782d0SMark Fasheh 		if (next_free > 2)
5642dcd0538fSMark Fasheh 			goto out;
56433a0782d0SMark Fasheh 
56443a0782d0SMark Fasheh 		/* We may have a valid extent in index 1, check it. */
56453a0782d0SMark Fasheh 		if (next_free == 2)
56463a0782d0SMark Fasheh 			rec = &el->l_recs[1];
56473a0782d0SMark Fasheh 
56483a0782d0SMark Fasheh 		/*
56493a0782d0SMark Fasheh 		 * Fall through - no more nonempty extents, so we want
56503a0782d0SMark Fasheh 		 * to delete this leaf.
56513a0782d0SMark Fasheh 		 */
56523a0782d0SMark Fasheh 	} else {
56533a0782d0SMark Fasheh 		if (next_free > 1)
5654dcd0538fSMark Fasheh 			goto out;
5655ccd979bdSMark Fasheh 
56563a0782d0SMark Fasheh 		rec = &el->l_recs[0];
56573a0782d0SMark Fasheh 	}
56583a0782d0SMark Fasheh 
56593a0782d0SMark Fasheh 	if (rec) {
56603a0782d0SMark Fasheh 		/*
56613a0782d0SMark Fasheh 		 * Check it we'll only be trimming off the end of this
56623a0782d0SMark Fasheh 		 * cluster.
56633a0782d0SMark Fasheh 		 */
5664e48edee2SMark Fasheh 		if (le16_to_cpu(rec->e_leaf_clusters) > clusters_to_del)
56653a0782d0SMark Fasheh 			goto out;
56663a0782d0SMark Fasheh 	}
56673a0782d0SMark Fasheh 
5668dcd0538fSMark Fasheh 	ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, &cpos);
5669dcd0538fSMark Fasheh 	if (ret) {
5670dcd0538fSMark Fasheh 		mlog_errno(ret);
5671dcd0538fSMark Fasheh 		goto out;
5672ccd979bdSMark Fasheh 	}
5673ccd979bdSMark Fasheh 
5674dcd0538fSMark Fasheh 	ret = ocfs2_find_leaf(inode, path_root_el(path), cpos, &bh);
5675dcd0538fSMark Fasheh 	if (ret) {
5676dcd0538fSMark Fasheh 		mlog_errno(ret);
5677dcd0538fSMark Fasheh 		goto out;
5678ccd979bdSMark Fasheh 	}
5679dcd0538fSMark Fasheh 
5680ccd979bdSMark Fasheh 	eb = (struct ocfs2_extent_block *) bh->b_data;
5681ccd979bdSMark Fasheh 	el = &eb->h_list;
5682ccd979bdSMark Fasheh 	if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
5683ccd979bdSMark Fasheh 		OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
5684dcd0538fSMark Fasheh 		ret = -EROFS;
5685dcd0538fSMark Fasheh 		goto out;
5686ccd979bdSMark Fasheh 	}
5687ccd979bdSMark Fasheh 
5688ccd979bdSMark Fasheh 	*new_last_eb = bh;
5689ccd979bdSMark Fasheh 	get_bh(*new_last_eb);
5690dcd0538fSMark Fasheh 	mlog(0, "returning block %llu, (cpos: %u)\n",
5691dcd0538fSMark Fasheh 	     (unsigned long long)le64_to_cpu(eb->h_blkno), cpos);
5692dcd0538fSMark Fasheh out:
5693ccd979bdSMark Fasheh 	brelse(bh);
5694ccd979bdSMark Fasheh 
5695dcd0538fSMark Fasheh 	return ret;
5696ccd979bdSMark Fasheh }
5697ccd979bdSMark Fasheh 
56983a0782d0SMark Fasheh /*
56993a0782d0SMark Fasheh  * Trim some clusters off the rightmost edge of a tree. Only called
57003a0782d0SMark Fasheh  * during truncate.
57013a0782d0SMark Fasheh  *
57023a0782d0SMark Fasheh  * The caller needs to:
57033a0782d0SMark Fasheh  *   - start journaling of each path component.
57043a0782d0SMark Fasheh  *   - compute and fully set up any new last ext block
57053a0782d0SMark Fasheh  */
57063a0782d0SMark Fasheh static int ocfs2_trim_tree(struct inode *inode, struct ocfs2_path *path,
57073a0782d0SMark Fasheh 			   handle_t *handle, struct ocfs2_truncate_context *tc,
57083a0782d0SMark Fasheh 			   u32 clusters_to_del, u64 *delete_start)
57093a0782d0SMark Fasheh {
57103a0782d0SMark Fasheh 	int ret, i, index = path->p_tree_depth;
57113a0782d0SMark Fasheh 	u32 new_edge = 0;
57123a0782d0SMark Fasheh 	u64 deleted_eb = 0;
57133a0782d0SMark Fasheh 	struct buffer_head *bh;
57143a0782d0SMark Fasheh 	struct ocfs2_extent_list *el;
57153a0782d0SMark Fasheh 	struct ocfs2_extent_rec *rec;
57163a0782d0SMark Fasheh 
57173a0782d0SMark Fasheh 	*delete_start = 0;
57183a0782d0SMark Fasheh 
57193a0782d0SMark Fasheh 	while (index >= 0) {
57203a0782d0SMark Fasheh 		bh = path->p_node[index].bh;
57213a0782d0SMark Fasheh 		el = path->p_node[index].el;
57223a0782d0SMark Fasheh 
57233a0782d0SMark Fasheh 		mlog(0, "traveling tree (index = %d, block = %llu)\n",
57243a0782d0SMark Fasheh 		     index,  (unsigned long long)bh->b_blocknr);
57253a0782d0SMark Fasheh 
57263a0782d0SMark Fasheh 		BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
57273a0782d0SMark Fasheh 
57283a0782d0SMark Fasheh 		if (index !=
57293a0782d0SMark Fasheh 		    (path->p_tree_depth - le16_to_cpu(el->l_tree_depth))) {
57303a0782d0SMark Fasheh 			ocfs2_error(inode->i_sb,
57313a0782d0SMark Fasheh 				    "Inode %lu has invalid ext. block %llu",
57323a0782d0SMark Fasheh 				    inode->i_ino,
57333a0782d0SMark Fasheh 				    (unsigned long long)bh->b_blocknr);
57343a0782d0SMark Fasheh 			ret = -EROFS;
57353a0782d0SMark Fasheh 			goto out;
57363a0782d0SMark Fasheh 		}
57373a0782d0SMark Fasheh 
57383a0782d0SMark Fasheh find_tail_record:
57393a0782d0SMark Fasheh 		i = le16_to_cpu(el->l_next_free_rec) - 1;
57403a0782d0SMark Fasheh 		rec = &el->l_recs[i];
57413a0782d0SMark Fasheh 
57423a0782d0SMark Fasheh 		mlog(0, "Extent list before: record %d: (%u, %u, %llu), "
57433a0782d0SMark Fasheh 		     "next = %u\n", i, le32_to_cpu(rec->e_cpos),
5744e48edee2SMark Fasheh 		     ocfs2_rec_clusters(el, rec),
57453a0782d0SMark Fasheh 		     (unsigned long long)le64_to_cpu(rec->e_blkno),
57463a0782d0SMark Fasheh 		     le16_to_cpu(el->l_next_free_rec));
57473a0782d0SMark Fasheh 
5748e48edee2SMark Fasheh 		BUG_ON(ocfs2_rec_clusters(el, rec) < clusters_to_del);
57493a0782d0SMark Fasheh 
57503a0782d0SMark Fasheh 		if (le16_to_cpu(el->l_tree_depth) == 0) {
57513a0782d0SMark Fasheh 			/*
57523a0782d0SMark Fasheh 			 * If the leaf block contains a single empty
57533a0782d0SMark Fasheh 			 * extent and no records, we can just remove
57543a0782d0SMark Fasheh 			 * the block.
57553a0782d0SMark Fasheh 			 */
57563a0782d0SMark Fasheh 			if (i == 0 && ocfs2_is_empty_extent(rec)) {
57573a0782d0SMark Fasheh 				memset(rec, 0,
57583a0782d0SMark Fasheh 				       sizeof(struct ocfs2_extent_rec));
57593a0782d0SMark Fasheh 				el->l_next_free_rec = cpu_to_le16(0);
57603a0782d0SMark Fasheh 
57613a0782d0SMark Fasheh 				goto delete;
57623a0782d0SMark Fasheh 			}
57633a0782d0SMark Fasheh 
57643a0782d0SMark Fasheh 			/*
57653a0782d0SMark Fasheh 			 * Remove any empty extents by shifting things
57663a0782d0SMark Fasheh 			 * left. That should make life much easier on
57673a0782d0SMark Fasheh 			 * the code below. This condition is rare
57683a0782d0SMark Fasheh 			 * enough that we shouldn't see a performance
57693a0782d0SMark Fasheh 			 * hit.
57703a0782d0SMark Fasheh 			 */
57713a0782d0SMark Fasheh 			if (ocfs2_is_empty_extent(&el->l_recs[0])) {
57723a0782d0SMark Fasheh 				le16_add_cpu(&el->l_next_free_rec, -1);
57733a0782d0SMark Fasheh 
57743a0782d0SMark Fasheh 				for(i = 0;
57753a0782d0SMark Fasheh 				    i < le16_to_cpu(el->l_next_free_rec); i++)
57763a0782d0SMark Fasheh 					el->l_recs[i] = el->l_recs[i + 1];
57773a0782d0SMark Fasheh 
57783a0782d0SMark Fasheh 				memset(&el->l_recs[i], 0,
57793a0782d0SMark Fasheh 				       sizeof(struct ocfs2_extent_rec));
57803a0782d0SMark Fasheh 
57813a0782d0SMark Fasheh 				/*
57823a0782d0SMark Fasheh 				 * We've modified our extent list. The
57833a0782d0SMark Fasheh 				 * simplest way to handle this change
57843a0782d0SMark Fasheh 				 * is to being the search from the
57853a0782d0SMark Fasheh 				 * start again.
57863a0782d0SMark Fasheh 				 */
57873a0782d0SMark Fasheh 				goto find_tail_record;
57883a0782d0SMark Fasheh 			}
57893a0782d0SMark Fasheh 
5790e48edee2SMark Fasheh 			le16_add_cpu(&rec->e_leaf_clusters, -clusters_to_del);
57913a0782d0SMark Fasheh 
57923a0782d0SMark Fasheh 			/*
57933a0782d0SMark Fasheh 			 * We'll use "new_edge" on our way back up the
57943a0782d0SMark Fasheh 			 * tree to know what our rightmost cpos is.
57953a0782d0SMark Fasheh 			 */
5796e48edee2SMark Fasheh 			new_edge = le16_to_cpu(rec->e_leaf_clusters);
57973a0782d0SMark Fasheh 			new_edge += le32_to_cpu(rec->e_cpos);
57983a0782d0SMark Fasheh 
57993a0782d0SMark Fasheh 			/*
58003a0782d0SMark Fasheh 			 * The caller will use this to delete data blocks.
58013a0782d0SMark Fasheh 			 */
58023a0782d0SMark Fasheh 			*delete_start = le64_to_cpu(rec->e_blkno)
58033a0782d0SMark Fasheh 				+ ocfs2_clusters_to_blocks(inode->i_sb,
5804e48edee2SMark Fasheh 					le16_to_cpu(rec->e_leaf_clusters));
58053a0782d0SMark Fasheh 
58063a0782d0SMark Fasheh 			/*
58073a0782d0SMark Fasheh 			 * If it's now empty, remove this record.
58083a0782d0SMark Fasheh 			 */
5809e48edee2SMark Fasheh 			if (le16_to_cpu(rec->e_leaf_clusters) == 0) {
58103a0782d0SMark Fasheh 				memset(rec, 0,
58113a0782d0SMark Fasheh 				       sizeof(struct ocfs2_extent_rec));
58123a0782d0SMark Fasheh 				le16_add_cpu(&el->l_next_free_rec, -1);
58133a0782d0SMark Fasheh 			}
58143a0782d0SMark Fasheh 		} else {
58153a0782d0SMark Fasheh 			if (le64_to_cpu(rec->e_blkno) == deleted_eb) {
58163a0782d0SMark Fasheh 				memset(rec, 0,
58173a0782d0SMark Fasheh 				       sizeof(struct ocfs2_extent_rec));
58183a0782d0SMark Fasheh 				le16_add_cpu(&el->l_next_free_rec, -1);
58193a0782d0SMark Fasheh 
58203a0782d0SMark Fasheh 				goto delete;
58213a0782d0SMark Fasheh 			}
58223a0782d0SMark Fasheh 
58233a0782d0SMark Fasheh 			/* Can this actually happen? */
58243a0782d0SMark Fasheh 			if (le16_to_cpu(el->l_next_free_rec) == 0)
58253a0782d0SMark Fasheh 				goto delete;
58263a0782d0SMark Fasheh 
58273a0782d0SMark Fasheh 			/*
58283a0782d0SMark Fasheh 			 * We never actually deleted any clusters
58293a0782d0SMark Fasheh 			 * because our leaf was empty. There's no
58303a0782d0SMark Fasheh 			 * reason to adjust the rightmost edge then.
58313a0782d0SMark Fasheh 			 */
58323a0782d0SMark Fasheh 			if (new_edge == 0)
58333a0782d0SMark Fasheh 				goto delete;
58343a0782d0SMark Fasheh 
5835e48edee2SMark Fasheh 			rec->e_int_clusters = cpu_to_le32(new_edge);
5836e48edee2SMark Fasheh 			le32_add_cpu(&rec->e_int_clusters,
58373a0782d0SMark Fasheh 				     -le32_to_cpu(rec->e_cpos));
58383a0782d0SMark Fasheh 
58393a0782d0SMark Fasheh 			 /*
58403a0782d0SMark Fasheh 			  * A deleted child record should have been
58413a0782d0SMark Fasheh 			  * caught above.
58423a0782d0SMark Fasheh 			  */
5843e48edee2SMark Fasheh 			 BUG_ON(le32_to_cpu(rec->e_int_clusters) == 0);
58443a0782d0SMark Fasheh 		}
58453a0782d0SMark Fasheh 
58463a0782d0SMark Fasheh delete:
58473a0782d0SMark Fasheh 		ret = ocfs2_journal_dirty(handle, bh);
58483a0782d0SMark Fasheh 		if (ret) {
58493a0782d0SMark Fasheh 			mlog_errno(ret);
58503a0782d0SMark Fasheh 			goto out;
58513a0782d0SMark Fasheh 		}
58523a0782d0SMark Fasheh 
58533a0782d0SMark Fasheh 		mlog(0, "extent list container %llu, after: record %d: "
58543a0782d0SMark Fasheh 		     "(%u, %u, %llu), next = %u.\n",
58553a0782d0SMark Fasheh 		     (unsigned long long)bh->b_blocknr, i,
5856e48edee2SMark Fasheh 		     le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec),
58573a0782d0SMark Fasheh 		     (unsigned long long)le64_to_cpu(rec->e_blkno),
58583a0782d0SMark Fasheh 		     le16_to_cpu(el->l_next_free_rec));
58593a0782d0SMark Fasheh 
58603a0782d0SMark Fasheh 		/*
58613a0782d0SMark Fasheh 		 * We must be careful to only attempt delete of an
58623a0782d0SMark Fasheh 		 * extent block (and not the root inode block).
58633a0782d0SMark Fasheh 		 */
58643a0782d0SMark Fasheh 		if (index > 0 && le16_to_cpu(el->l_next_free_rec) == 0) {
58653a0782d0SMark Fasheh 			struct ocfs2_extent_block *eb =
58663a0782d0SMark Fasheh 				(struct ocfs2_extent_block *)bh->b_data;
58673a0782d0SMark Fasheh 
58683a0782d0SMark Fasheh 			/*
58693a0782d0SMark Fasheh 			 * Save this for use when processing the
58703a0782d0SMark Fasheh 			 * parent block.
58713a0782d0SMark Fasheh 			 */
58723a0782d0SMark Fasheh 			deleted_eb = le64_to_cpu(eb->h_blkno);
58733a0782d0SMark Fasheh 
58743a0782d0SMark Fasheh 			mlog(0, "deleting this extent block.\n");
58753a0782d0SMark Fasheh 
58763a0782d0SMark Fasheh 			ocfs2_remove_from_cache(inode, bh);
58773a0782d0SMark Fasheh 
5878e48edee2SMark Fasheh 			BUG_ON(ocfs2_rec_clusters(el, &el->l_recs[0]));
58793a0782d0SMark Fasheh 			BUG_ON(le32_to_cpu(el->l_recs[0].e_cpos));
58803a0782d0SMark Fasheh 			BUG_ON(le64_to_cpu(el->l_recs[0].e_blkno));
58813a0782d0SMark Fasheh 
588259a5e416SMark Fasheh 			ret = ocfs2_cache_extent_block_free(&tc->tc_dealloc, eb);
58833a0782d0SMark Fasheh 			/* An error here is not fatal. */
58843a0782d0SMark Fasheh 			if (ret < 0)
58853a0782d0SMark Fasheh 				mlog_errno(ret);
58863a0782d0SMark Fasheh 		} else {
58873a0782d0SMark Fasheh 			deleted_eb = 0;
58883a0782d0SMark Fasheh 		}
58893a0782d0SMark Fasheh 
58903a0782d0SMark Fasheh 		index--;
58913a0782d0SMark Fasheh 	}
58923a0782d0SMark Fasheh 
58933a0782d0SMark Fasheh 	ret = 0;
58943a0782d0SMark Fasheh out:
58953a0782d0SMark Fasheh 	return ret;
58963a0782d0SMark Fasheh }
58973a0782d0SMark Fasheh 
5898ccd979bdSMark Fasheh static int ocfs2_do_truncate(struct ocfs2_super *osb,
5899ccd979bdSMark Fasheh 			     unsigned int clusters_to_del,
5900ccd979bdSMark Fasheh 			     struct inode *inode,
5901ccd979bdSMark Fasheh 			     struct buffer_head *fe_bh,
59021fabe148SMark Fasheh 			     handle_t *handle,
5903dcd0538fSMark Fasheh 			     struct ocfs2_truncate_context *tc,
5904dcd0538fSMark Fasheh 			     struct ocfs2_path *path)
5905ccd979bdSMark Fasheh {
59063a0782d0SMark Fasheh 	int status;
5907ccd979bdSMark Fasheh 	struct ocfs2_dinode *fe;
5908ccd979bdSMark Fasheh 	struct ocfs2_extent_block *last_eb = NULL;
5909ccd979bdSMark Fasheh 	struct ocfs2_extent_list *el;
5910ccd979bdSMark Fasheh 	struct buffer_head *last_eb_bh = NULL;
5911ccd979bdSMark Fasheh 	u64 delete_blk = 0;
5912ccd979bdSMark Fasheh 
5913ccd979bdSMark Fasheh 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
5914ccd979bdSMark Fasheh 
59153a0782d0SMark Fasheh 	status = ocfs2_find_new_last_ext_blk(inode, clusters_to_del,
5916dcd0538fSMark Fasheh 					     path, &last_eb_bh);
5917ccd979bdSMark Fasheh 	if (status < 0) {
5918ccd979bdSMark Fasheh 		mlog_errno(status);
5919ccd979bdSMark Fasheh 		goto bail;
5920ccd979bdSMark Fasheh 	}
5921ccd979bdSMark Fasheh 
5922dcd0538fSMark Fasheh 	/*
5923dcd0538fSMark Fasheh 	 * Each component will be touched, so we might as well journal
5924dcd0538fSMark Fasheh 	 * here to avoid having to handle errors later.
5925dcd0538fSMark Fasheh 	 */
59263a0782d0SMark Fasheh 	status = ocfs2_journal_access_path(inode, handle, path);
5927ccd979bdSMark Fasheh 	if (status < 0) {
5928ccd979bdSMark Fasheh 		mlog_errno(status);
5929ccd979bdSMark Fasheh 		goto bail;
5930ccd979bdSMark Fasheh 	}
5931dcd0538fSMark Fasheh 
5932dcd0538fSMark Fasheh 	if (last_eb_bh) {
5933dcd0538fSMark Fasheh 		status = ocfs2_journal_access(handle, inode, last_eb_bh,
5934dcd0538fSMark Fasheh 					      OCFS2_JOURNAL_ACCESS_WRITE);
5935dcd0538fSMark Fasheh 		if (status < 0) {
5936dcd0538fSMark Fasheh 			mlog_errno(status);
5937dcd0538fSMark Fasheh 			goto bail;
5938dcd0538fSMark Fasheh 		}
5939dcd0538fSMark Fasheh 
5940dcd0538fSMark Fasheh 		last_eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
5941dcd0538fSMark Fasheh 	}
5942dcd0538fSMark Fasheh 
5943ccd979bdSMark Fasheh 	el = &(fe->id2.i_list);
5944ccd979bdSMark Fasheh 
5945dcd0538fSMark Fasheh 	/*
5946dcd0538fSMark Fasheh 	 * Lower levels depend on this never happening, but it's best
5947dcd0538fSMark Fasheh 	 * to check it up here before changing the tree.
5948dcd0538fSMark Fasheh 	 */
5949e48edee2SMark Fasheh 	if (el->l_tree_depth && el->l_recs[0].e_int_clusters == 0) {
5950dcd0538fSMark Fasheh 		ocfs2_error(inode->i_sb,
5951dcd0538fSMark Fasheh 			    "Inode %lu has an empty extent record, depth %u\n",
5952dcd0538fSMark Fasheh 			    inode->i_ino, le16_to_cpu(el->l_tree_depth));
59533a0782d0SMark Fasheh 		status = -EROFS;
5954dcd0538fSMark Fasheh 		goto bail;
5955dcd0538fSMark Fasheh 	}
5956dcd0538fSMark Fasheh 
5957ccd979bdSMark Fasheh 	spin_lock(&OCFS2_I(inode)->ip_lock);
5958ccd979bdSMark Fasheh 	OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters) -
5959ccd979bdSMark Fasheh 				      clusters_to_del;
5960ccd979bdSMark Fasheh 	spin_unlock(&OCFS2_I(inode)->ip_lock);
5961ccd979bdSMark Fasheh 	le32_add_cpu(&fe->i_clusters, -clusters_to_del);
5962e535e2efSMark Fasheh 	inode->i_blocks = ocfs2_inode_sector_count(inode);
5963ccd979bdSMark Fasheh 
59643a0782d0SMark Fasheh 	status = ocfs2_trim_tree(inode, path, handle, tc,
59653a0782d0SMark Fasheh 				 clusters_to_del, &delete_blk);
59663a0782d0SMark Fasheh 	if (status) {
59673a0782d0SMark Fasheh 		mlog_errno(status);
59683a0782d0SMark Fasheh 		goto bail;
5969ccd979bdSMark Fasheh 	}
5970ccd979bdSMark Fasheh 
5971dcd0538fSMark Fasheh 	if (le32_to_cpu(fe->i_clusters) == 0) {
5972ccd979bdSMark Fasheh 		/* trunc to zero is a special case. */
5973ccd979bdSMark Fasheh 		el->l_tree_depth = 0;
5974ccd979bdSMark Fasheh 		fe->i_last_eb_blk = 0;
5975ccd979bdSMark Fasheh 	} else if (last_eb)
5976ccd979bdSMark Fasheh 		fe->i_last_eb_blk = last_eb->h_blkno;
5977ccd979bdSMark Fasheh 
5978ccd979bdSMark Fasheh 	status = ocfs2_journal_dirty(handle, fe_bh);
5979ccd979bdSMark Fasheh 	if (status < 0) {
5980ccd979bdSMark Fasheh 		mlog_errno(status);
5981ccd979bdSMark Fasheh 		goto bail;
5982ccd979bdSMark Fasheh 	}
5983ccd979bdSMark Fasheh 
5984ccd979bdSMark Fasheh 	if (last_eb) {
5985ccd979bdSMark Fasheh 		/* If there will be a new last extent block, then by
5986ccd979bdSMark Fasheh 		 * definition, there cannot be any leaves to the right of
5987ccd979bdSMark Fasheh 		 * him. */
5988ccd979bdSMark Fasheh 		last_eb->h_next_leaf_blk = 0;
5989ccd979bdSMark Fasheh 		status = ocfs2_journal_dirty(handle, last_eb_bh);
5990ccd979bdSMark Fasheh 		if (status < 0) {
5991ccd979bdSMark Fasheh 			mlog_errno(status);
5992ccd979bdSMark Fasheh 			goto bail;
5993ccd979bdSMark Fasheh 		}
5994ccd979bdSMark Fasheh 	}
5995ccd979bdSMark Fasheh 
59963a0782d0SMark Fasheh 	if (delete_blk) {
5997ccd979bdSMark Fasheh 		status = ocfs2_truncate_log_append(osb, handle, delete_blk,
5998ccd979bdSMark Fasheh 						   clusters_to_del);
5999ccd979bdSMark Fasheh 		if (status < 0) {
6000ccd979bdSMark Fasheh 			mlog_errno(status);
6001ccd979bdSMark Fasheh 			goto bail;
6002ccd979bdSMark Fasheh 		}
60033a0782d0SMark Fasheh 	}
6004ccd979bdSMark Fasheh 	status = 0;
6005ccd979bdSMark Fasheh bail:
6006dcd0538fSMark Fasheh 
6007ccd979bdSMark Fasheh 	mlog_exit(status);
6008ccd979bdSMark Fasheh 	return status;
6009ccd979bdSMark Fasheh }
6010ccd979bdSMark Fasheh 
601160b11392SMark Fasheh static int ocfs2_writeback_zero_func(handle_t *handle, struct buffer_head *bh)
601260b11392SMark Fasheh {
601360b11392SMark Fasheh 	set_buffer_uptodate(bh);
601460b11392SMark Fasheh 	mark_buffer_dirty(bh);
601560b11392SMark Fasheh 	return 0;
601660b11392SMark Fasheh }
601760b11392SMark Fasheh 
601860b11392SMark Fasheh static int ocfs2_ordered_zero_func(handle_t *handle, struct buffer_head *bh)
601960b11392SMark Fasheh {
602060b11392SMark Fasheh 	set_buffer_uptodate(bh);
602160b11392SMark Fasheh 	mark_buffer_dirty(bh);
602260b11392SMark Fasheh 	return ocfs2_journal_dirty_data(handle, bh);
602360b11392SMark Fasheh }
602460b11392SMark Fasheh 
60251d410a6eSMark Fasheh static void ocfs2_map_and_dirty_page(struct inode *inode, handle_t *handle,
60261d410a6eSMark Fasheh 				     unsigned int from, unsigned int to,
60271d410a6eSMark Fasheh 				     struct page *page, int zero, u64 *phys)
602860b11392SMark Fasheh {
60291d410a6eSMark Fasheh 	int ret, partial = 0;
603060b11392SMark Fasheh 
60311d410a6eSMark Fasheh 	ret = ocfs2_map_page_blocks(page, phys, inode, from, to, 0);
603260b11392SMark Fasheh 	if (ret)
603360b11392SMark Fasheh 		mlog_errno(ret);
603460b11392SMark Fasheh 
60351d410a6eSMark Fasheh 	if (zero)
6036eebd2aa3SChristoph Lameter 		zero_user_segment(page, from, to);
603760b11392SMark Fasheh 
603860b11392SMark Fasheh 	/*
603960b11392SMark Fasheh 	 * Need to set the buffers we zero'd into uptodate
604060b11392SMark Fasheh 	 * here if they aren't - ocfs2_map_page_blocks()
604160b11392SMark Fasheh 	 * might've skipped some
604260b11392SMark Fasheh 	 */
604360b11392SMark Fasheh 	if (ocfs2_should_order_data(inode)) {
604460b11392SMark Fasheh 		ret = walk_page_buffers(handle,
604560b11392SMark Fasheh 					page_buffers(page),
604660b11392SMark Fasheh 					from, to, &partial,
604760b11392SMark Fasheh 					ocfs2_ordered_zero_func);
604860b11392SMark Fasheh 		if (ret < 0)
604960b11392SMark Fasheh 			mlog_errno(ret);
605060b11392SMark Fasheh 	} else {
605160b11392SMark Fasheh 		ret = walk_page_buffers(handle, page_buffers(page),
605260b11392SMark Fasheh 					from, to, &partial,
605360b11392SMark Fasheh 					ocfs2_writeback_zero_func);
605460b11392SMark Fasheh 		if (ret < 0)
605560b11392SMark Fasheh 			mlog_errno(ret);
605660b11392SMark Fasheh 	}
605760b11392SMark Fasheh 
605860b11392SMark Fasheh 	if (!partial)
605960b11392SMark Fasheh 		SetPageUptodate(page);
606060b11392SMark Fasheh 
606160b11392SMark Fasheh 	flush_dcache_page(page);
60621d410a6eSMark Fasheh }
60631d410a6eSMark Fasheh 
60641d410a6eSMark Fasheh static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t start,
60651d410a6eSMark Fasheh 				     loff_t end, struct page **pages,
60661d410a6eSMark Fasheh 				     int numpages, u64 phys, handle_t *handle)
60671d410a6eSMark Fasheh {
60681d410a6eSMark Fasheh 	int i;
60691d410a6eSMark Fasheh 	struct page *page;
60701d410a6eSMark Fasheh 	unsigned int from, to = PAGE_CACHE_SIZE;
60711d410a6eSMark Fasheh 	struct super_block *sb = inode->i_sb;
60721d410a6eSMark Fasheh 
60731d410a6eSMark Fasheh 	BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(sb)));
60741d410a6eSMark Fasheh 
60751d410a6eSMark Fasheh 	if (numpages == 0)
60761d410a6eSMark Fasheh 		goto out;
60771d410a6eSMark Fasheh 
60781d410a6eSMark Fasheh 	to = PAGE_CACHE_SIZE;
60791d410a6eSMark Fasheh 	for(i = 0; i < numpages; i++) {
60801d410a6eSMark Fasheh 		page = pages[i];
60811d410a6eSMark Fasheh 
60821d410a6eSMark Fasheh 		from = start & (PAGE_CACHE_SIZE - 1);
60831d410a6eSMark Fasheh 		if ((end >> PAGE_CACHE_SHIFT) == page->index)
60841d410a6eSMark Fasheh 			to = end & (PAGE_CACHE_SIZE - 1);
60851d410a6eSMark Fasheh 
60861d410a6eSMark Fasheh 		BUG_ON(from > PAGE_CACHE_SIZE);
60871d410a6eSMark Fasheh 		BUG_ON(to > PAGE_CACHE_SIZE);
60881d410a6eSMark Fasheh 
60891d410a6eSMark Fasheh 		ocfs2_map_and_dirty_page(inode, handle, from, to, page, 1,
60901d410a6eSMark Fasheh 					 &phys);
609160b11392SMark Fasheh 
609235edec1dSMark Fasheh 		start = (page->index + 1) << PAGE_CACHE_SHIFT;
609360b11392SMark Fasheh 	}
609460b11392SMark Fasheh out:
60951d410a6eSMark Fasheh 	if (pages)
60961d410a6eSMark Fasheh 		ocfs2_unlock_and_free_pages(pages, numpages);
609760b11392SMark Fasheh }
609860b11392SMark Fasheh 
609935edec1dSMark Fasheh static int ocfs2_grab_eof_pages(struct inode *inode, loff_t start, loff_t end,
61001d410a6eSMark Fasheh 				struct page **pages, int *num)
610160b11392SMark Fasheh {
61021d410a6eSMark Fasheh 	int numpages, ret = 0;
610360b11392SMark Fasheh 	struct super_block *sb = inode->i_sb;
610460b11392SMark Fasheh 	struct address_space *mapping = inode->i_mapping;
610560b11392SMark Fasheh 	unsigned long index;
610635edec1dSMark Fasheh 	loff_t last_page_bytes;
610760b11392SMark Fasheh 
610835edec1dSMark Fasheh 	BUG_ON(start > end);
610960b11392SMark Fasheh 
611035edec1dSMark Fasheh 	BUG_ON(start >> OCFS2_SB(sb)->s_clustersize_bits !=
611135edec1dSMark Fasheh 	       (end - 1) >> OCFS2_SB(sb)->s_clustersize_bits);
611235edec1dSMark Fasheh 
61131d410a6eSMark Fasheh 	numpages = 0;
611435edec1dSMark Fasheh 	last_page_bytes = PAGE_ALIGN(end);
611535edec1dSMark Fasheh 	index = start >> PAGE_CACHE_SHIFT;
611660b11392SMark Fasheh 	do {
611760b11392SMark Fasheh 		pages[numpages] = grab_cache_page(mapping, index);
611860b11392SMark Fasheh 		if (!pages[numpages]) {
611960b11392SMark Fasheh 			ret = -ENOMEM;
612060b11392SMark Fasheh 			mlog_errno(ret);
612160b11392SMark Fasheh 			goto out;
612260b11392SMark Fasheh 		}
612360b11392SMark Fasheh 
612460b11392SMark Fasheh 		numpages++;
612560b11392SMark Fasheh 		index++;
612635edec1dSMark Fasheh 	} while (index < (last_page_bytes >> PAGE_CACHE_SHIFT));
612760b11392SMark Fasheh 
612860b11392SMark Fasheh out:
612960b11392SMark Fasheh 	if (ret != 0) {
61301d410a6eSMark Fasheh 		if (pages)
61311d410a6eSMark Fasheh 			ocfs2_unlock_and_free_pages(pages, numpages);
613260b11392SMark Fasheh 		numpages = 0;
613360b11392SMark Fasheh 	}
613460b11392SMark Fasheh 
613560b11392SMark Fasheh 	*num = numpages;
613660b11392SMark Fasheh 
613760b11392SMark Fasheh 	return ret;
613860b11392SMark Fasheh }
613960b11392SMark Fasheh 
614060b11392SMark Fasheh /*
614160b11392SMark Fasheh  * Zero the area past i_size but still within an allocated
614260b11392SMark Fasheh  * cluster. This avoids exposing nonzero data on subsequent file
614360b11392SMark Fasheh  * extends.
614460b11392SMark Fasheh  *
614560b11392SMark Fasheh  * We need to call this before i_size is updated on the inode because
614660b11392SMark Fasheh  * otherwise block_write_full_page() will skip writeout of pages past
614760b11392SMark Fasheh  * i_size. The new_i_size parameter is passed for this reason.
614860b11392SMark Fasheh  */
614935edec1dSMark Fasheh int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle,
615035edec1dSMark Fasheh 				  u64 range_start, u64 range_end)
615160b11392SMark Fasheh {
61521d410a6eSMark Fasheh 	int ret = 0, numpages;
615360b11392SMark Fasheh 	struct page **pages = NULL;
615460b11392SMark Fasheh 	u64 phys;
61551d410a6eSMark Fasheh 	unsigned int ext_flags;
61561d410a6eSMark Fasheh 	struct super_block *sb = inode->i_sb;
615760b11392SMark Fasheh 
615860b11392SMark Fasheh 	/*
615960b11392SMark Fasheh 	 * File systems which don't support sparse files zero on every
616060b11392SMark Fasheh 	 * extend.
616160b11392SMark Fasheh 	 */
61621d410a6eSMark Fasheh 	if (!ocfs2_sparse_alloc(OCFS2_SB(sb)))
616360b11392SMark Fasheh 		return 0;
616460b11392SMark Fasheh 
61651d410a6eSMark Fasheh 	pages = kcalloc(ocfs2_pages_per_cluster(sb),
616660b11392SMark Fasheh 			sizeof(struct page *), GFP_NOFS);
616760b11392SMark Fasheh 	if (pages == NULL) {
616860b11392SMark Fasheh 		ret = -ENOMEM;
616960b11392SMark Fasheh 		mlog_errno(ret);
617060b11392SMark Fasheh 		goto out;
617160b11392SMark Fasheh 	}
617260b11392SMark Fasheh 
61731d410a6eSMark Fasheh 	if (range_start == range_end)
61741d410a6eSMark Fasheh 		goto out;
61751d410a6eSMark Fasheh 
61761d410a6eSMark Fasheh 	ret = ocfs2_extent_map_get_blocks(inode,
61771d410a6eSMark Fasheh 					  range_start >> sb->s_blocksize_bits,
61781d410a6eSMark Fasheh 					  &phys, NULL, &ext_flags);
617960b11392SMark Fasheh 	if (ret) {
618060b11392SMark Fasheh 		mlog_errno(ret);
618160b11392SMark Fasheh 		goto out;
618260b11392SMark Fasheh 	}
618360b11392SMark Fasheh 
61841d410a6eSMark Fasheh 	/*
61851d410a6eSMark Fasheh 	 * Tail is a hole, or is marked unwritten. In either case, we
61861d410a6eSMark Fasheh 	 * can count on read and write to return/push zero's.
61871d410a6eSMark Fasheh 	 */
61881d410a6eSMark Fasheh 	if (phys == 0 || ext_flags & OCFS2_EXT_UNWRITTEN)
618960b11392SMark Fasheh 		goto out;
619060b11392SMark Fasheh 
61911d410a6eSMark Fasheh 	ret = ocfs2_grab_eof_pages(inode, range_start, range_end, pages,
61921d410a6eSMark Fasheh 				   &numpages);
61931d410a6eSMark Fasheh 	if (ret) {
61941d410a6eSMark Fasheh 		mlog_errno(ret);
61951d410a6eSMark Fasheh 		goto out;
61961d410a6eSMark Fasheh 	}
61971d410a6eSMark Fasheh 
619835edec1dSMark Fasheh 	ocfs2_zero_cluster_pages(inode, range_start, range_end, pages,
619935edec1dSMark Fasheh 				 numpages, phys, handle);
620060b11392SMark Fasheh 
620160b11392SMark Fasheh 	/*
620260b11392SMark Fasheh 	 * Initiate writeout of the pages we zero'd here. We don't
620360b11392SMark Fasheh 	 * wait on them - the truncate_inode_pages() call later will
620460b11392SMark Fasheh 	 * do that for us.
620560b11392SMark Fasheh 	 */
620635edec1dSMark Fasheh 	ret = do_sync_mapping_range(inode->i_mapping, range_start,
620735edec1dSMark Fasheh 				    range_end - 1, SYNC_FILE_RANGE_WRITE);
620860b11392SMark Fasheh 	if (ret)
620960b11392SMark Fasheh 		mlog_errno(ret);
621060b11392SMark Fasheh 
621160b11392SMark Fasheh out:
621260b11392SMark Fasheh 	if (pages)
621360b11392SMark Fasheh 		kfree(pages);
621460b11392SMark Fasheh 
621560b11392SMark Fasheh 	return ret;
621660b11392SMark Fasheh }
621760b11392SMark Fasheh 
62181afc32b9SMark Fasheh static void ocfs2_zero_dinode_id2(struct inode *inode, struct ocfs2_dinode *di)
62191afc32b9SMark Fasheh {
62201afc32b9SMark Fasheh 	unsigned int blocksize = 1 << inode->i_sb->s_blocksize_bits;
62211afc32b9SMark Fasheh 
62221afc32b9SMark Fasheh 	memset(&di->id2, 0, blocksize - offsetof(struct ocfs2_dinode, id2));
62231afc32b9SMark Fasheh }
62241afc32b9SMark Fasheh 
62255b6a3a2bSMark Fasheh void ocfs2_dinode_new_extent_list(struct inode *inode,
62265b6a3a2bSMark Fasheh 				  struct ocfs2_dinode *di)
62275b6a3a2bSMark Fasheh {
62285b6a3a2bSMark Fasheh 	ocfs2_zero_dinode_id2(inode, di);
62295b6a3a2bSMark Fasheh 	di->id2.i_list.l_tree_depth = 0;
62305b6a3a2bSMark Fasheh 	di->id2.i_list.l_next_free_rec = 0;
62315b6a3a2bSMark Fasheh 	di->id2.i_list.l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(inode->i_sb));
62325b6a3a2bSMark Fasheh }
62335b6a3a2bSMark Fasheh 
62341afc32b9SMark Fasheh void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di)
62351afc32b9SMark Fasheh {
62361afc32b9SMark Fasheh 	struct ocfs2_inode_info *oi = OCFS2_I(inode);
62371afc32b9SMark Fasheh 	struct ocfs2_inline_data *idata = &di->id2.i_data;
62381afc32b9SMark Fasheh 
62391afc32b9SMark Fasheh 	spin_lock(&oi->ip_lock);
62401afc32b9SMark Fasheh 	oi->ip_dyn_features |= OCFS2_INLINE_DATA_FL;
62411afc32b9SMark Fasheh 	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
62421afc32b9SMark Fasheh 	spin_unlock(&oi->ip_lock);
62431afc32b9SMark Fasheh 
62441afc32b9SMark Fasheh 	/*
62451afc32b9SMark Fasheh 	 * We clear the entire i_data structure here so that all
62461afc32b9SMark Fasheh 	 * fields can be properly initialized.
62471afc32b9SMark Fasheh 	 */
62481afc32b9SMark Fasheh 	ocfs2_zero_dinode_id2(inode, di);
62491afc32b9SMark Fasheh 
62501afc32b9SMark Fasheh 	idata->id_count = cpu_to_le16(ocfs2_max_inline_data(inode->i_sb));
62511afc32b9SMark Fasheh }
62521afc32b9SMark Fasheh 
62531afc32b9SMark Fasheh int ocfs2_convert_inline_data_to_extents(struct inode *inode,
62541afc32b9SMark Fasheh 					 struct buffer_head *di_bh)
62551afc32b9SMark Fasheh {
62561afc32b9SMark Fasheh 	int ret, i, has_data, num_pages = 0;
62571afc32b9SMark Fasheh 	handle_t *handle;
62581afc32b9SMark Fasheh 	u64 uninitialized_var(block);
62591afc32b9SMark Fasheh 	struct ocfs2_inode_info *oi = OCFS2_I(inode);
62601afc32b9SMark Fasheh 	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
62611afc32b9SMark Fasheh 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
62621afc32b9SMark Fasheh 	struct ocfs2_alloc_context *data_ac = NULL;
62631afc32b9SMark Fasheh 	struct page **pages = NULL;
62641afc32b9SMark Fasheh 	loff_t end = osb->s_clustersize;
62651afc32b9SMark Fasheh 
62661afc32b9SMark Fasheh 	has_data = i_size_read(inode) ? 1 : 0;
62671afc32b9SMark Fasheh 
62681afc32b9SMark Fasheh 	if (has_data) {
62691afc32b9SMark Fasheh 		pages = kcalloc(ocfs2_pages_per_cluster(osb->sb),
62701afc32b9SMark Fasheh 				sizeof(struct page *), GFP_NOFS);
62711afc32b9SMark Fasheh 		if (pages == NULL) {
62721afc32b9SMark Fasheh 			ret = -ENOMEM;
62731afc32b9SMark Fasheh 			mlog_errno(ret);
62741afc32b9SMark Fasheh 			goto out;
62751afc32b9SMark Fasheh 		}
62761afc32b9SMark Fasheh 
62771afc32b9SMark Fasheh 		ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
62781afc32b9SMark Fasheh 		if (ret) {
62791afc32b9SMark Fasheh 			mlog_errno(ret);
62801afc32b9SMark Fasheh 			goto out;
62811afc32b9SMark Fasheh 		}
62821afc32b9SMark Fasheh 	}
62831afc32b9SMark Fasheh 
62841afc32b9SMark Fasheh 	handle = ocfs2_start_trans(osb, OCFS2_INLINE_TO_EXTENTS_CREDITS);
62851afc32b9SMark Fasheh 	if (IS_ERR(handle)) {
62861afc32b9SMark Fasheh 		ret = PTR_ERR(handle);
62871afc32b9SMark Fasheh 		mlog_errno(ret);
62881afc32b9SMark Fasheh 		goto out_unlock;
62891afc32b9SMark Fasheh 	}
62901afc32b9SMark Fasheh 
62911afc32b9SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, di_bh,
62921afc32b9SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
62931afc32b9SMark Fasheh 	if (ret) {
62941afc32b9SMark Fasheh 		mlog_errno(ret);
62951afc32b9SMark Fasheh 		goto out_commit;
62961afc32b9SMark Fasheh 	}
62971afc32b9SMark Fasheh 
62981afc32b9SMark Fasheh 	if (has_data) {
62991afc32b9SMark Fasheh 		u32 bit_off, num;
63001afc32b9SMark Fasheh 		unsigned int page_end;
63011afc32b9SMark Fasheh 		u64 phys;
63021afc32b9SMark Fasheh 
63031afc32b9SMark Fasheh 		ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off,
63041afc32b9SMark Fasheh 					   &num);
63051afc32b9SMark Fasheh 		if (ret) {
63061afc32b9SMark Fasheh 			mlog_errno(ret);
63071afc32b9SMark Fasheh 			goto out_commit;
63081afc32b9SMark Fasheh 		}
63091afc32b9SMark Fasheh 
63101afc32b9SMark Fasheh 		/*
63111afc32b9SMark Fasheh 		 * Save two copies, one for insert, and one that can
63121afc32b9SMark Fasheh 		 * be changed by ocfs2_map_and_dirty_page() below.
63131afc32b9SMark Fasheh 		 */
63141afc32b9SMark Fasheh 		block = phys = ocfs2_clusters_to_blocks(inode->i_sb, bit_off);
63151afc32b9SMark Fasheh 
63161afc32b9SMark Fasheh 		/*
63171afc32b9SMark Fasheh 		 * Non sparse file systems zero on extend, so no need
63181afc32b9SMark Fasheh 		 * to do that now.
63191afc32b9SMark Fasheh 		 */
63201afc32b9SMark Fasheh 		if (!ocfs2_sparse_alloc(osb) &&
63211afc32b9SMark Fasheh 		    PAGE_CACHE_SIZE < osb->s_clustersize)
63221afc32b9SMark Fasheh 			end = PAGE_CACHE_SIZE;
63231afc32b9SMark Fasheh 
63241afc32b9SMark Fasheh 		ret = ocfs2_grab_eof_pages(inode, 0, end, pages, &num_pages);
63251afc32b9SMark Fasheh 		if (ret) {
63261afc32b9SMark Fasheh 			mlog_errno(ret);
63271afc32b9SMark Fasheh 			goto out_commit;
63281afc32b9SMark Fasheh 		}
63291afc32b9SMark Fasheh 
63301afc32b9SMark Fasheh 		/*
63311afc32b9SMark Fasheh 		 * This should populate the 1st page for us and mark
63321afc32b9SMark Fasheh 		 * it up to date.
63331afc32b9SMark Fasheh 		 */
63341afc32b9SMark Fasheh 		ret = ocfs2_read_inline_data(inode, pages[0], di_bh);
63351afc32b9SMark Fasheh 		if (ret) {
63361afc32b9SMark Fasheh 			mlog_errno(ret);
63371afc32b9SMark Fasheh 			goto out_commit;
63381afc32b9SMark Fasheh 		}
63391afc32b9SMark Fasheh 
63401afc32b9SMark Fasheh 		page_end = PAGE_CACHE_SIZE;
63411afc32b9SMark Fasheh 		if (PAGE_CACHE_SIZE > osb->s_clustersize)
63421afc32b9SMark Fasheh 			page_end = osb->s_clustersize;
63431afc32b9SMark Fasheh 
63441afc32b9SMark Fasheh 		for (i = 0; i < num_pages; i++)
63451afc32b9SMark Fasheh 			ocfs2_map_and_dirty_page(inode, handle, 0, page_end,
63461afc32b9SMark Fasheh 						 pages[i], i > 0, &phys);
63471afc32b9SMark Fasheh 	}
63481afc32b9SMark Fasheh 
63491afc32b9SMark Fasheh 	spin_lock(&oi->ip_lock);
63501afc32b9SMark Fasheh 	oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL;
63511afc32b9SMark Fasheh 	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
63521afc32b9SMark Fasheh 	spin_unlock(&oi->ip_lock);
63531afc32b9SMark Fasheh 
63545b6a3a2bSMark Fasheh 	ocfs2_dinode_new_extent_list(inode, di);
63551afc32b9SMark Fasheh 
63561afc32b9SMark Fasheh 	ocfs2_journal_dirty(handle, di_bh);
63571afc32b9SMark Fasheh 
63581afc32b9SMark Fasheh 	if (has_data) {
63591afc32b9SMark Fasheh 		/*
63601afc32b9SMark Fasheh 		 * An error at this point should be extremely rare. If
63611afc32b9SMark Fasheh 		 * this proves to be false, we could always re-build
63621afc32b9SMark Fasheh 		 * the in-inode data from our pages.
63631afc32b9SMark Fasheh 		 */
63641afc32b9SMark Fasheh 		ret = ocfs2_insert_extent(osb, handle, inode, di_bh,
63651afc32b9SMark Fasheh 					  0, block, 1, 0, NULL);
63661afc32b9SMark Fasheh 		if (ret) {
63671afc32b9SMark Fasheh 			mlog_errno(ret);
63681afc32b9SMark Fasheh 			goto out_commit;
63691afc32b9SMark Fasheh 		}
63701afc32b9SMark Fasheh 
63711afc32b9SMark Fasheh 		inode->i_blocks = ocfs2_inode_sector_count(inode);
63721afc32b9SMark Fasheh 	}
63731afc32b9SMark Fasheh 
63741afc32b9SMark Fasheh out_commit:
63751afc32b9SMark Fasheh 	ocfs2_commit_trans(osb, handle);
63761afc32b9SMark Fasheh 
63771afc32b9SMark Fasheh out_unlock:
63781afc32b9SMark Fasheh 	if (data_ac)
63791afc32b9SMark Fasheh 		ocfs2_free_alloc_context(data_ac);
63801afc32b9SMark Fasheh 
63811afc32b9SMark Fasheh out:
63821afc32b9SMark Fasheh 	if (pages) {
63831afc32b9SMark Fasheh 		ocfs2_unlock_and_free_pages(pages, num_pages);
63841afc32b9SMark Fasheh 		kfree(pages);
63851afc32b9SMark Fasheh 	}
63861afc32b9SMark Fasheh 
63871afc32b9SMark Fasheh 	return ret;
63881afc32b9SMark Fasheh }
63891afc32b9SMark Fasheh 
6390ccd979bdSMark Fasheh /*
6391ccd979bdSMark Fasheh  * It is expected, that by the time you call this function,
6392ccd979bdSMark Fasheh  * inode->i_size and fe->i_size have been adjusted.
6393ccd979bdSMark Fasheh  *
6394ccd979bdSMark Fasheh  * WARNING: This will kfree the truncate context
6395ccd979bdSMark Fasheh  */
6396ccd979bdSMark Fasheh int ocfs2_commit_truncate(struct ocfs2_super *osb,
6397ccd979bdSMark Fasheh 			  struct inode *inode,
6398ccd979bdSMark Fasheh 			  struct buffer_head *fe_bh,
6399ccd979bdSMark Fasheh 			  struct ocfs2_truncate_context *tc)
6400ccd979bdSMark Fasheh {
6401ccd979bdSMark Fasheh 	int status, i, credits, tl_sem = 0;
6402dcd0538fSMark Fasheh 	u32 clusters_to_del, new_highest_cpos, range;
6403ccd979bdSMark Fasheh 	struct ocfs2_extent_list *el;
64041fabe148SMark Fasheh 	handle_t *handle = NULL;
6405ccd979bdSMark Fasheh 	struct inode *tl_inode = osb->osb_tl_inode;
6406dcd0538fSMark Fasheh 	struct ocfs2_path *path = NULL;
6407ccd979bdSMark Fasheh 
6408ccd979bdSMark Fasheh 	mlog_entry_void();
6409ccd979bdSMark Fasheh 
6410dcd0538fSMark Fasheh 	new_highest_cpos = ocfs2_clusters_for_bytes(osb->sb,
6411ccd979bdSMark Fasheh 						     i_size_read(inode));
6412ccd979bdSMark Fasheh 
6413dcd0538fSMark Fasheh 	path = ocfs2_new_inode_path(fe_bh);
6414dcd0538fSMark Fasheh 	if (!path) {
6415dcd0538fSMark Fasheh 		status = -ENOMEM;
6416ccd979bdSMark Fasheh 		mlog_errno(status);
6417ccd979bdSMark Fasheh 		goto bail;
6418ccd979bdSMark Fasheh 	}
641983418978SMark Fasheh 
642083418978SMark Fasheh 	ocfs2_extent_map_trunc(inode, new_highest_cpos);
642183418978SMark Fasheh 
6422dcd0538fSMark Fasheh start:
6423dcd0538fSMark Fasheh 	/*
64243a0782d0SMark Fasheh 	 * Check that we still have allocation to delete.
64253a0782d0SMark Fasheh 	 */
64263a0782d0SMark Fasheh 	if (OCFS2_I(inode)->ip_clusters == 0) {
64273a0782d0SMark Fasheh 		status = 0;
64283a0782d0SMark Fasheh 		goto bail;
64293a0782d0SMark Fasheh 	}
64303a0782d0SMark Fasheh 
64313a0782d0SMark Fasheh 	/*
6432dcd0538fSMark Fasheh 	 * Truncate always works against the rightmost tree branch.
6433dcd0538fSMark Fasheh 	 */
6434dcd0538fSMark Fasheh 	status = ocfs2_find_path(inode, path, UINT_MAX);
6435dcd0538fSMark Fasheh 	if (status) {
6436dcd0538fSMark Fasheh 		mlog_errno(status);
6437ccd979bdSMark Fasheh 		goto bail;
6438ccd979bdSMark Fasheh 	}
6439ccd979bdSMark Fasheh 
6440dcd0538fSMark Fasheh 	mlog(0, "inode->ip_clusters = %u, tree_depth = %u\n",
6441dcd0538fSMark Fasheh 	     OCFS2_I(inode)->ip_clusters, path->p_tree_depth);
6442dcd0538fSMark Fasheh 
6443dcd0538fSMark Fasheh 	/*
6444dcd0538fSMark Fasheh 	 * By now, el will point to the extent list on the bottom most
6445dcd0538fSMark Fasheh 	 * portion of this tree. Only the tail record is considered in
6446dcd0538fSMark Fasheh 	 * each pass.
6447dcd0538fSMark Fasheh 	 *
6448dcd0538fSMark Fasheh 	 * We handle the following cases, in order:
6449dcd0538fSMark Fasheh 	 * - empty extent: delete the remaining branch
6450dcd0538fSMark Fasheh 	 * - remove the entire record
6451dcd0538fSMark Fasheh 	 * - remove a partial record
6452dcd0538fSMark Fasheh 	 * - no record needs to be removed (truncate has completed)
6453dcd0538fSMark Fasheh 	 */
6454dcd0538fSMark Fasheh 	el = path_leaf_el(path);
64553a0782d0SMark Fasheh 	if (le16_to_cpu(el->l_next_free_rec) == 0) {
64563a0782d0SMark Fasheh 		ocfs2_error(inode->i_sb,
64573a0782d0SMark Fasheh 			    "Inode %llu has empty extent block at %llu\n",
64583a0782d0SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
64593a0782d0SMark Fasheh 			    (unsigned long long)path_leaf_bh(path)->b_blocknr);
64603a0782d0SMark Fasheh 		status = -EROFS;
64613a0782d0SMark Fasheh 		goto bail;
64623a0782d0SMark Fasheh 	}
64633a0782d0SMark Fasheh 
6464ccd979bdSMark Fasheh 	i = le16_to_cpu(el->l_next_free_rec) - 1;
6465dcd0538fSMark Fasheh 	range = le32_to_cpu(el->l_recs[i].e_cpos) +
6466e48edee2SMark Fasheh 		ocfs2_rec_clusters(el, &el->l_recs[i]);
6467dcd0538fSMark Fasheh 	if (i == 0 && ocfs2_is_empty_extent(&el->l_recs[i])) {
6468dcd0538fSMark Fasheh 		clusters_to_del = 0;
6469dcd0538fSMark Fasheh 	} else if (le32_to_cpu(el->l_recs[i].e_cpos) >= new_highest_cpos) {
6470e48edee2SMark Fasheh 		clusters_to_del = ocfs2_rec_clusters(el, &el->l_recs[i]);
6471dcd0538fSMark Fasheh 	} else if (range > new_highest_cpos) {
6472e48edee2SMark Fasheh 		clusters_to_del = (ocfs2_rec_clusters(el, &el->l_recs[i]) +
6473ccd979bdSMark Fasheh 				   le32_to_cpu(el->l_recs[i].e_cpos)) -
6474dcd0538fSMark Fasheh 				  new_highest_cpos;
6475dcd0538fSMark Fasheh 	} else {
6476dcd0538fSMark Fasheh 		status = 0;
6477dcd0538fSMark Fasheh 		goto bail;
6478dcd0538fSMark Fasheh 	}
6479ccd979bdSMark Fasheh 
6480dcd0538fSMark Fasheh 	mlog(0, "clusters_to_del = %u in this pass, tail blk=%llu\n",
6481dcd0538fSMark Fasheh 	     clusters_to_del, (unsigned long long)path_leaf_bh(path)->b_blocknr);
6482dcd0538fSMark Fasheh 
64831b1dcc1bSJes Sorensen 	mutex_lock(&tl_inode->i_mutex);
6484ccd979bdSMark Fasheh 	tl_sem = 1;
6485ccd979bdSMark Fasheh 	/* ocfs2_truncate_log_needs_flush guarantees us at least one
6486ccd979bdSMark Fasheh 	 * record is free for use. If there isn't any, we flush to get
6487ccd979bdSMark Fasheh 	 * an empty truncate log.  */
6488ccd979bdSMark Fasheh 	if (ocfs2_truncate_log_needs_flush(osb)) {
6489ccd979bdSMark Fasheh 		status = __ocfs2_flush_truncate_log(osb);
6490ccd979bdSMark Fasheh 		if (status < 0) {
6491ccd979bdSMark Fasheh 			mlog_errno(status);
6492ccd979bdSMark Fasheh 			goto bail;
6493ccd979bdSMark Fasheh 		}
6494ccd979bdSMark Fasheh 	}
6495ccd979bdSMark Fasheh 
6496ccd979bdSMark Fasheh 	credits = ocfs2_calc_tree_trunc_credits(osb->sb, clusters_to_del,
6497dcd0538fSMark Fasheh 						(struct ocfs2_dinode *)fe_bh->b_data,
6498dcd0538fSMark Fasheh 						el);
649965eff9ccSMark Fasheh 	handle = ocfs2_start_trans(osb, credits);
6500ccd979bdSMark Fasheh 	if (IS_ERR(handle)) {
6501ccd979bdSMark Fasheh 		status = PTR_ERR(handle);
6502ccd979bdSMark Fasheh 		handle = NULL;
6503ccd979bdSMark Fasheh 		mlog_errno(status);
6504ccd979bdSMark Fasheh 		goto bail;
6505ccd979bdSMark Fasheh 	}
6506ccd979bdSMark Fasheh 
6507dcd0538fSMark Fasheh 	status = ocfs2_do_truncate(osb, clusters_to_del, inode, fe_bh, handle,
6508dcd0538fSMark Fasheh 				   tc, path);
6509ccd979bdSMark Fasheh 	if (status < 0) {
6510ccd979bdSMark Fasheh 		mlog_errno(status);
6511ccd979bdSMark Fasheh 		goto bail;
6512ccd979bdSMark Fasheh 	}
6513ccd979bdSMark Fasheh 
65141b1dcc1bSJes Sorensen 	mutex_unlock(&tl_inode->i_mutex);
6515ccd979bdSMark Fasheh 	tl_sem = 0;
6516ccd979bdSMark Fasheh 
651702dc1af4SMark Fasheh 	ocfs2_commit_trans(osb, handle);
6518ccd979bdSMark Fasheh 	handle = NULL;
6519ccd979bdSMark Fasheh 
6520dcd0538fSMark Fasheh 	ocfs2_reinit_path(path, 1);
6521dcd0538fSMark Fasheh 
6522dcd0538fSMark Fasheh 	/*
65233a0782d0SMark Fasheh 	 * The check above will catch the case where we've truncated
65243a0782d0SMark Fasheh 	 * away all allocation.
6525dcd0538fSMark Fasheh 	 */
6526ccd979bdSMark Fasheh 	goto start;
65273a0782d0SMark Fasheh 
6528ccd979bdSMark Fasheh bail:
6529ccd979bdSMark Fasheh 
6530ccd979bdSMark Fasheh 	ocfs2_schedule_truncate_log_flush(osb, 1);
6531ccd979bdSMark Fasheh 
6532ccd979bdSMark Fasheh 	if (tl_sem)
65331b1dcc1bSJes Sorensen 		mutex_unlock(&tl_inode->i_mutex);
6534ccd979bdSMark Fasheh 
6535ccd979bdSMark Fasheh 	if (handle)
653602dc1af4SMark Fasheh 		ocfs2_commit_trans(osb, handle);
6537ccd979bdSMark Fasheh 
653859a5e416SMark Fasheh 	ocfs2_run_deallocs(osb, &tc->tc_dealloc);
653959a5e416SMark Fasheh 
6540dcd0538fSMark Fasheh 	ocfs2_free_path(path);
6541ccd979bdSMark Fasheh 
6542ccd979bdSMark Fasheh 	/* This will drop the ext_alloc cluster lock for us */
6543ccd979bdSMark Fasheh 	ocfs2_free_truncate_context(tc);
6544ccd979bdSMark Fasheh 
6545ccd979bdSMark Fasheh 	mlog_exit(status);
6546ccd979bdSMark Fasheh 	return status;
6547ccd979bdSMark Fasheh }
6548ccd979bdSMark Fasheh 
6549ccd979bdSMark Fasheh /*
655059a5e416SMark Fasheh  * Expects the inode to already be locked.
6551ccd979bdSMark Fasheh  */
6552ccd979bdSMark Fasheh int ocfs2_prepare_truncate(struct ocfs2_super *osb,
6553ccd979bdSMark Fasheh 			   struct inode *inode,
6554ccd979bdSMark Fasheh 			   struct buffer_head *fe_bh,
6555ccd979bdSMark Fasheh 			   struct ocfs2_truncate_context **tc)
6556ccd979bdSMark Fasheh {
655759a5e416SMark Fasheh 	int status;
6558ccd979bdSMark Fasheh 	unsigned int new_i_clusters;
6559ccd979bdSMark Fasheh 	struct ocfs2_dinode *fe;
6560ccd979bdSMark Fasheh 	struct ocfs2_extent_block *eb;
6561ccd979bdSMark Fasheh 	struct buffer_head *last_eb_bh = NULL;
6562ccd979bdSMark Fasheh 
6563ccd979bdSMark Fasheh 	mlog_entry_void();
6564ccd979bdSMark Fasheh 
6565ccd979bdSMark Fasheh 	*tc = NULL;
6566ccd979bdSMark Fasheh 
6567ccd979bdSMark Fasheh 	new_i_clusters = ocfs2_clusters_for_bytes(osb->sb,
6568ccd979bdSMark Fasheh 						  i_size_read(inode));
6569ccd979bdSMark Fasheh 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
6570ccd979bdSMark Fasheh 
6571ccd979bdSMark Fasheh 	mlog(0, "fe->i_clusters = %u, new_i_clusters = %u, fe->i_size ="
65721ca1a111SMark Fasheh 	     "%llu\n", le32_to_cpu(fe->i_clusters), new_i_clusters,
65731ca1a111SMark Fasheh 	     (unsigned long long)le64_to_cpu(fe->i_size));
6574ccd979bdSMark Fasheh 
6575cd861280SRobert P. J. Day 	*tc = kzalloc(sizeof(struct ocfs2_truncate_context), GFP_KERNEL);
6576ccd979bdSMark Fasheh 	if (!(*tc)) {
6577ccd979bdSMark Fasheh 		status = -ENOMEM;
6578ccd979bdSMark Fasheh 		mlog_errno(status);
6579ccd979bdSMark Fasheh 		goto bail;
6580ccd979bdSMark Fasheh 	}
658159a5e416SMark Fasheh 	ocfs2_init_dealloc_ctxt(&(*tc)->tc_dealloc);
6582ccd979bdSMark Fasheh 
6583ccd979bdSMark Fasheh 	if (fe->id2.i_list.l_tree_depth) {
6584ccd979bdSMark Fasheh 		status = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk),
6585ccd979bdSMark Fasheh 					  &last_eb_bh, OCFS2_BH_CACHED, inode);
6586ccd979bdSMark Fasheh 		if (status < 0) {
6587ccd979bdSMark Fasheh 			mlog_errno(status);
6588ccd979bdSMark Fasheh 			goto bail;
6589ccd979bdSMark Fasheh 		}
6590ccd979bdSMark Fasheh 		eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
6591ccd979bdSMark Fasheh 		if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
6592ccd979bdSMark Fasheh 			OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
6593ccd979bdSMark Fasheh 
6594ccd979bdSMark Fasheh 			brelse(last_eb_bh);
6595ccd979bdSMark Fasheh 			status = -EIO;
6596ccd979bdSMark Fasheh 			goto bail;
6597ccd979bdSMark Fasheh 		}
6598ccd979bdSMark Fasheh 	}
6599ccd979bdSMark Fasheh 
6600ccd979bdSMark Fasheh 	(*tc)->tc_last_eb_bh = last_eb_bh;
6601ccd979bdSMark Fasheh 
6602ccd979bdSMark Fasheh 	status = 0;
6603ccd979bdSMark Fasheh bail:
6604ccd979bdSMark Fasheh 	if (status < 0) {
6605ccd979bdSMark Fasheh 		if (*tc)
6606ccd979bdSMark Fasheh 			ocfs2_free_truncate_context(*tc);
6607ccd979bdSMark Fasheh 		*tc = NULL;
6608ccd979bdSMark Fasheh 	}
6609ccd979bdSMark Fasheh 	mlog_exit_void();
6610ccd979bdSMark Fasheh 	return status;
6611ccd979bdSMark Fasheh }
6612ccd979bdSMark Fasheh 
66131afc32b9SMark Fasheh /*
66141afc32b9SMark Fasheh  * 'start' is inclusive, 'end' is not.
66151afc32b9SMark Fasheh  */
66161afc32b9SMark Fasheh int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh,
66171afc32b9SMark Fasheh 			  unsigned int start, unsigned int end, int trunc)
66181afc32b9SMark Fasheh {
66191afc32b9SMark Fasheh 	int ret;
66201afc32b9SMark Fasheh 	unsigned int numbytes;
66211afc32b9SMark Fasheh 	handle_t *handle;
66221afc32b9SMark Fasheh 	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
66231afc32b9SMark Fasheh 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
66241afc32b9SMark Fasheh 	struct ocfs2_inline_data *idata = &di->id2.i_data;
66251afc32b9SMark Fasheh 
66261afc32b9SMark Fasheh 	if (end > i_size_read(inode))
66271afc32b9SMark Fasheh 		end = i_size_read(inode);
66281afc32b9SMark Fasheh 
66291afc32b9SMark Fasheh 	BUG_ON(start >= end);
66301afc32b9SMark Fasheh 
66311afc32b9SMark Fasheh 	if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) ||
66321afc32b9SMark Fasheh 	    !(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL) ||
66331afc32b9SMark Fasheh 	    !ocfs2_supports_inline_data(osb)) {
66341afc32b9SMark Fasheh 		ocfs2_error(inode->i_sb,
66351afc32b9SMark Fasheh 			    "Inline data flags for inode %llu don't agree! "
66361afc32b9SMark Fasheh 			    "Disk: 0x%x, Memory: 0x%x, Superblock: 0x%x\n",
66371afc32b9SMark Fasheh 			    (unsigned long long)OCFS2_I(inode)->ip_blkno,
66381afc32b9SMark Fasheh 			    le16_to_cpu(di->i_dyn_features),
66391afc32b9SMark Fasheh 			    OCFS2_I(inode)->ip_dyn_features,
66401afc32b9SMark Fasheh 			    osb->s_feature_incompat);
66411afc32b9SMark Fasheh 		ret = -EROFS;
66421afc32b9SMark Fasheh 		goto out;
66431afc32b9SMark Fasheh 	}
66441afc32b9SMark Fasheh 
66451afc32b9SMark Fasheh 	handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
66461afc32b9SMark Fasheh 	if (IS_ERR(handle)) {
66471afc32b9SMark Fasheh 		ret = PTR_ERR(handle);
66481afc32b9SMark Fasheh 		mlog_errno(ret);
66491afc32b9SMark Fasheh 		goto out;
66501afc32b9SMark Fasheh 	}
66511afc32b9SMark Fasheh 
66521afc32b9SMark Fasheh 	ret = ocfs2_journal_access(handle, inode, di_bh,
66531afc32b9SMark Fasheh 				   OCFS2_JOURNAL_ACCESS_WRITE);
66541afc32b9SMark Fasheh 	if (ret) {
66551afc32b9SMark Fasheh 		mlog_errno(ret);
66561afc32b9SMark Fasheh 		goto out_commit;
66571afc32b9SMark Fasheh 	}
66581afc32b9SMark Fasheh 
66591afc32b9SMark Fasheh 	numbytes = end - start;
66601afc32b9SMark Fasheh 	memset(idata->id_data + start, 0, numbytes);
66611afc32b9SMark Fasheh 
66621afc32b9SMark Fasheh 	/*
66631afc32b9SMark Fasheh 	 * No need to worry about the data page here - it's been
66641afc32b9SMark Fasheh 	 * truncated already and inline data doesn't need it for
66651afc32b9SMark Fasheh 	 * pushing zero's to disk, so we'll let readpage pick it up
66661afc32b9SMark Fasheh 	 * later.
66671afc32b9SMark Fasheh 	 */
66681afc32b9SMark Fasheh 	if (trunc) {
66691afc32b9SMark Fasheh 		i_size_write(inode, start);
66701afc32b9SMark Fasheh 		di->i_size = cpu_to_le64(start);
66711afc32b9SMark Fasheh 	}
66721afc32b9SMark Fasheh 
66731afc32b9SMark Fasheh 	inode->i_blocks = ocfs2_inode_sector_count(inode);
66741afc32b9SMark Fasheh 	inode->i_ctime = inode->i_mtime = CURRENT_TIME;
66751afc32b9SMark Fasheh 
66761afc32b9SMark Fasheh 	di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec);
66771afc32b9SMark Fasheh 	di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
66781afc32b9SMark Fasheh 
66791afc32b9SMark Fasheh 	ocfs2_journal_dirty(handle, di_bh);
66801afc32b9SMark Fasheh 
66811afc32b9SMark Fasheh out_commit:
66821afc32b9SMark Fasheh 	ocfs2_commit_trans(osb, handle);
66831afc32b9SMark Fasheh 
66841afc32b9SMark Fasheh out:
66851afc32b9SMark Fasheh 	return ret;
66861afc32b9SMark Fasheh }
66871afc32b9SMark Fasheh 
6688ccd979bdSMark Fasheh static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc)
6689ccd979bdSMark Fasheh {
669059a5e416SMark Fasheh 	/*
669159a5e416SMark Fasheh 	 * The caller is responsible for completing deallocation
669259a5e416SMark Fasheh 	 * before freeing the context.
669359a5e416SMark Fasheh 	 */
669459a5e416SMark Fasheh 	if (tc->tc_dealloc.c_first_suballocator != NULL)
669559a5e416SMark Fasheh 		mlog(ML_NOTICE,
669659a5e416SMark Fasheh 		     "Truncate completion has non-empty dealloc context\n");
6697ccd979bdSMark Fasheh 
6698ccd979bdSMark Fasheh 	if (tc->tc_last_eb_bh)
6699ccd979bdSMark Fasheh 		brelse(tc->tc_last_eb_bh);
6700ccd979bdSMark Fasheh 
6701ccd979bdSMark Fasheh 	kfree(tc);
6702ccd979bdSMark Fasheh }
6703