1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* alloc.c
4	*
5	* Extent allocs and frees
6	*
7	* Copyright (C) 2002, 2004 Oracle. All rights reserved.
8	*/
9
10	#include <linux/fs.h>
11	#include <linux/types.h>
12	#include <linux/slab.h>
13	#include <linux/string.h>
14	#include <linux/highmem.h>
15	#include <linux/swap.h>
16	#include <linux/quotaops.h>
17	#include <linux/blkdev.h>
18	#include <linux/sched/signal.h>
19
20	#include <cluster/masklog.h>
21
22	#include "ocfs2.h"
23
24	#include "alloc.h"
25	#include "aops.h"
26	#include "blockcheck.h"
27	#include "dlmglue.h"
28	#include "extent_map.h"
29	#include "inode.h"
30	#include "journal.h"
31	#include "localalloc.h"
32	#include "suballoc.h"
33	#include "sysfile.h"
34	#include "file.h"
35	#include "super.h"
36	#include "uptodate.h"
37	#include "xattr.h"
38	#include "refcounttree.h"
39	#include "ocfs2_trace.h"
40
41	#include "buffer_head_io.h"
42
43	enum ocfs2_contig_type {
44	CONTIG_NONE = 0,
45	CONTIG_LEFT,
46	CONTIG_RIGHT,
47	CONTIG_LEFTRIGHT,
48	};
49
50	static enum ocfs2_contig_type
51	ocfs2_extent_rec_contig(struct super_block *sb,
52	struct ocfs2_extent_rec *ext,
53	struct ocfs2_extent_rec *insert_rec);
54	/*
55	* Operations for a specific extent tree type.
56	*
57	* To implement an on-disk btree (extent tree) type in ocfs2, add
58	* an ocfs2_extent_tree_operations structure and the matching
59	* ocfs2_init_<thingy>_extent_tree() function. That's pretty much it
60	* for the allocation portion of the extent tree.
61	*/
62	struct ocfs2_extent_tree_operations {
63	/*
64	* last_eb_blk is the block number of the right most leaf extent
65	* block. Most on-disk structures containing an extent tree store
66	* this value for fast access. The ->eo_set_last_eb_blk() and
67	* ->eo_get_last_eb_blk() operations access this value. They are
68	* both required.
69	*/
70	void (*eo_set_last_eb_blk)(struct ocfs2_extent_tree *et,
71	u64 blkno);
72	u64 (*eo_get_last_eb_blk)(struct ocfs2_extent_tree *et);
73
74	/*
75	* The on-disk structure usually keeps track of how many total
76	* clusters are stored in this extent tree. This function updates
77	* that value. new_clusters is the delta, and must be
78	* added to the total. Required.
79	*/
80	void (*eo_update_clusters)(struct ocfs2_extent_tree *et,
81	u32 new_clusters);
82
83	/*
84	* If this extent tree is supported by an extent map, insert
85	* a record into the map.
86	*/
87	void (*eo_extent_map_insert)(struct ocfs2_extent_tree *et,
88	struct ocfs2_extent_rec *rec);
89
90	/*
91	* If this extent tree is supported by an extent map, truncate the
92	* map to clusters,
93	*/
94	void (*eo_extent_map_truncate)(struct ocfs2_extent_tree *et,
95	u32 clusters);
96
97	/*
98	* If ->eo_insert_check() exists, it is called before rec is
99	* inserted into the extent tree. It is optional.
100	*/
101	int (*eo_insert_check)(struct ocfs2_extent_tree *et,
102	struct ocfs2_extent_rec *rec);
103	int (*eo_sanity_check)(struct ocfs2_extent_tree *et);
104
105	/*
106	* --------------------------------------------------------------
107	* The remaining are internal to ocfs2_extent_tree and don't have
108	* accessor functions
109	*/
110
111	/*
112	* ->eo_fill_root_el() takes et->et_object and sets et->et_root_el.
113	* It is required.
114	*/
115	void (*eo_fill_root_el)(struct ocfs2_extent_tree *et);
116
117	/*
118	* ->eo_fill_max_leaf_clusters sets et->et_max_leaf_clusters if
119	* it exists. If it does not, et->et_max_leaf_clusters is set
120	* to 0 (unlimited). Optional.
121	*/
122	void (*eo_fill_max_leaf_clusters)(struct ocfs2_extent_tree *et);
123
124	/*
125	* ->eo_extent_contig test whether the 2 ocfs2_extent_rec
126	* are contiguous or not. Optional. Don't need to set it if use
127	* ocfs2_extent_rec as the tree leaf.
128	*/
129	enum ocfs2_contig_type
130	(*eo_extent_contig)(struct ocfs2_extent_tree *et,
131	struct ocfs2_extent_rec *ext,
132	struct ocfs2_extent_rec *insert_rec);
133	};
134
135
136	/*
137	* Pre-declare ocfs2_dinode_et_ops so we can use it as a sanity check
138	* in the methods.
139	*/
140	static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et);
141	static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
142	u64 blkno);
143	static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et,
144	u32 clusters);
145	static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et,
146	struct ocfs2_extent_rec *rec);
147	static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et,
148	u32 clusters);
149	static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et,
150	struct ocfs2_extent_rec *rec);
151	static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et);
152	static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et);
153
154	static int ocfs2_reuse_blk_from_dealloc(handle_t *handle,
155	struct ocfs2_extent_tree *et,
156	struct buffer_head **new_eb_bh,
157	int blk_wanted, int *blk_given);
158	static int ocfs2_is_dealloc_empty(struct ocfs2_extent_tree *et);
159
160	static const struct ocfs2_extent_tree_operations ocfs2_dinode_et_ops = {
161	.eo_set_last_eb_blk = ocfs2_dinode_set_last_eb_blk,
162	.eo_get_last_eb_blk = ocfs2_dinode_get_last_eb_blk,
163	.eo_update_clusters = ocfs2_dinode_update_clusters,
164	.eo_extent_map_insert = ocfs2_dinode_extent_map_insert,
165	.eo_extent_map_truncate = ocfs2_dinode_extent_map_truncate,
166	.eo_insert_check = ocfs2_dinode_insert_check,
167	.eo_sanity_check = ocfs2_dinode_sanity_check,
168	.eo_fill_root_el = ocfs2_dinode_fill_root_el,
169	};
170
171	static void ocfs2_dinode_set_last_eb_blk(struct ocfs2_extent_tree *et,
172	u64 blkno)
173	{
174	struct ocfs2_dinode *di = et->et_object;
175
176	BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
177	di->i_last_eb_blk = cpu_to_le64(blkno);
178	}
179
180	static u64 ocfs2_dinode_get_last_eb_blk(struct ocfs2_extent_tree *et)
181	{
182	struct ocfs2_dinode *di = et->et_object;
183
184	BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
185	return le64_to_cpu(di->i_last_eb_blk);
186	}
187
188	static void ocfs2_dinode_update_clusters(struct ocfs2_extent_tree *et,
189	u32 clusters)
190	{
191	struct ocfs2_inode_info *oi = cache_info_to_inode(ci: et->et_ci);
192	struct ocfs2_dinode *di = et->et_object;
193
194	le32_add_cpu(var: &di->i_clusters, val: clusters);
195	spin_lock(lock: &oi->ip_lock);
196	oi->ip_clusters = le32_to_cpu(di->i_clusters);
197	spin_unlock(lock: &oi->ip_lock);
198	}
199
200	static void ocfs2_dinode_extent_map_insert(struct ocfs2_extent_tree *et,
201	struct ocfs2_extent_rec *rec)
202	{
203	struct inode *inode = &cache_info_to_inode(ci: et->et_ci)->vfs_inode;
204
205	ocfs2_extent_map_insert_rec(inode, rec);
206	}
207
208	static void ocfs2_dinode_extent_map_truncate(struct ocfs2_extent_tree *et,
209	u32 clusters)
210	{
211	struct inode *inode = &cache_info_to_inode(ci: et->et_ci)->vfs_inode;
212
213	ocfs2_extent_map_trunc(inode, cluster: clusters);
214	}
215
216	static int ocfs2_dinode_insert_check(struct ocfs2_extent_tree *et,
217	struct ocfs2_extent_rec *rec)
218	{
219	struct ocfs2_inode_info *oi = cache_info_to_inode(ci: et->et_ci);
220	struct ocfs2_super *osb = OCFS2_SB(oi->vfs_inode.i_sb);
221
222	BUG_ON(oi->ip_dyn_features & OCFS2_INLINE_DATA_FL);
223	mlog_bug_on_msg(!ocfs2_sparse_alloc(osb) &&
224	(oi->ip_clusters != le32_to_cpu(rec->e_cpos)),
225	"Device %s, asking for sparse allocation: inode %llu, "
226	"cpos %u, clusters %u\n",
227	osb->dev_str,
228	(unsigned long long)oi->ip_blkno,
229	rec->e_cpos, oi->ip_clusters);
230
231	return 0;
232	}
233
234	static int ocfs2_dinode_sanity_check(struct ocfs2_extent_tree *et)
235	{
236	struct ocfs2_dinode *di = et->et_object;
237
238	BUG_ON(et->et_ops != &ocfs2_dinode_et_ops);
239	BUG_ON(!OCFS2_IS_VALID_DINODE(di));
240
241	return 0;
242	}
243
244	static void ocfs2_dinode_fill_root_el(struct ocfs2_extent_tree *et)
245	{
246	struct ocfs2_dinode *di = et->et_object;
247
248	et->et_root_el = &di->id2.i_list;
249	}
250
251
252	static void ocfs2_xattr_value_fill_root_el(struct ocfs2_extent_tree *et)
253	{
254	struct ocfs2_xattr_value_buf *vb = et->et_object;
255
256	et->et_root_el = &vb->vb_xv->xr_list;
257	}
258
259	static void ocfs2_xattr_value_set_last_eb_blk(struct ocfs2_extent_tree *et,
260	u64 blkno)
261	{
262	struct ocfs2_xattr_value_buf *vb = et->et_object;
263
264	vb->vb_xv->xr_last_eb_blk = cpu_to_le64(blkno);
265	}
266
267	static u64 ocfs2_xattr_value_get_last_eb_blk(struct ocfs2_extent_tree *et)
268	{
269	struct ocfs2_xattr_value_buf *vb = et->et_object;
270
271	return le64_to_cpu(vb->vb_xv->xr_last_eb_blk);
272	}
273
274	static void ocfs2_xattr_value_update_clusters(struct ocfs2_extent_tree *et,
275	u32 clusters)
276	{
277	struct ocfs2_xattr_value_buf *vb = et->et_object;
278
279	le32_add_cpu(var: &vb->vb_xv->xr_clusters, val: clusters);
280	}
281
282	static const struct ocfs2_extent_tree_operations ocfs2_xattr_value_et_ops = {
283	.eo_set_last_eb_blk = ocfs2_xattr_value_set_last_eb_blk,
284	.eo_get_last_eb_blk = ocfs2_xattr_value_get_last_eb_blk,
285	.eo_update_clusters = ocfs2_xattr_value_update_clusters,
286	.eo_fill_root_el = ocfs2_xattr_value_fill_root_el,
287	};
288
289	static void ocfs2_xattr_tree_fill_root_el(struct ocfs2_extent_tree *et)
290	{
291	struct ocfs2_xattr_block *xb = et->et_object;
292
293	et->et_root_el = &xb->xb_attrs.xb_root.xt_list;
294	}
295
296	static void ocfs2_xattr_tree_fill_max_leaf_clusters(struct ocfs2_extent_tree *et)
297	{
298	struct super_block *sb = ocfs2_metadata_cache_get_super(ci: et->et_ci);
299	et->et_max_leaf_clusters =
300	ocfs2_clusters_for_bytes(sb, OCFS2_MAX_XATTR_TREE_LEAF_SIZE);
301	}
302
303	static void ocfs2_xattr_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
304	u64 blkno)
305	{
306	struct ocfs2_xattr_block *xb = et->et_object;
307	struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
308
309	xt->xt_last_eb_blk = cpu_to_le64(blkno);
310	}
311
312	static u64 ocfs2_xattr_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
313	{
314	struct ocfs2_xattr_block *xb = et->et_object;
315	struct ocfs2_xattr_tree_root *xt = &xb->xb_attrs.xb_root;
316
317	return le64_to_cpu(xt->xt_last_eb_blk);
318	}
319
320	static void ocfs2_xattr_tree_update_clusters(struct ocfs2_extent_tree *et,
321	u32 clusters)
322	{
323	struct ocfs2_xattr_block *xb = et->et_object;
324
325	le32_add_cpu(var: &xb->xb_attrs.xb_root.xt_clusters, val: clusters);
326	}
327
328	static const struct ocfs2_extent_tree_operations ocfs2_xattr_tree_et_ops = {
329	.eo_set_last_eb_blk = ocfs2_xattr_tree_set_last_eb_blk,
330	.eo_get_last_eb_blk = ocfs2_xattr_tree_get_last_eb_blk,
331	.eo_update_clusters = ocfs2_xattr_tree_update_clusters,
332	.eo_fill_root_el = ocfs2_xattr_tree_fill_root_el,
333	.eo_fill_max_leaf_clusters = ocfs2_xattr_tree_fill_max_leaf_clusters,
334	};
335
336	static void ocfs2_dx_root_set_last_eb_blk(struct ocfs2_extent_tree *et,
337	u64 blkno)
338	{
339	struct ocfs2_dx_root_block *dx_root = et->et_object;
340
341	dx_root->dr_last_eb_blk = cpu_to_le64(blkno);
342	}
343
344	static u64 ocfs2_dx_root_get_last_eb_blk(struct ocfs2_extent_tree *et)
345	{
346	struct ocfs2_dx_root_block *dx_root = et->et_object;
347
348	return le64_to_cpu(dx_root->dr_last_eb_blk);
349	}
350
351	static void ocfs2_dx_root_update_clusters(struct ocfs2_extent_tree *et,
352	u32 clusters)
353	{
354	struct ocfs2_dx_root_block *dx_root = et->et_object;
355
356	le32_add_cpu(var: &dx_root->dr_clusters, val: clusters);
357	}
358
359	static int ocfs2_dx_root_sanity_check(struct ocfs2_extent_tree *et)
360	{
361	struct ocfs2_dx_root_block *dx_root = et->et_object;
362
363	BUG_ON(!OCFS2_IS_VALID_DX_ROOT(dx_root));
364
365	return 0;
366	}
367
368	static void ocfs2_dx_root_fill_root_el(struct ocfs2_extent_tree *et)
369	{
370	struct ocfs2_dx_root_block *dx_root = et->et_object;
371
372	et->et_root_el = &dx_root->dr_list;
373	}
374
375	static const struct ocfs2_extent_tree_operations ocfs2_dx_root_et_ops = {
376	.eo_set_last_eb_blk = ocfs2_dx_root_set_last_eb_blk,
377	.eo_get_last_eb_blk = ocfs2_dx_root_get_last_eb_blk,
378	.eo_update_clusters = ocfs2_dx_root_update_clusters,
379	.eo_sanity_check = ocfs2_dx_root_sanity_check,
380	.eo_fill_root_el = ocfs2_dx_root_fill_root_el,
381	};
382
383	static void ocfs2_refcount_tree_fill_root_el(struct ocfs2_extent_tree *et)
384	{
385	struct ocfs2_refcount_block *rb = et->et_object;
386
387	et->et_root_el = &rb->rf_list;
388	}
389
390	static void ocfs2_refcount_tree_set_last_eb_blk(struct ocfs2_extent_tree *et,
391	u64 blkno)
392	{
393	struct ocfs2_refcount_block *rb = et->et_object;
394
395	rb->rf_last_eb_blk = cpu_to_le64(blkno);
396	}
397
398	static u64 ocfs2_refcount_tree_get_last_eb_blk(struct ocfs2_extent_tree *et)
399	{
400	struct ocfs2_refcount_block *rb = et->et_object;
401
402	return le64_to_cpu(rb->rf_last_eb_blk);
403	}
404
405	static void ocfs2_refcount_tree_update_clusters(struct ocfs2_extent_tree *et,
406	u32 clusters)
407	{
408	struct ocfs2_refcount_block *rb = et->et_object;
409
410	le32_add_cpu(var: &rb->rf_clusters, val: clusters);
411	}
412
413	static enum ocfs2_contig_type
414	ocfs2_refcount_tree_extent_contig(struct ocfs2_extent_tree *et,
415	struct ocfs2_extent_rec *ext,
416	struct ocfs2_extent_rec *insert_rec)
417	{
418	return CONTIG_NONE;
419	}
420
421	static const struct ocfs2_extent_tree_operations ocfs2_refcount_tree_et_ops = {
422	.eo_set_last_eb_blk = ocfs2_refcount_tree_set_last_eb_blk,
423	.eo_get_last_eb_blk = ocfs2_refcount_tree_get_last_eb_blk,
424	.eo_update_clusters = ocfs2_refcount_tree_update_clusters,
425	.eo_fill_root_el = ocfs2_refcount_tree_fill_root_el,
426	.eo_extent_contig = ocfs2_refcount_tree_extent_contig,
427	};
428
429	static void __ocfs2_init_extent_tree(struct ocfs2_extent_tree *et,
430	struct ocfs2_caching_info *ci,
431	struct buffer_head *bh,
432	ocfs2_journal_access_func access,
433	void *obj,
434	const struct ocfs2_extent_tree_operations *ops)
435	{
436	et->et_ops = ops;
437	et->et_root_bh = bh;
438	et->et_ci = ci;
439	et->et_root_journal_access = access;
440	if (!obj)
441	obj = (void *)bh->b_data;
442	et->et_object = obj;
443	et->et_dealloc = NULL;
444
445	et->et_ops->eo_fill_root_el(et);
446	if (!et->et_ops->eo_fill_max_leaf_clusters)
447	et->et_max_leaf_clusters = 0;
448	else
449	et->et_ops->eo_fill_max_leaf_clusters(et);
450	}
451
452	void ocfs2_init_dinode_extent_tree(struct ocfs2_extent_tree *et,
453	struct ocfs2_caching_info *ci,
454	struct buffer_head *bh)
455	{
456	__ocfs2_init_extent_tree(et, ci, bh, access: ocfs2_journal_access_di,
457	NULL, ops: &ocfs2_dinode_et_ops);
458	}
459
460	void ocfs2_init_xattr_tree_extent_tree(struct ocfs2_extent_tree *et,
461	struct ocfs2_caching_info *ci,
462	struct buffer_head *bh)
463	{
464	__ocfs2_init_extent_tree(et, ci, bh, access: ocfs2_journal_access_xb,
465	NULL, ops: &ocfs2_xattr_tree_et_ops);
466	}
467
468	void ocfs2_init_xattr_value_extent_tree(struct ocfs2_extent_tree *et,
469	struct ocfs2_caching_info *ci,
470	struct ocfs2_xattr_value_buf *vb)
471	{
472	__ocfs2_init_extent_tree(et, ci, bh: vb->vb_bh, access: vb->vb_access, obj: vb,
473	ops: &ocfs2_xattr_value_et_ops);
474	}
475
476	void ocfs2_init_dx_root_extent_tree(struct ocfs2_extent_tree *et,
477	struct ocfs2_caching_info *ci,
478	struct buffer_head *bh)
479	{
480	__ocfs2_init_extent_tree(et, ci, bh, access: ocfs2_journal_access_dr,
481	NULL, ops: &ocfs2_dx_root_et_ops);
482	}
483
484	void ocfs2_init_refcount_extent_tree(struct ocfs2_extent_tree *et,
485	struct ocfs2_caching_info *ci,
486	struct buffer_head *bh)
487	{
488	__ocfs2_init_extent_tree(et, ci, bh, access: ocfs2_journal_access_rb,
489	NULL, ops: &ocfs2_refcount_tree_et_ops);
490	}
491
492	static inline void ocfs2_et_set_last_eb_blk(struct ocfs2_extent_tree *et,
493	u64 new_last_eb_blk)
494	{
495	et->et_ops->eo_set_last_eb_blk(et, new_last_eb_blk);
496	}
497
498	static inline u64 ocfs2_et_get_last_eb_blk(struct ocfs2_extent_tree *et)
499	{
500	return et->et_ops->eo_get_last_eb_blk(et);
501	}
502
503	static inline void ocfs2_et_update_clusters(struct ocfs2_extent_tree *et,
504	u32 clusters)
505	{
506	et->et_ops->eo_update_clusters(et, clusters);
507	}
508
509	static inline void ocfs2_et_extent_map_insert(struct ocfs2_extent_tree *et,
510	struct ocfs2_extent_rec *rec)
511	{
512	if (et->et_ops->eo_extent_map_insert)
513	et->et_ops->eo_extent_map_insert(et, rec);
514	}
515
516	static inline void ocfs2_et_extent_map_truncate(struct ocfs2_extent_tree *et,
517	u32 clusters)
518	{
519	if (et->et_ops->eo_extent_map_truncate)
520	et->et_ops->eo_extent_map_truncate(et, clusters);
521	}
522
523	static inline int ocfs2_et_root_journal_access(handle_t *handle,
524	struct ocfs2_extent_tree *et,
525	int type)
526	{
527	return et->et_root_journal_access(handle, et->et_ci, et->et_root_bh,
528	type);
529	}
530
531	static inline enum ocfs2_contig_type
532	ocfs2_et_extent_contig(struct ocfs2_extent_tree *et,
533	struct ocfs2_extent_rec *rec,
534	struct ocfs2_extent_rec *insert_rec)
535	{
536	if (et->et_ops->eo_extent_contig)
537	return et->et_ops->eo_extent_contig(et, rec, insert_rec);
538
539	return ocfs2_extent_rec_contig(
540	sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
541	ext: rec, insert_rec);
542	}
543
544	static inline int ocfs2_et_insert_check(struct ocfs2_extent_tree *et,
545	struct ocfs2_extent_rec *rec)
546	{
547	int ret = 0;
548
549	if (et->et_ops->eo_insert_check)
550	ret = et->et_ops->eo_insert_check(et, rec);
551	return ret;
552	}
553
554	static inline int ocfs2_et_sanity_check(struct ocfs2_extent_tree *et)
555	{
556	int ret = 0;
557
558	if (et->et_ops->eo_sanity_check)
559	ret = et->et_ops->eo_sanity_check(et);
560	return ret;
561	}
562
563	static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
564	struct ocfs2_extent_block *eb);
565	static void ocfs2_adjust_rightmost_records(handle_t *handle,
566	struct ocfs2_extent_tree *et,
567	struct ocfs2_path *path,
568	struct ocfs2_extent_rec *insert_rec);
569	/*
570	* Reset the actual path elements so that we can reuse the structure
571	* to build another path. Generally, this involves freeing the buffer
572	* heads.
573	*/
574	void ocfs2_reinit_path(struct ocfs2_path *path, int keep_root)
575	{
576	int i, start = 0, depth = 0;
577	struct ocfs2_path_item *node;
578
579	if (keep_root)
580	start = 1;
581
582	for(i = start; i < path_num_items(path); i++) {
583	node = &path->p_node[i];
584
585	brelse(bh: node->bh);
586	node->bh = NULL;
587	node->el = NULL;
588	}
589
590	/*
591	* Tree depth may change during truncate, or insert. If we're
592	* keeping the root extent list, then make sure that our path
593	* structure reflects the proper depth.
594	*/
595	if (keep_root)
596	depth = le16_to_cpu(path_root_el(path)->l_tree_depth);
597	else
598	path_root_access(path) = NULL;
599
600	path->p_tree_depth = depth;
601	}
602
603	void ocfs2_free_path(struct ocfs2_path *path)
604	{
605	if (path) {
606	ocfs2_reinit_path(path, keep_root: 0);
607	kfree(objp: path);
608	}
609	}
610
611	/*
612	* All the elements of src into dest. After this call, src could be freed
613	* without affecting dest.
614	*
615	* Both paths should have the same root. Any non-root elements of dest
616	* will be freed.
617	*/
618	static void ocfs2_cp_path(struct ocfs2_path *dest, struct ocfs2_path *src)
619	{
620	int i;
621
622	BUG_ON(path_root_bh(dest) != path_root_bh(src));
623	BUG_ON(path_root_el(dest) != path_root_el(src));
624	BUG_ON(path_root_access(dest) != path_root_access(src));
625
626	ocfs2_reinit_path(path: dest, keep_root: 1);
627
628	for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
629	dest->p_node[i].bh = src->p_node[i].bh;
630	dest->p_node[i].el = src->p_node[i].el;
631
632	if (dest->p_node[i].bh)
633	get_bh(bh: dest->p_node[i].bh);
634	}
635	}
636
637	/*
638	* Make the *dest path the same as src and re-initialize src path to
639	* have a root only.
640	*/
641	static void ocfs2_mv_path(struct ocfs2_path *dest, struct ocfs2_path *src)
642	{
643	int i;
644
645	BUG_ON(path_root_bh(dest) != path_root_bh(src));
646	BUG_ON(path_root_access(dest) != path_root_access(src));
647
648	for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
649	brelse(bh: dest->p_node[i].bh);
650
651	dest->p_node[i].bh = src->p_node[i].bh;
652	dest->p_node[i].el = src->p_node[i].el;
653
654	src->p_node[i].bh = NULL;
655	src->p_node[i].el = NULL;
656	}
657	}
658
659	/*
660	* Insert an extent block at given index.
661	*
662	* This will not take an additional reference on eb_bh.
663	*/
664	static inline void ocfs2_path_insert_eb(struct ocfs2_path *path, int index,
665	struct buffer_head *eb_bh)
666	{
667	struct ocfs2_extent_block *eb = (struct ocfs2_extent_block *)eb_bh->b_data;
668
669	/*
670	* Right now, no root bh is an extent block, so this helps
671	* catch code errors with dinode trees. The assertion can be
672	* safely removed if we ever need to insert extent block
673	* structures at the root.
674	*/
675	BUG_ON(index == 0);
676
677	path->p_node[index].bh = eb_bh;
678	path->p_node[index].el = &eb->h_list;
679	}
680
681	static struct ocfs2_path *ocfs2_new_path(struct buffer_head *root_bh,
682	struct ocfs2_extent_list *root_el,
683	ocfs2_journal_access_func access)
684	{
685	struct ocfs2_path *path;
686
687	BUG_ON(le16_to_cpu(root_el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH);
688
689	path = kzalloc(sizeof(*path), GFP_NOFS);
690	if (path) {
691	path->p_tree_depth = le16_to_cpu(root_el->l_tree_depth);
692	get_bh(bh: root_bh);
693	path_root_bh(path) = root_bh;
694	path_root_el(path) = root_el;
695	path_root_access(path) = access;
696	}
697
698	return path;
699	}
700
701	struct ocfs2_path *ocfs2_new_path_from_path(struct ocfs2_path *path)
702	{
703	return ocfs2_new_path(path_root_bh(path), path_root_el(path),
704	path_root_access(path));
705	}
706
707	struct ocfs2_path *ocfs2_new_path_from_et(struct ocfs2_extent_tree *et)
708	{
709	return ocfs2_new_path(root_bh: et->et_root_bh, root_el: et->et_root_el,
710	access: et->et_root_journal_access);
711	}
712
713	/*
714	* Journal the buffer at depth idx. All idx>0 are extent_blocks,
715	* otherwise it's the root_access function.
716	*
717	* I don't like the way this function's name looks next to
718	* ocfs2_journal_access_path(), but I don't have a better one.
719	*/
720	int ocfs2_path_bh_journal_access(handle_t *handle,
721	struct ocfs2_caching_info *ci,
722	struct ocfs2_path *path,
723	int idx)
724	{
725	ocfs2_journal_access_func access = path_root_access(path);
726
727	if (!access)
728	access = ocfs2_journal_access;
729
730	if (idx)
731	access = ocfs2_journal_access_eb;
732
733	return access(handle, ci, path->p_node[idx].bh,
734	OCFS2_JOURNAL_ACCESS_WRITE);
735	}
736
737	/*
738	* Convenience function to journal all components in a path.
739	*/
740	int ocfs2_journal_access_path(struct ocfs2_caching_info *ci,
741	handle_t *handle,
742	struct ocfs2_path *path)
743	{
744	int i, ret = 0;
745
746	if (!path)
747	goto out;
748
749	for(i = 0; i < path_num_items(path); i++) {
750	ret = ocfs2_path_bh_journal_access(handle, ci, path, idx: i);
751	if (ret < 0) {
752	mlog_errno(ret);
753	goto out;
754	}
755	}
756
757	out:
758	return ret;
759	}
760
761	/*
762	* Return the index of the extent record which contains cluster #v_cluster.
763	* -1 is returned if it was not found.
764	*
765	* Should work fine on interior and exterior nodes.
766	*/
767	int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster)
768	{
769	int ret = -1;
770	int i;
771	struct ocfs2_extent_rec *rec;
772	u32 rec_end, rec_start, clusters;
773
774	for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
775	rec = &el->l_recs[i];
776
777	rec_start = le32_to_cpu(rec->e_cpos);
778	clusters = ocfs2_rec_clusters(el, rec);
779
780	rec_end = rec_start + clusters;
781
782	if (v_cluster >= rec_start && v_cluster < rec_end) {
783	ret = i;
784	break;
785	}
786	}
787
788	return ret;
789	}
790
791	/*
792	* NOTE: ocfs2_block_extent_contig(), ocfs2_extents_adjacent() and
793	* ocfs2_extent_rec_contig only work properly against leaf nodes!
794	*/
795	static int ocfs2_block_extent_contig(struct super_block *sb,
796	struct ocfs2_extent_rec *ext,
797	u64 blkno)
798	{
799	u64 blk_end = le64_to_cpu(ext->e_blkno);
800
801	blk_end += ocfs2_clusters_to_blocks(sb,
802	le16_to_cpu(ext->e_leaf_clusters));
803
804	return blkno == blk_end;
805	}
806
807	static int ocfs2_extents_adjacent(struct ocfs2_extent_rec *left,
808	struct ocfs2_extent_rec *right)
809	{
810	u32 left_range;
811
812	left_range = le32_to_cpu(left->e_cpos) +
813	le16_to_cpu(left->e_leaf_clusters);
814
815	return (left_range == le32_to_cpu(right->e_cpos));
816	}
817
818	static enum ocfs2_contig_type
819	ocfs2_extent_rec_contig(struct super_block *sb,
820	struct ocfs2_extent_rec *ext,
821	struct ocfs2_extent_rec *insert_rec)
822	{
823	u64 blkno = le64_to_cpu(insert_rec->e_blkno);
824
825	/*
826	* Refuse to coalesce extent records with different flag
827	* fields - we don't want to mix unwritten extents with user
828	* data.
829	*/
830	if (ext->e_flags != insert_rec->e_flags)
831	return CONTIG_NONE;
832
833	if (ocfs2_extents_adjacent(left: ext, right: insert_rec) &&
834	ocfs2_block_extent_contig(sb, ext, blkno))
835	return CONTIG_RIGHT;
836
837	blkno = le64_to_cpu(ext->e_blkno);
838	if (ocfs2_extents_adjacent(left: insert_rec, right: ext) &&
839	ocfs2_block_extent_contig(sb, ext: insert_rec, blkno))
840	return CONTIG_LEFT;
841
842	return CONTIG_NONE;
843	}
844
845	/*
846	* NOTE: We can have pretty much any combination of contiguousness and
847	* appending.
848	*
849	* The usefulness of APPEND_TAIL is more in that it lets us know that
850	* we'll have to update the path to that leaf.
851	*/
852	enum ocfs2_append_type {
853	APPEND_NONE = 0,
854	APPEND_TAIL,
855	};
856
857	enum ocfs2_split_type {
858	SPLIT_NONE = 0,
859	SPLIT_LEFT,
860	SPLIT_RIGHT,
861	};
862
863	struct ocfs2_insert_type {
864	enum ocfs2_split_type ins_split;
865	enum ocfs2_append_type ins_appending;
866	enum ocfs2_contig_type ins_contig;
867	int ins_contig_index;
868	int ins_tree_depth;
869	};
870
871	struct ocfs2_merge_ctxt {
872	enum ocfs2_contig_type c_contig_type;
873	int c_has_empty_extent;
874	int c_split_covers_rec;
875	};
876
877	static int ocfs2_validate_extent_block(struct super_block *sb,
878	struct buffer_head *bh)
879	{
880	int rc;
881	struct ocfs2_extent_block *eb =
882	(struct ocfs2_extent_block *)bh->b_data;
883
884	trace_ocfs2_validate_extent_block(blkno: (unsigned long long)bh->b_blocknr);
885
886	BUG_ON(!buffer_uptodate(bh));
887
888	/*
889	* If the ecc fails, we return the error but otherwise
890	* leave the filesystem running. We know any error is
891	* local to this block.
892	*/
893	rc = ocfs2_validate_meta_ecc(sb, data: bh->b_data, bc: &eb->h_check);
894	if (rc) {
895	mlog(ML_ERROR, "Checksum failed for extent block %llu\n",
896	(unsigned long long)bh->b_blocknr);
897	return rc;
898	}
899
900	/*
901	* Errors after here are fatal.
902	*/
903
904	if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
905	rc = ocfs2_error(sb,
906	"Extent block #%llu has bad signature %.*s\n",
907	(unsigned long long)bh->b_blocknr, 7,
908	eb->h_signature);
909	goto bail;
910	}
911
912	if (le64_to_cpu(eb->h_blkno) != bh->b_blocknr) {
913	rc = ocfs2_error(sb,
914	"Extent block #%llu has an invalid h_blkno of %llu\n",
915	(unsigned long long)bh->b_blocknr,
916	(unsigned long long)le64_to_cpu(eb->h_blkno));
917	goto bail;
918	}
919
920	if (le32_to_cpu(eb->h_fs_generation) != OCFS2_SB(sb)->fs_generation)
921	rc = ocfs2_error(sb,
922	"Extent block #%llu has an invalid h_fs_generation of #%u\n",
923	(unsigned long long)bh->b_blocknr,
924	le32_to_cpu(eb->h_fs_generation));
925	bail:
926	return rc;
927	}
928
929	int ocfs2_read_extent_block(struct ocfs2_caching_info *ci, u64 eb_blkno,
930	struct buffer_head **bh)
931	{
932	int rc;
933	struct buffer_head *tmp = *bh;
934
935	rc = ocfs2_read_block(ci, off: eb_blkno, bh: &tmp,
936	validate: ocfs2_validate_extent_block);
937
938	/* If ocfs2_read_block() got us a new bh, pass it up. */
939	if (!rc && !*bh)
940	*bh = tmp;
941
942	return rc;
943	}
944
945
946	/*
947	* How many free extents have we got before we need more meta data?
948	*/
949	int ocfs2_num_free_extents(struct ocfs2_extent_tree *et)
950	{
951	int retval;
952	struct ocfs2_extent_list *el = NULL;
953	struct ocfs2_extent_block *eb;
954	struct buffer_head *eb_bh = NULL;
955	u64 last_eb_blk = 0;
956
957	el = et->et_root_el;
958	last_eb_blk = ocfs2_et_get_last_eb_blk(et);
959
960	if (last_eb_blk) {
961	retval = ocfs2_read_extent_block(ci: et->et_ci, eb_blkno: last_eb_blk,
962	bh: &eb_bh);
963	if (retval < 0) {
964	mlog_errno(retval);
965	goto bail;
966	}
967	eb = (struct ocfs2_extent_block *) eb_bh->b_data;
968	el = &eb->h_list;
969	}
970
971	if (el->l_tree_depth != 0) {
972	retval = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
973	"Owner %llu has leaf extent block %llu with an invalid l_tree_depth of %u\n",
974	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
975	(unsigned long long)last_eb_blk,
976	le16_to_cpu(el->l_tree_depth));
977	goto bail;
978	}
979
980	retval = le16_to_cpu(el->l_count) - le16_to_cpu(el->l_next_free_rec);
981	bail:
982	brelse(bh: eb_bh);
983
984	trace_ocfs2_num_free_extents(num: retval);
985	return retval;
986	}
987
988	/* expects array to already be allocated
989	*
990	* sets h_signature, h_blkno, h_suballoc_bit, h_suballoc_slot, and
991	* l_count for you
992	*/
993	static int ocfs2_create_new_meta_bhs(handle_t *handle,
994	struct ocfs2_extent_tree *et,
995	int wanted,
996	struct ocfs2_alloc_context *meta_ac,
997	struct buffer_head *bhs[])
998	{
999	int count, status, i;
1000	u16 suballoc_bit_start;
1001	u32 num_got;
1002	u64 suballoc_loc, first_blkno;
1003	struct ocfs2_super *osb =
1004	OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
1005	struct ocfs2_extent_block *eb;
1006
1007	count = 0;
1008	while (count < wanted) {
1009	status = ocfs2_claim_metadata(handle,
1010	ac: meta_ac,
1011	bits_wanted: wanted - count,
1012	suballoc_loc: &suballoc_loc,
1013	suballoc_bit_start: &suballoc_bit_start,
1014	num_bits: &num_got,
1015	blkno_start: &first_blkno);
1016	if (status < 0) {
1017	mlog_errno(status);
1018	goto bail;
1019	}
1020
1021	for(i = count; i < (num_got + count); i++) {
1022	bhs[i] = sb_getblk(sb: osb->sb, block: first_blkno);
1023	if (bhs[i] == NULL) {
1024	status = -ENOMEM;
1025	mlog_errno(status);
1026	goto bail;
1027	}
1028	ocfs2_set_new_buffer_uptodate(ci: et->et_ci, bh: bhs[i]);
1029
1030	status = ocfs2_journal_access_eb(handle, ci: et->et_ci,
1031	bh: bhs[i],
1032	OCFS2_JOURNAL_ACCESS_CREATE);
1033	if (status < 0) {
1034	mlog_errno(status);
1035	goto bail;
1036	}
1037
1038	memset(bhs[i]->b_data, 0, osb->sb->s_blocksize);
1039	eb = (struct ocfs2_extent_block *) bhs[i]->b_data;
1040	/* Ok, setup the minimal stuff here. */
1041	strscpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
1042	eb->h_blkno = cpu_to_le64(first_blkno);
1043	eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
1044	eb->h_suballoc_slot =
1045	cpu_to_le16(meta_ac->ac_alloc_slot);
1046	eb->h_suballoc_loc = cpu_to_le64(suballoc_loc);
1047	eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start);
1048	eb->h_list.l_count =
1049	cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
1050
1051	suballoc_bit_start++;
1052	first_blkno++;
1053
1054	/* We'll also be dirtied by the caller, so
1055	* this isn't absolutely necessary. */
1056	ocfs2_journal_dirty(handle, bh: bhs[i]);
1057	}
1058
1059	count += num_got;
1060	}
1061
1062	status = 0;
1063	bail:
1064	if (status < 0) {
1065	for(i = 0; i < wanted; i++) {
1066	brelse(bh: bhs[i]);
1067	bhs[i] = NULL;
1068	}
1069	}
1070	return status;
1071	}
1072
1073	/*
1074	* Helper function for ocfs2_add_branch() and ocfs2_shift_tree_depth().
1075	*
1076	* Returns the sum of the rightmost extent rec logical offset and
1077	* cluster count.
1078	*
1079	* ocfs2_add_branch() uses this to determine what logical cluster
1080	* value should be populated into the leftmost new branch records.
1081	*
1082	* ocfs2_shift_tree_depth() uses this to determine the # clusters
1083	* value for the new topmost tree record.
1084	*/
1085	static inline u32 ocfs2_sum_rightmost_rec(struct ocfs2_extent_list *el)
1086	{
1087	int i;
1088
1089	i = le16_to_cpu(el->l_next_free_rec) - 1;
1090
1091	return le32_to_cpu(el->l_recs[i].e_cpos) +
1092	ocfs2_rec_clusters(el, rec: &el->l_recs[i]);
1093	}
1094
1095	/*
1096	* Change range of the branches in the right most path according to the leaf
1097	* extent block's rightmost record.
1098	*/
1099	static int ocfs2_adjust_rightmost_branch(handle_t *handle,
1100	struct ocfs2_extent_tree *et)
1101	{
1102	int status;
1103	struct ocfs2_path *path = NULL;
1104	struct ocfs2_extent_list *el;
1105	struct ocfs2_extent_rec *rec;
1106
1107	path = ocfs2_new_path_from_et(et);
1108	if (!path) {
1109	status = -ENOMEM;
1110	return status;
1111	}
1112
1113	status = ocfs2_find_path(ci: et->et_ci, path, UINT_MAX);
1114	if (status < 0) {
1115	mlog_errno(status);
1116	goto out;
1117	}
1118
1119	status = ocfs2_extend_trans(handle, path_num_items(path));
1120	if (status < 0) {
1121	mlog_errno(status);
1122	goto out;
1123	}
1124
1125	status = ocfs2_journal_access_path(ci: et->et_ci, handle, path);
1126	if (status < 0) {
1127	mlog_errno(status);
1128	goto out;
1129	}
1130
1131	el = path_leaf_el(path);
1132	rec = &el->l_recs[le16_to_cpu(el->l_next_free_rec) - 1];
1133
1134	ocfs2_adjust_rightmost_records(handle, et, path, insert_rec: rec);
1135
1136	out:
1137	ocfs2_free_path(path);
1138	return status;
1139	}
1140
1141	/*
1142	* Add an entire tree branch to our inode. eb_bh is the extent block
1143	* to start at, if we don't want to start the branch at the root
1144	* structure.
1145	*
1146	* last_eb_bh is required as we have to update it's next_leaf pointer
1147	* for the new last extent block.
1148	*
1149	* the new branch will be 'empty' in the sense that every block will
1150	* contain a single record with cluster count == 0.
1151	*/
1152	static int ocfs2_add_branch(handle_t *handle,
1153	struct ocfs2_extent_tree *et,
1154	struct buffer_head *eb_bh,
1155	struct buffer_head **last_eb_bh,
1156	struct ocfs2_alloc_context *meta_ac)
1157	{
1158	int status, new_blocks, i, block_given = 0;
1159	u64 next_blkno, new_last_eb_blk;
1160	struct buffer_head *bh;
1161	struct buffer_head **new_eb_bhs = NULL;
1162	struct ocfs2_extent_block *eb;
1163	struct ocfs2_extent_list *eb_el;
1164	struct ocfs2_extent_list *el;
1165	u32 new_cpos, root_end;
1166
1167	BUG_ON(!last_eb_bh || !*last_eb_bh);
1168
1169	if (eb_bh) {
1170	eb = (struct ocfs2_extent_block *) eb_bh->b_data;
1171	el = &eb->h_list;
1172	} else
1173	el = et->et_root_el;
1174
1175	/* we never add a branch to a leaf. */
1176	BUG_ON(!el->l_tree_depth);
1177
1178	new_blocks = le16_to_cpu(el->l_tree_depth);
1179
1180	eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data;
1181	new_cpos = ocfs2_sum_rightmost_rec(el: &eb->h_list);
1182	root_end = ocfs2_sum_rightmost_rec(el: et->et_root_el);
1183
1184	/*
1185	* If there is a gap before the root end and the real end
1186	* of the rightmost leaf block, we need to remove the gap
1187	* between new_cpos and root_end first so that the tree
1188	* is consistent after we add a new branch(it will start
1189	* from new_cpos).
1190	*/
1191	if (root_end > new_cpos) {
1192	trace_ocfs2_adjust_rightmost_branch(
1193	owner: (unsigned long long)
1194	ocfs2_metadata_cache_owner(ci: et->et_ci),
1195	value1: root_end, value2: new_cpos);
1196
1197	status = ocfs2_adjust_rightmost_branch(handle, et);
1198	if (status) {
1199	mlog_errno(status);
1200	goto bail;
1201	}
1202	}
1203
1204	/* allocate the number of new eb blocks we need */
1205	new_eb_bhs = kcalloc(new_blocks, sizeof(struct buffer_head *),
1206	GFP_KERNEL);
1207	if (!new_eb_bhs) {
1208	status = -ENOMEM;
1209	mlog_errno(status);
1210	goto bail;
1211	}
1212
1213	/* Firstyly, try to reuse dealloc since we have already estimated how
1214	* many extent blocks we may use.
1215	*/
1216	if (!ocfs2_is_dealloc_empty(et)) {
1217	status = ocfs2_reuse_blk_from_dealloc(handle, et,
1218	new_eb_bh: new_eb_bhs, blk_wanted: new_blocks,
1219	blk_given: &block_given);
1220	if (status < 0) {
1221	mlog_errno(status);
1222	goto bail;
1223	}
1224	}
1225
1226	BUG_ON(block_given > new_blocks);
1227
1228	if (block_given < new_blocks) {
1229	BUG_ON(!meta_ac);
1230	status = ocfs2_create_new_meta_bhs(handle, et,
1231	wanted: new_blocks - block_given,
1232	meta_ac,
1233	bhs: &new_eb_bhs[block_given]);
1234	if (status < 0) {
1235	mlog_errno(status);
1236	goto bail;
1237	}
1238	}
1239
1240	/* Note: new_eb_bhs[new_blocks - 1] is the guy which will be
1241	* linked with the rest of the tree.
1242	* conversely, new_eb_bhs[0] is the new bottommost leaf.
1243	*
1244	* when we leave the loop, new_last_eb_blk will point to the
1245	* newest leaf, and next_blkno will point to the topmost extent
1246	* block. */
1247	next_blkno = new_last_eb_blk = 0;
1248	for(i = 0; i < new_blocks; i++) {
1249	bh = new_eb_bhs[i];
1250	eb = (struct ocfs2_extent_block *) bh->b_data;
1251	/* ocfs2_create_new_meta_bhs() should create it right! */
1252	BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
1253	eb_el = &eb->h_list;
1254
1255	status = ocfs2_journal_access_eb(handle, ci: et->et_ci, bh,
1256	OCFS2_JOURNAL_ACCESS_CREATE);
1257	if (status < 0) {
1258	mlog_errno(status);
1259	goto bail;
1260	}
1261
1262	eb->h_next_leaf_blk = 0;
1263	eb_el->l_tree_depth = cpu_to_le16(i);
1264	eb_el->l_next_free_rec = cpu_to_le16(1);
1265	/*
1266	* This actually counts as an empty extent as
1267	* c_clusters == 0
1268	*/
1269	eb_el->l_recs[0].e_cpos = cpu_to_le32(new_cpos);
1270	eb_el->l_recs[0].e_blkno = cpu_to_le64(next_blkno);
1271	/*
1272	* eb_el isn't always an interior node, but even leaf
1273	* nodes want a zero'd flags and reserved field so
1274	* this gets the whole 32 bits regardless of use.
1275	*/
1276	eb_el->l_recs[0].e_int_clusters = cpu_to_le32(0);
1277	if (!eb_el->l_tree_depth)
1278	new_last_eb_blk = le64_to_cpu(eb->h_blkno);
1279
1280	ocfs2_journal_dirty(handle, bh);
1281	next_blkno = le64_to_cpu(eb->h_blkno);
1282	}
1283
1284	/* This is a bit hairy. We want to update up to three blocks
1285	* here without leaving any of them in an inconsistent state
1286	* in case of error. We don't have to worry about
1287	* journal_dirty erroring as it won't unless we've aborted the
1288	* handle (in which case we would never be here) so reserving
1289	* the write with journal_access is all we need to do. */
1290	status = ocfs2_journal_access_eb(handle, ci: et->et_ci, bh: *last_eb_bh,
1291	OCFS2_JOURNAL_ACCESS_WRITE);
1292	if (status < 0) {
1293	mlog_errno(status);
1294	goto bail;
1295	}
1296	status = ocfs2_et_root_journal_access(handle, et,
1297	OCFS2_JOURNAL_ACCESS_WRITE);
1298	if (status < 0) {
1299	mlog_errno(status);
1300	goto bail;
1301	}
1302	if (eb_bh) {
1303	status = ocfs2_journal_access_eb(handle, ci: et->et_ci, bh: eb_bh,
1304	OCFS2_JOURNAL_ACCESS_WRITE);
1305	if (status < 0) {
1306	mlog_errno(status);
1307	goto bail;
1308	}
1309	}
1310
1311	/* Link the new branch into the rest of the tree (el will
1312	* either be on the root_bh, or the extent block passed in. */
1313	i = le16_to_cpu(el->l_next_free_rec);
1314	el->l_recs[i].e_blkno = cpu_to_le64(next_blkno);
1315	el->l_recs[i].e_cpos = cpu_to_le32(new_cpos);
1316	el->l_recs[i].e_int_clusters = 0;
1317	le16_add_cpu(var: &el->l_next_free_rec, val: 1);
1318
1319	/* fe needs a new last extent block pointer, as does the
1320	* next_leaf on the previously last-extent-block. */
1321	ocfs2_et_set_last_eb_blk(et, new_last_eb_blk);
1322
1323	eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
1324	eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk);
1325
1326	ocfs2_journal_dirty(handle, bh: *last_eb_bh);
1327	ocfs2_journal_dirty(handle, bh: et->et_root_bh);
1328	if (eb_bh)
1329	ocfs2_journal_dirty(handle, bh: eb_bh);
1330
1331	/*
1332	* Some callers want to track the rightmost leaf so pass it
1333	* back here.
1334	*/
1335	brelse(bh: *last_eb_bh);
1336	get_bh(bh: new_eb_bhs[0]);
1337	*last_eb_bh = new_eb_bhs[0];
1338
1339	status = 0;
1340	bail:
1341	if (new_eb_bhs) {
1342	for (i = 0; i < new_blocks; i++)
1343	brelse(bh: new_eb_bhs[i]);
1344	kfree(objp: new_eb_bhs);
1345	}
1346
1347	return status;
1348	}
1349
1350	/*
1351	* adds another level to the allocation tree.
1352	* returns back the new extent block so you can add a branch to it
1353	* after this call.
1354	*/
1355	static int ocfs2_shift_tree_depth(handle_t *handle,
1356	struct ocfs2_extent_tree *et,
1357	struct ocfs2_alloc_context *meta_ac,
1358	struct buffer_head **ret_new_eb_bh)
1359	{
1360	int status, i, block_given = 0;
1361	u32 new_clusters;
1362	struct buffer_head *new_eb_bh = NULL;
1363	struct ocfs2_extent_block *eb;
1364	struct ocfs2_extent_list *root_el;
1365	struct ocfs2_extent_list *eb_el;
1366
1367	if (!ocfs2_is_dealloc_empty(et)) {
1368	status = ocfs2_reuse_blk_from_dealloc(handle, et,
1369	new_eb_bh: &new_eb_bh, blk_wanted: 1,
1370	blk_given: &block_given);
1371	} else if (meta_ac) {
1372	status = ocfs2_create_new_meta_bhs(handle, et, wanted: 1, meta_ac,
1373	bhs: &new_eb_bh);
1374
1375	} else {
1376	BUG();
1377	}
1378
1379	if (status < 0) {
1380	mlog_errno(status);
1381	goto bail;
1382	}
1383
1384	eb = (struct ocfs2_extent_block *) new_eb_bh->b_data;
1385	/* ocfs2_create_new_meta_bhs() should create it right! */
1386	BUG_ON(!OCFS2_IS_VALID_EXTENT_BLOCK(eb));
1387
1388	eb_el = &eb->h_list;
1389	root_el = et->et_root_el;
1390
1391	status = ocfs2_journal_access_eb(handle, ci: et->et_ci, bh: new_eb_bh,
1392	OCFS2_JOURNAL_ACCESS_CREATE);
1393	if (status < 0) {
1394	mlog_errno(status);
1395	goto bail;
1396	}
1397
1398	/* copy the root extent list data into the new extent block */
1399	eb_el->l_tree_depth = root_el->l_tree_depth;
1400	eb_el->l_next_free_rec = root_el->l_next_free_rec;
1401	for (i = 0; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1402	eb_el->l_recs[i] = root_el->l_recs[i];
1403
1404	ocfs2_journal_dirty(handle, bh: new_eb_bh);
1405
1406	status = ocfs2_et_root_journal_access(handle, et,
1407	OCFS2_JOURNAL_ACCESS_WRITE);
1408	if (status < 0) {
1409	mlog_errno(status);
1410	goto bail;
1411	}
1412
1413	new_clusters = ocfs2_sum_rightmost_rec(el: eb_el);
1414
1415	/* update root_bh now */
1416	le16_add_cpu(var: &root_el->l_tree_depth, val: 1);
1417	root_el->l_recs[0].e_cpos = 0;
1418	root_el->l_recs[0].e_blkno = eb->h_blkno;
1419	root_el->l_recs[0].e_int_clusters = cpu_to_le32(new_clusters);
1420	for (i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
1421	memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
1422	root_el->l_next_free_rec = cpu_to_le16(1);
1423
1424	/* If this is our 1st tree depth shift, then last_eb_blk
1425	* becomes the allocated extent block */
1426	if (root_el->l_tree_depth == cpu_to_le16(1))
1427	ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
1428
1429	ocfs2_journal_dirty(handle, bh: et->et_root_bh);
1430
1431	*ret_new_eb_bh = new_eb_bh;
1432	new_eb_bh = NULL;
1433	status = 0;
1434	bail:
1435	brelse(bh: new_eb_bh);
1436
1437	return status;
1438	}
1439
1440	/*
1441	* Should only be called when there is no space left in any of the
1442	* leaf nodes. What we want to do is find the lowest tree depth
1443	* non-leaf extent block with room for new records. There are three
1444	* valid results of this search:
1445	*
1446	* 1) a lowest extent block is found, then we pass it back in
1447	* *lowest_eb_bh and return '0'
1448	*
1449	* 2) the search fails to find anything, but the root_el has room. We
1450	* pass NULL back in *lowest_eb_bh, but still return '0'
1451	*
1452	* 3) the search fails to find anything AND the root_el is full, in
1453	* which case we return > 0
1454	*
1455	* return status < 0 indicates an error.
1456	*/
1457	static int ocfs2_find_branch_target(struct ocfs2_extent_tree *et,
1458	struct buffer_head **target_bh)
1459	{
1460	int status = 0, i;
1461	u64 blkno;
1462	struct ocfs2_extent_block *eb;
1463	struct ocfs2_extent_list *el;
1464	struct buffer_head *bh = NULL;
1465	struct buffer_head *lowest_bh = NULL;
1466
1467	*target_bh = NULL;
1468
1469	el = et->et_root_el;
1470
1471	while(le16_to_cpu(el->l_tree_depth) > 1) {
1472	if (le16_to_cpu(el->l_next_free_rec) == 0) {
1473	status = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
1474	"Owner %llu has empty extent list (next_free_rec == 0)\n",
1475	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
1476	goto bail;
1477	}
1478	i = le16_to_cpu(el->l_next_free_rec) - 1;
1479	blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1480	if (!blkno) {
1481	status = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
1482	"Owner %llu has extent list where extent # %d has no physical block start\n",
1483	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci), i);
1484	goto bail;
1485	}
1486
1487	brelse(bh);
1488	bh = NULL;
1489
1490	status = ocfs2_read_extent_block(ci: et->et_ci, eb_blkno: blkno, bh: &bh);
1491	if (status < 0) {
1492	mlog_errno(status);
1493	goto bail;
1494	}
1495
1496	eb = (struct ocfs2_extent_block *) bh->b_data;
1497	el = &eb->h_list;
1498
1499	if (le16_to_cpu(el->l_next_free_rec) <
1500	le16_to_cpu(el->l_count)) {
1501	brelse(bh: lowest_bh);
1502	lowest_bh = bh;
1503	get_bh(bh: lowest_bh);
1504	}
1505	}
1506
1507	/* If we didn't find one and the fe doesn't have any room,
1508	* then return '1' */
1509	el = et->et_root_el;
1510	if (!lowest_bh && (el->l_next_free_rec == el->l_count))
1511	status = 1;
1512
1513	*target_bh = lowest_bh;
1514	bail:
1515	brelse(bh);
1516
1517	return status;
1518	}
1519
1520	/*
1521	* Grow a b-tree so that it has more records.
1522	*
1523	* We might shift the tree depth in which case existing paths should
1524	* be considered invalid.
1525	*
1526	* Tree depth after the grow is returned via *final_depth.
1527	*
1528	* *last_eb_bh will be updated by ocfs2_add_branch().
1529	*/
1530	static int ocfs2_grow_tree(handle_t *handle, struct ocfs2_extent_tree *et,
1531	int *final_depth, struct buffer_head **last_eb_bh,
1532	struct ocfs2_alloc_context *meta_ac)
1533	{
1534	int ret, shift;
1535	struct ocfs2_extent_list *el = et->et_root_el;
1536	int depth = le16_to_cpu(el->l_tree_depth);
1537	struct buffer_head *bh = NULL;
1538
1539	BUG_ON(meta_ac == NULL && ocfs2_is_dealloc_empty(et));
1540
1541	shift = ocfs2_find_branch_target(et, target_bh: &bh);
1542	if (shift < 0) {
1543	ret = shift;
1544	mlog_errno(ret);
1545	goto out;
1546	}
1547
1548	/* We traveled all the way to the bottom of the allocation tree
1549	* and didn't find room for any more extents - we need to add
1550	* another tree level */
1551	if (shift) {
1552	BUG_ON(bh);
1553	trace_ocfs2_grow_tree(
1554	owner: (unsigned long long)
1555	ocfs2_metadata_cache_owner(ci: et->et_ci),
1556	depth);
1557
1558	/* ocfs2_shift_tree_depth will return us a buffer with
1559	* the new extent block (so we can pass that to
1560	* ocfs2_add_branch). */
1561	ret = ocfs2_shift_tree_depth(handle, et, meta_ac, ret_new_eb_bh: &bh);
1562	if (ret < 0) {
1563	mlog_errno(ret);
1564	goto out;
1565	}
1566	depth++;
1567	if (depth == 1) {
1568	/*
1569	* Special case: we have room now if we shifted from
1570	* tree_depth 0, so no more work needs to be done.
1571	*
1572	* We won't be calling add_branch, so pass
1573	* back *last_eb_bh as the new leaf. At depth
1574	* zero, it should always be null so there's
1575	* no reason to brelse.
1576	*/
1577	BUG_ON(*last_eb_bh);
1578	get_bh(bh);
1579	*last_eb_bh = bh;
1580	goto out;
1581	}
1582	}
1583
1584	/* call ocfs2_add_branch to add the final part of the tree with
1585	* the new data. */
1586	ret = ocfs2_add_branch(handle, et, eb_bh: bh, last_eb_bh,
1587	meta_ac);
1588	if (ret < 0)
1589	mlog_errno(ret);
1590
1591	out:
1592	if (final_depth)
1593	*final_depth = depth;
1594	brelse(bh);
1595	return ret;
1596	}
1597
1598	/*
1599	* This function will discard the rightmost extent record.
1600	*/
1601	static void ocfs2_shift_records_right(struct ocfs2_extent_list *el)
1602	{
1603	int next_free = le16_to_cpu(el->l_next_free_rec);
1604	int count = le16_to_cpu(el->l_count);
1605	unsigned int num_bytes;
1606
1607	BUG_ON(!next_free);
1608	/* This will cause us to go off the end of our extent list. */
1609	BUG_ON(next_free >= count);
1610
1611	num_bytes = sizeof(struct ocfs2_extent_rec) * next_free;
1612
1613	memmove(&el->l_recs[1], &el->l_recs[0], num_bytes);
1614	}
1615
1616	static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el,
1617	struct ocfs2_extent_rec *insert_rec)
1618	{
1619	int i, insert_index, next_free, has_empty, num_bytes;
1620	u32 insert_cpos = le32_to_cpu(insert_rec->e_cpos);
1621	struct ocfs2_extent_rec *rec;
1622
1623	next_free = le16_to_cpu(el->l_next_free_rec);
1624	has_empty = ocfs2_is_empty_extent(rec: &el->l_recs[0]);
1625
1626	BUG_ON(!next_free);
1627
1628	/* The tree code before us didn't allow enough room in the leaf. */
1629	BUG_ON(el->l_next_free_rec == el->l_count && !has_empty);
1630
1631	/*
1632	* The easiest way to approach this is to just remove the
1633	* empty extent and temporarily decrement next_free.
1634	*/
1635	if (has_empty) {
1636	/*
1637	* If next_free was 1 (only an empty extent), this
1638	* loop won't execute, which is fine. We still want
1639	* the decrement above to happen.
1640	*/
1641	for(i = 0; i < (next_free - 1); i++)
1642	el->l_recs[i] = el->l_recs[i+1];
1643
1644	next_free--;
1645	}
1646
1647	/*
1648	* Figure out what the new record index should be.
1649	*/
1650	for(i = 0; i < next_free; i++) {
1651	rec = &el->l_recs[i];
1652
1653	if (insert_cpos < le32_to_cpu(rec->e_cpos))
1654	break;
1655	}
1656	insert_index = i;
1657
1658	trace_ocfs2_rotate_leaf(insert_cpos, insert_index,
1659	has_empty, next_free,
1660	le16_to_cpu(el->l_count));
1661
1662	BUG_ON(insert_index < 0);
1663	BUG_ON(insert_index >= le16_to_cpu(el->l_count));
1664	BUG_ON(insert_index > next_free);
1665
1666	/*
1667	* No need to memmove if we're just adding to the tail.
1668	*/
1669	if (insert_index != next_free) {
1670	BUG_ON(next_free >= le16_to_cpu(el->l_count));
1671
1672	num_bytes = next_free - insert_index;
1673	num_bytes *= sizeof(struct ocfs2_extent_rec);
1674	memmove(&el->l_recs[insert_index + 1],
1675	&el->l_recs[insert_index],
1676	num_bytes);
1677	}
1678
1679	/*
1680	* Either we had an empty extent, and need to re-increment or
1681	* there was no empty extent on a non full rightmost leaf node,
1682	* in which case we still need to increment.
1683	*/
1684	next_free++;
1685	el->l_next_free_rec = cpu_to_le16(next_free);
1686	/*
1687	* Make sure none of the math above just messed up our tree.
1688	*/
1689	BUG_ON(le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count));
1690
1691	el->l_recs[insert_index] = *insert_rec;
1692
1693	}
1694
1695	static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el)
1696	{
1697	int size, num_recs = le16_to_cpu(el->l_next_free_rec);
1698
1699	BUG_ON(num_recs == 0);
1700
1701	if (ocfs2_is_empty_extent(rec: &el->l_recs[0])) {
1702	num_recs--;
1703	size = num_recs * sizeof(struct ocfs2_extent_rec);
1704	memmove(&el->l_recs[0], &el->l_recs[1], size);
1705	memset(&el->l_recs[num_recs], 0,
1706	sizeof(struct ocfs2_extent_rec));
1707	el->l_next_free_rec = cpu_to_le16(num_recs);
1708	}
1709	}
1710
1711	/*
1712	* Create an empty extent record .
1713	*
1714	* l_next_free_rec may be updated.
1715	*
1716	* If an empty extent already exists do nothing.
1717	*/
1718	static void ocfs2_create_empty_extent(struct ocfs2_extent_list *el)
1719	{
1720	int next_free = le16_to_cpu(el->l_next_free_rec);
1721
1722	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
1723
1724	if (next_free == 0)
1725	goto set_and_inc;
1726
1727	if (ocfs2_is_empty_extent(rec: &el->l_recs[0]))
1728	return;
1729
1730	mlog_bug_on_msg(el->l_count == el->l_next_free_rec,
1731	"Asked to create an empty extent in a full list:\n"
1732	"count = %u, tree depth = %u",
1733	le16_to_cpu(el->l_count),
1734	le16_to_cpu(el->l_tree_depth));
1735
1736	ocfs2_shift_records_right(el);
1737
1738	set_and_inc:
1739	le16_add_cpu(var: &el->l_next_free_rec, val: 1);
1740	memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
1741	}
1742
1743	/*
1744	* For a rotation which involves two leaf nodes, the "root node" is
1745	* the lowest level tree node which contains a path to both leafs. This
1746	* resulting set of information can be used to form a complete "subtree"
1747	*
1748	* This function is passed two full paths from the dinode down to a
1749	* pair of adjacent leaves. It's task is to figure out which path
1750	* index contains the subtree root - this can be the root index itself
1751	* in a worst-case rotation.
1752	*
1753	* The array index of the subtree root is passed back.
1754	*/
1755	int ocfs2_find_subtree_root(struct ocfs2_extent_tree *et,
1756	struct ocfs2_path *left,
1757	struct ocfs2_path *right)
1758	{
1759	int i = 0;
1760
1761	/*
1762	* Check that the caller passed in two paths from the same tree.
1763	*/
1764	BUG_ON(path_root_bh(left) != path_root_bh(right));
1765
1766	do {
1767	i++;
1768
1769	/*
1770	* The caller didn't pass two adjacent paths.
1771	*/
1772	mlog_bug_on_msg(i > left->p_tree_depth,
1773	"Owner %llu, left depth %u, right depth %u\n"
1774	"left leaf blk %llu, right leaf blk %llu\n",
1775	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
1776	left->p_tree_depth, right->p_tree_depth,
1777	(unsigned long long)path_leaf_bh(left)->b_blocknr,
1778	(unsigned long long)path_leaf_bh(right)->b_blocknr);
1779	} while (left->p_node[i].bh->b_blocknr ==
1780	right->p_node[i].bh->b_blocknr);
1781
1782	return i - 1;
1783	}
1784
1785	typedef void (path_insert_t)(void *, struct buffer_head *);
1786
1787	/*
1788	* Traverse a btree path in search of cpos, starting at root_el.
1789	*
1790	* This code can be called with a cpos larger than the tree, in which
1791	* case it will return the rightmost path.
1792	*/
1793	static int __ocfs2_find_path(struct ocfs2_caching_info *ci,
1794	struct ocfs2_extent_list *root_el, u32 cpos,
1795	path_insert_t *func, void *data)
1796	{
1797	int i, ret = 0;
1798	u32 range;
1799	u64 blkno;
1800	struct buffer_head *bh = NULL;
1801	struct ocfs2_extent_block *eb;
1802	struct ocfs2_extent_list *el;
1803	struct ocfs2_extent_rec *rec;
1804
1805	el = root_el;
1806	while (el->l_tree_depth) {
1807	if (unlikely(le16_to_cpu(el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH)) {
1808	ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1809	"Owner %llu has invalid tree depth %u in extent list\n",
1810	(unsigned long long)ocfs2_metadata_cache_owner(ci),
1811	le16_to_cpu(el->l_tree_depth));
1812	ret = -EROFS;
1813	goto out;
1814	}
1815	if (le16_to_cpu(el->l_next_free_rec) == 0) {
1816	ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1817	"Owner %llu has empty extent list at depth %u\n",
1818	(unsigned long long)ocfs2_metadata_cache_owner(ci),
1819	le16_to_cpu(el->l_tree_depth));
1820	ret = -EROFS;
1821	goto out;
1822
1823	}
1824
1825	for(i = 0; i < le16_to_cpu(el->l_next_free_rec) - 1; i++) {
1826	rec = &el->l_recs[i];
1827
1828	/*
1829	* In the case that cpos is off the allocation
1830	* tree, this should just wind up returning the
1831	* rightmost record.
1832	*/
1833	range = le32_to_cpu(rec->e_cpos) +
1834	ocfs2_rec_clusters(el, rec);
1835	if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
1836	break;
1837	}
1838
1839	blkno = le64_to_cpu(el->l_recs[i].e_blkno);
1840	if (blkno == 0) {
1841	ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1842	"Owner %llu has bad blkno in extent list at depth %u (index %d)\n",
1843	(unsigned long long)ocfs2_metadata_cache_owner(ci),
1844	le16_to_cpu(el->l_tree_depth), i);
1845	ret = -EROFS;
1846	goto out;
1847	}
1848
1849	brelse(bh);
1850	bh = NULL;
1851	ret = ocfs2_read_extent_block(ci, eb_blkno: blkno, bh: &bh);
1852	if (ret) {
1853	mlog_errno(ret);
1854	goto out;
1855	}
1856
1857	eb = (struct ocfs2_extent_block *) bh->b_data;
1858	el = &eb->h_list;
1859
1860	if (le16_to_cpu(el->l_next_free_rec) >
1861	le16_to_cpu(el->l_count)) {
1862	ocfs2_error(ocfs2_metadata_cache_get_super(ci),
1863	"Owner %llu has bad count in extent list at block %llu (next free=%u, count=%u)\n",
1864	(unsigned long long)ocfs2_metadata_cache_owner(ci),
1865	(unsigned long long)bh->b_blocknr,
1866	le16_to_cpu(el->l_next_free_rec),
1867	le16_to_cpu(el->l_count));
1868	ret = -EROFS;
1869	goto out;
1870	}
1871
1872	if (func)
1873	func(data, bh);
1874	}
1875
1876	out:
1877	/*
1878	* Catch any trailing bh that the loop didn't handle.
1879	*/
1880	brelse(bh);
1881
1882	return ret;
1883	}
1884
1885	/*
1886	* Given an initialized path (that is, it has a valid root extent
1887	* list), this function will traverse the btree in search of the path
1888	* which would contain cpos.
1889	*
1890	* The path traveled is recorded in the path structure.
1891	*
1892	* Note that this will not do any comparisons on leaf node extent
1893	* records, so it will work fine in the case that we just added a tree
1894	* branch.
1895	*/
1896	struct find_path_data {
1897	int index;
1898	struct ocfs2_path *path;
1899	};
1900	static void find_path_ins(void *data, struct buffer_head *bh)
1901	{
1902	struct find_path_data *fp = data;
1903
1904	get_bh(bh);
1905	ocfs2_path_insert_eb(path: fp->path, index: fp->index, eb_bh: bh);
1906	fp->index++;
1907	}
1908	int ocfs2_find_path(struct ocfs2_caching_info *ci,
1909	struct ocfs2_path *path, u32 cpos)
1910	{
1911	struct find_path_data data;
1912
1913	data.index = 1;
1914	data.path = path;
1915	return __ocfs2_find_path(ci, path_root_el(path), cpos,
1916	func: find_path_ins, data: &data);
1917	}
1918
1919	static void find_leaf_ins(void *data, struct buffer_head *bh)
1920	{
1921	struct ocfs2_extent_block *eb =(struct ocfs2_extent_block *)bh->b_data;
1922	struct ocfs2_extent_list *el = &eb->h_list;
1923	struct buffer_head **ret = data;
1924
1925	/* We want to retain only the leaf block. */
1926	if (le16_to_cpu(el->l_tree_depth) == 0) {
1927	get_bh(bh);
1928	*ret = bh;
1929	}
1930	}
1931	/*
1932	* Find the leaf block in the tree which would contain cpos. No
1933	* checking of the actual leaf is done.
1934	*
1935	* Some paths want to call this instead of allocating a path structure
1936	* and calling ocfs2_find_path().
1937	*
1938	* This function doesn't handle non btree extent lists.
1939	*/
1940	int ocfs2_find_leaf(struct ocfs2_caching_info *ci,
1941	struct ocfs2_extent_list *root_el, u32 cpos,
1942	struct buffer_head **leaf_bh)
1943	{
1944	int ret;
1945	struct buffer_head *bh = NULL;
1946
1947	ret = __ocfs2_find_path(ci, root_el, cpos, func: find_leaf_ins, data: &bh);
1948	if (ret) {
1949	mlog_errno(ret);
1950	goto out;
1951	}
1952
1953	*leaf_bh = bh;
1954	out:
1955	return ret;
1956	}
1957
1958	/*
1959	* Adjust the adjacent records (left_rec, right_rec) involved in a rotation.
1960	*
1961	* Basically, we've moved stuff around at the bottom of the tree and
1962	* we need to fix up the extent records above the changes to reflect
1963	* the new changes.
1964	*
1965	* left_rec: the record on the left.
1966	* right_rec: the record to the right of left_rec
1967	* right_child_el: is the child list pointed to by right_rec
1968	*
1969	* By definition, this only works on interior nodes.
1970	*/
1971	static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec,
1972	struct ocfs2_extent_rec *right_rec,
1973	struct ocfs2_extent_list *right_child_el)
1974	{
1975	u32 left_clusters, right_end;
1976
1977	/*
1978	* Interior nodes never have holes. Their cpos is the cpos of
1979	* the leftmost record in their child list. Their cluster
1980	* count covers the full theoretical range of their child list
1981	* - the range between their cpos and the cpos of the record
1982	* immediately to their right.
1983	*/
1984	left_clusters = le32_to_cpu(right_child_el->l_recs[0].e_cpos);
1985	if (!ocfs2_rec_clusters(el: right_child_el, rec: &right_child_el->l_recs[0])) {
1986	BUG_ON(right_child_el->l_tree_depth);
1987	BUG_ON(le16_to_cpu(right_child_el->l_next_free_rec) <= 1);
1988	left_clusters = le32_to_cpu(right_child_el->l_recs[1].e_cpos);
1989	}
1990	left_clusters -= le32_to_cpu(left_rec->e_cpos);
1991	left_rec->e_int_clusters = cpu_to_le32(left_clusters);
1992
1993	/*
1994	* Calculate the rightmost cluster count boundary before
1995	* moving cpos - we will need to adjust clusters after
1996	* updating e_cpos to keep the same highest cluster count.
1997	*/
1998	right_end = le32_to_cpu(right_rec->e_cpos);
1999	right_end += le32_to_cpu(right_rec->e_int_clusters);
2000
2001	right_rec->e_cpos = left_rec->e_cpos;
2002	le32_add_cpu(var: &right_rec->e_cpos, val: left_clusters);
2003
2004	right_end -= le32_to_cpu(right_rec->e_cpos);
2005	right_rec->e_int_clusters = cpu_to_le32(right_end);
2006	}
2007
2008	/*
2009	* Adjust the adjacent root node records involved in a
2010	* rotation. left_el_blkno is passed in as a key so that we can easily
2011	* find it's index in the root list.
2012	*/
2013	static void ocfs2_adjust_root_records(struct ocfs2_extent_list *root_el,
2014	struct ocfs2_extent_list *left_el,
2015	struct ocfs2_extent_list *right_el,
2016	u64 left_el_blkno)
2017	{
2018	int i;
2019
2020	BUG_ON(le16_to_cpu(root_el->l_tree_depth) <=
2021	le16_to_cpu(left_el->l_tree_depth));
2022
2023	for(i = 0; i < le16_to_cpu(root_el->l_next_free_rec) - 1; i++) {
2024	if (le64_to_cpu(root_el->l_recs[i].e_blkno) == left_el_blkno)
2025	break;
2026	}
2027
2028	/*
2029	* The path walking code should have never returned a root and
2030	* two paths which are not adjacent.
2031	*/
2032	BUG_ON(i >= (le16_to_cpu(root_el->l_next_free_rec) - 1));
2033
2034	ocfs2_adjust_adjacent_records(left_rec: &root_el->l_recs[i],
2035	right_rec: &root_el->l_recs[i + 1], right_child_el: right_el);
2036	}
2037
2038	/*
2039	* We've changed a leaf block (in right_path) and need to reflect that
2040	* change back up the subtree.
2041	*
2042	* This happens in multiple places:
2043	* - When we've moved an extent record from the left path leaf to the right
2044	* path leaf to make room for an empty extent in the left path leaf.
2045	* - When our insert into the right path leaf is at the leftmost edge
2046	* and requires an update of the path immediately to it's left. This
2047	* can occur at the end of some types of rotation and appending inserts.
2048	* - When we've adjusted the last extent record in the left path leaf and the
2049	* 1st extent record in the right path leaf during cross extent block merge.
2050	*/
2051	static void ocfs2_complete_edge_insert(handle_t *handle,
2052	struct ocfs2_path *left_path,
2053	struct ocfs2_path *right_path,
2054	int subtree_index)
2055	{
2056	int i, idx;
2057	struct ocfs2_extent_list *el, *left_el, *right_el;
2058	struct ocfs2_extent_rec *left_rec, *right_rec;
2059	struct buffer_head *root_bh;
2060
2061	/*
2062	* Update the counts and position values within all the
2063	* interior nodes to reflect the leaf rotation we just did.
2064	*
2065	* The root node is handled below the loop.
2066	*
2067	* We begin the loop with right_el and left_el pointing to the
2068	* leaf lists and work our way up.
2069	*
2070	* NOTE: within this loop, left_el and right_el always refer
2071	* to the *child* lists.
2072	*/
2073	left_el = path_leaf_el(left_path);
2074	right_el = path_leaf_el(right_path);
2075	for(i = left_path->p_tree_depth - 1; i > subtree_index; i--) {
2076	trace_ocfs2_complete_edge_insert(num: i);
2077
2078	/*
2079	* One nice property of knowing that all of these
2080	* nodes are below the root is that we only deal with
2081	* the leftmost right node record and the rightmost
2082	* left node record.
2083	*/
2084	el = left_path->p_node[i].el;
2085	idx = le16_to_cpu(left_el->l_next_free_rec) - 1;
2086	left_rec = &el->l_recs[idx];
2087
2088	el = right_path->p_node[i].el;
2089	right_rec = &el->l_recs[0];
2090
2091	ocfs2_adjust_adjacent_records(left_rec, right_rec, right_child_el: right_el);
2092
2093	ocfs2_journal_dirty(handle, bh: left_path->p_node[i].bh);
2094	ocfs2_journal_dirty(handle, bh: right_path->p_node[i].bh);
2095
2096	/*
2097	* Setup our list pointers now so that the current
2098	* parents become children in the next iteration.
2099	*/
2100	left_el = left_path->p_node[i].el;
2101	right_el = right_path->p_node[i].el;
2102	}
2103
2104	/*
2105	* At the root node, adjust the two adjacent records which
2106	* begin our path to the leaves.
2107	*/
2108
2109	el = left_path->p_node[subtree_index].el;
2110	left_el = left_path->p_node[subtree_index + 1].el;
2111	right_el = right_path->p_node[subtree_index + 1].el;
2112
2113	ocfs2_adjust_root_records(root_el: el, left_el, right_el,
2114	left_el_blkno: left_path->p_node[subtree_index + 1].bh->b_blocknr);
2115
2116	root_bh = left_path->p_node[subtree_index].bh;
2117
2118	ocfs2_journal_dirty(handle, bh: root_bh);
2119	}
2120
2121	static int ocfs2_rotate_subtree_right(handle_t *handle,
2122	struct ocfs2_extent_tree *et,
2123	struct ocfs2_path *left_path,
2124	struct ocfs2_path *right_path,
2125	int subtree_index)
2126	{
2127	int ret, i;
2128	struct buffer_head *right_leaf_bh;
2129	struct buffer_head *left_leaf_bh = NULL;
2130	struct buffer_head *root_bh;
2131	struct ocfs2_extent_list *right_el, *left_el;
2132	struct ocfs2_extent_rec move_rec;
2133
2134	left_leaf_bh = path_leaf_bh(left_path);
2135	left_el = path_leaf_el(left_path);
2136
2137	if (left_el->l_next_free_rec != left_el->l_count) {
2138	ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
2139	"Inode %llu has non-full interior leaf node %llu (next free = %u)\n",
2140	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2141	(unsigned long long)left_leaf_bh->b_blocknr,
2142	le16_to_cpu(left_el->l_next_free_rec));
2143	return -EROFS;
2144	}
2145
2146	/*
2147	* This extent block may already have an empty record, so we
2148	* return early if so.
2149	*/
2150	if (ocfs2_is_empty_extent(rec: &left_el->l_recs[0]))
2151	return 0;
2152
2153	root_bh = left_path->p_node[subtree_index].bh;
2154	BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2155
2156	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci, path: right_path,
2157	idx: subtree_index);
2158	if (ret) {
2159	mlog_errno(ret);
2160	goto out;
2161	}
2162
2163	for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2164	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci,
2165	path: right_path, idx: i);
2166	if (ret) {
2167	mlog_errno(ret);
2168	goto out;
2169	}
2170
2171	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci,
2172	path: left_path, idx: i);
2173	if (ret) {
2174	mlog_errno(ret);
2175	goto out;
2176	}
2177	}
2178
2179	right_leaf_bh = path_leaf_bh(right_path);
2180	right_el = path_leaf_el(right_path);
2181
2182	/* This is a code error, not a disk corruption. */
2183	mlog_bug_on_msg(!right_el->l_next_free_rec, "Inode %llu: Rotate fails "
2184	"because rightmost leaf block %llu is empty\n",
2185	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2186	(unsigned long long)right_leaf_bh->b_blocknr);
2187
2188	ocfs2_create_empty_extent(el: right_el);
2189
2190	ocfs2_journal_dirty(handle, bh: right_leaf_bh);
2191
2192	/* Do the copy now. */
2193	i = le16_to_cpu(left_el->l_next_free_rec) - 1;
2194	move_rec = left_el->l_recs[i];
2195	right_el->l_recs[0] = move_rec;
2196
2197	/*
2198	* Clear out the record we just copied and shift everything
2199	* over, leaving an empty extent in the left leaf.
2200	*
2201	* We temporarily subtract from next_free_rec so that the
2202	* shift will lose the tail record (which is now defunct).
2203	*/
2204	le16_add_cpu(var: &left_el->l_next_free_rec, val: -1);
2205	ocfs2_shift_records_right(el: left_el);
2206	memset(&left_el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2207	le16_add_cpu(var: &left_el->l_next_free_rec, val: 1);
2208
2209	ocfs2_journal_dirty(handle, bh: left_leaf_bh);
2210
2211	ocfs2_complete_edge_insert(handle, left_path, right_path,
2212	subtree_index);
2213
2214	out:
2215	return ret;
2216	}
2217
2218	/*
2219	* Given a full path, determine what cpos value would return us a path
2220	* containing the leaf immediately to the left of the current one.
2221	*
2222	* Will return zero if the path passed in is already the leftmost path.
2223	*/
2224	int ocfs2_find_cpos_for_left_leaf(struct super_block *sb,
2225	struct ocfs2_path *path, u32 *cpos)
2226	{
2227	int i, j, ret = 0;
2228	u64 blkno;
2229	struct ocfs2_extent_list *el;
2230
2231	BUG_ON(path->p_tree_depth == 0);
2232
2233	*cpos = 0;
2234
2235	blkno = path_leaf_bh(path)->b_blocknr;
2236
2237	/* Start at the tree node just above the leaf and work our way up. */
2238	i = path->p_tree_depth - 1;
2239	while (i >= 0) {
2240	el = path->p_node[i].el;
2241
2242	/*
2243	* Find the extent record just before the one in our
2244	* path.
2245	*/
2246	for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2247	if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2248	if (j == 0) {
2249	if (i == 0) {
2250	/*
2251	* We've determined that the
2252	* path specified is already
2253	* the leftmost one - return a
2254	* cpos of zero.
2255	*/
2256	goto out;
2257	}
2258	/*
2259	* The leftmost record points to our
2260	* leaf - we need to travel up the
2261	* tree one level.
2262	*/
2263	goto next_node;
2264	}
2265
2266	*cpos = le32_to_cpu(el->l_recs[j - 1].e_cpos);
2267	*cpos = *cpos + ocfs2_rec_clusters(el,
2268	rec: &el->l_recs[j - 1]);
2269	*cpos = *cpos - 1;
2270	goto out;
2271	}
2272	}
2273
2274	/*
2275	* If we got here, we never found a valid node where
2276	* the tree indicated one should be.
2277	*/
2278	ocfs2_error(sb, "Invalid extent tree at extent block %llu\n",
2279	(unsigned long long)blkno);
2280	ret = -EROFS;
2281	goto out;
2282
2283	next_node:
2284	blkno = path->p_node[i].bh->b_blocknr;
2285	i--;
2286	}
2287
2288	out:
2289	return ret;
2290	}
2291
2292	/*
2293	* Extend the transaction by enough credits to complete the rotation,
2294	* and still leave at least the original number of credits allocated
2295	* to this transaction.
2296	*/
2297	static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth,
2298	int op_credits,
2299	struct ocfs2_path *path)
2300	{
2301	int ret = 0;
2302	int credits = (path->p_tree_depth - subtree_depth) * 2 + 1 + op_credits;
2303
2304	if (jbd2_handle_buffer_credits(handle) < credits)
2305	ret = ocfs2_extend_trans(handle,
2306	nblocks: credits - jbd2_handle_buffer_credits(handle));
2307
2308	return ret;
2309	}
2310
2311	/*
2312	* Trap the case where we're inserting into the theoretical range past
2313	* the _actual_ left leaf range. Otherwise, we'll rotate a record
2314	* whose cpos is less than ours into the right leaf.
2315	*
2316	* It's only necessary to look at the rightmost record of the left
2317	* leaf because the logic that calls us should ensure that the
2318	* theoretical ranges in the path components above the leaves are
2319	* correct.
2320	*/
2321	static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path,
2322	u32 insert_cpos)
2323	{
2324	struct ocfs2_extent_list *left_el;
2325	struct ocfs2_extent_rec *rec;
2326	int next_free;
2327
2328	left_el = path_leaf_el(left_path);
2329	next_free = le16_to_cpu(left_el->l_next_free_rec);
2330	rec = &left_el->l_recs[next_free - 1];
2331
2332	if (insert_cpos > le32_to_cpu(rec->e_cpos))
2333	return 1;
2334	return 0;
2335	}
2336
2337	static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos)
2338	{
2339	int next_free = le16_to_cpu(el->l_next_free_rec);
2340	unsigned int range;
2341	struct ocfs2_extent_rec *rec;
2342
2343	if (next_free == 0)
2344	return 0;
2345
2346	rec = &el->l_recs[0];
2347	if (ocfs2_is_empty_extent(rec)) {
2348	/* Empty list. */
2349	if (next_free == 1)
2350	return 0;
2351	rec = &el->l_recs[1];
2352	}
2353
2354	range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2355	if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
2356	return 1;
2357	return 0;
2358	}
2359
2360	/*
2361	* Rotate all the records in a btree right one record, starting at insert_cpos.
2362	*
2363	* The path to the rightmost leaf should be passed in.
2364	*
2365	* The array is assumed to be large enough to hold an entire path (tree depth).
2366	*
2367	* Upon successful return from this function:
2368	*
2369	* - The 'right_path' array will contain a path to the leaf block
2370	* whose range contains e_cpos.
2371	* - That leaf block will have a single empty extent in list index 0.
2372	* - In the case that the rotation requires a post-insert update,
2373	* *ret_left_path will contain a valid path which can be passed to
2374	* ocfs2_insert_path().
2375	*/
2376	static int ocfs2_rotate_tree_right(handle_t *handle,
2377	struct ocfs2_extent_tree *et,
2378	enum ocfs2_split_type split,
2379	u32 insert_cpos,
2380	struct ocfs2_path *right_path,
2381	struct ocfs2_path **ret_left_path)
2382	{
2383	int ret, start, orig_credits = jbd2_handle_buffer_credits(handle);
2384	u32 cpos;
2385	struct ocfs2_path *left_path = NULL;
2386	struct super_block *sb = ocfs2_metadata_cache_get_super(ci: et->et_ci);
2387
2388	*ret_left_path = NULL;
2389
2390	left_path = ocfs2_new_path_from_path(path: right_path);
2391	if (!left_path) {
2392	ret = -ENOMEM;
2393	mlog_errno(ret);
2394	goto out;
2395	}
2396
2397	ret = ocfs2_find_cpos_for_left_leaf(sb, path: right_path, cpos: &cpos);
2398	if (ret) {
2399	mlog_errno(ret);
2400	goto out;
2401	}
2402
2403	trace_ocfs2_rotate_tree_right(
2404	owner: (unsigned long long)ocfs2_metadata_cache_owner(ci: et->et_ci),
2405	value1: insert_cpos, value2: cpos);
2406
2407	/*
2408	* What we want to do here is:
2409	*
2410	* 1) Start with the rightmost path.
2411	*
2412	* 2) Determine a path to the leaf block directly to the left
2413	* of that leaf.
2414	*
2415	* 3) Determine the 'subtree root' - the lowest level tree node
2416	* which contains a path to both leaves.
2417	*
2418	* 4) Rotate the subtree.
2419	*
2420	* 5) Find the next subtree by considering the left path to be
2421	* the new right path.
2422	*
2423	* The check at the top of this while loop also accepts
2424	* insert_cpos == cpos because cpos is only a _theoretical_
2425	* value to get us the left path - insert_cpos might very well
2426	* be filling that hole.
2427	*
2428	* Stop at a cpos of '0' because we either started at the
2429	* leftmost branch (i.e., a tree with one branch and a
2430	* rotation inside of it), or we've gone as far as we can in
2431	* rotating subtrees.
2432	*/
2433	while (cpos && insert_cpos <= cpos) {
2434	trace_ocfs2_rotate_tree_right(
2435	owner: (unsigned long long)
2436	ocfs2_metadata_cache_owner(ci: et->et_ci),
2437	value1: insert_cpos, value2: cpos);
2438
2439	ret = ocfs2_find_path(ci: et->et_ci, path: left_path, cpos);
2440	if (ret) {
2441	mlog_errno(ret);
2442	goto out;
2443	}
2444
2445	mlog_bug_on_msg(path_leaf_bh(left_path) ==
2446	path_leaf_bh(right_path),
2447	"Owner %llu: error during insert of %u "
2448	"(left path cpos %u) results in two identical "
2449	"paths ending at %llu\n",
2450	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2451	insert_cpos, cpos,
2452	(unsigned long long)
2453	path_leaf_bh(left_path)->b_blocknr);
2454
2455	if (split == SPLIT_NONE &&
2456	ocfs2_rotate_requires_path_adjustment(left_path,
2457	insert_cpos)) {
2458
2459	/*
2460	* We've rotated the tree as much as we
2461	* should. The rest is up to
2462	* ocfs2_insert_path() to complete, after the
2463	* record insertion. We indicate this
2464	* situation by returning the left path.
2465	*
2466	* The reason we don't adjust the records here
2467	* before the record insert is that an error
2468	* later might break the rule where a parent
2469	* record e_cpos will reflect the actual
2470	* e_cpos of the 1st nonempty record of the
2471	* child list.
2472	*/
2473	*ret_left_path = left_path;
2474	goto out_ret_path;
2475	}
2476
2477	start = ocfs2_find_subtree_root(et, left: left_path, right: right_path);
2478
2479	trace_ocfs2_rotate_subtree(subtree_root: start,
2480	blkno: (unsigned long long)
2481	right_path->p_node[start].bh->b_blocknr,
2482	depth: right_path->p_tree_depth);
2483
2484	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: start,
2485	op_credits: orig_credits, path: right_path);
2486	if (ret) {
2487	mlog_errno(ret);
2488	goto out;
2489	}
2490
2491	ret = ocfs2_rotate_subtree_right(handle, et, left_path,
2492	right_path, subtree_index: start);
2493	if (ret) {
2494	mlog_errno(ret);
2495	goto out;
2496	}
2497
2498	if (split != SPLIT_NONE &&
2499	ocfs2_leftmost_rec_contains(path_leaf_el(right_path),
2500	cpos: insert_cpos)) {
2501	/*
2502	* A rotate moves the rightmost left leaf
2503	* record over to the leftmost right leaf
2504	* slot. If we're doing an extent split
2505	* instead of a real insert, then we have to
2506	* check that the extent to be split wasn't
2507	* just moved over. If it was, then we can
2508	* exit here, passing left_path back -
2509	* ocfs2_split_extent() is smart enough to
2510	* search both leaves.
2511	*/
2512	*ret_left_path = left_path;
2513	goto out_ret_path;
2514	}
2515
2516	/*
2517	* There is no need to re-read the next right path
2518	* as we know that it'll be our current left
2519	* path. Optimize by copying values instead.
2520	*/
2521	ocfs2_mv_path(dest: right_path, src: left_path);
2522
2523	ret = ocfs2_find_cpos_for_left_leaf(sb, path: right_path, cpos: &cpos);
2524	if (ret) {
2525	mlog_errno(ret);
2526	goto out;
2527	}
2528	}
2529
2530	out:
2531	ocfs2_free_path(path: left_path);
2532
2533	out_ret_path:
2534	return ret;
2535	}
2536
2537	static int ocfs2_update_edge_lengths(handle_t *handle,
2538	struct ocfs2_extent_tree *et,
2539	struct ocfs2_path *path)
2540	{
2541	int i, idx, ret;
2542	struct ocfs2_extent_rec *rec;
2543	struct ocfs2_extent_list *el;
2544	struct ocfs2_extent_block *eb;
2545	u32 range;
2546
2547	ret = ocfs2_journal_access_path(ci: et->et_ci, handle, path);
2548	if (ret) {
2549	mlog_errno(ret);
2550	goto out;
2551	}
2552
2553	/* Path should always be rightmost. */
2554	eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
2555	BUG_ON(eb->h_next_leaf_blk != 0ULL);
2556
2557	el = &eb->h_list;
2558	BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
2559	idx = le16_to_cpu(el->l_next_free_rec) - 1;
2560	rec = &el->l_recs[idx];
2561	range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
2562
2563	for (i = 0; i < path->p_tree_depth; i++) {
2564	el = path->p_node[i].el;
2565	idx = le16_to_cpu(el->l_next_free_rec) - 1;
2566	rec = &el->l_recs[idx];
2567
2568	rec->e_int_clusters = cpu_to_le32(range);
2569	le32_add_cpu(var: &rec->e_int_clusters, val: -le32_to_cpu(rec->e_cpos));
2570
2571	ocfs2_journal_dirty(handle, bh: path->p_node[i].bh);
2572	}
2573	out:
2574	return ret;
2575	}
2576
2577	static void ocfs2_unlink_path(handle_t *handle,
2578	struct ocfs2_extent_tree *et,
2579	struct ocfs2_cached_dealloc_ctxt *dealloc,
2580	struct ocfs2_path *path, int unlink_start)
2581	{
2582	int ret, i;
2583	struct ocfs2_extent_block *eb;
2584	struct ocfs2_extent_list *el;
2585	struct buffer_head *bh;
2586
2587	for(i = unlink_start; i < path_num_items(path); i++) {
2588	bh = path->p_node[i].bh;
2589
2590	eb = (struct ocfs2_extent_block *)bh->b_data;
2591	/*
2592	* Not all nodes might have had their final count
2593	* decremented by the caller - handle this here.
2594	*/
2595	el = &eb->h_list;
2596	if (le16_to_cpu(el->l_next_free_rec) > 1) {
2597	mlog(ML_ERROR,
2598	"Inode %llu, attempted to remove extent block "
2599	"%llu with %u records\n",
2600	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
2601	(unsigned long long)le64_to_cpu(eb->h_blkno),
2602	le16_to_cpu(el->l_next_free_rec));
2603
2604	ocfs2_journal_dirty(handle, bh);
2605	ocfs2_remove_from_cache(ci: et->et_ci, bh);
2606	continue;
2607	}
2608
2609	el->l_next_free_rec = 0;
2610	memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
2611
2612	ocfs2_journal_dirty(handle, bh);
2613
2614	ret = ocfs2_cache_extent_block_free(ctxt: dealloc, eb);
2615	if (ret)
2616	mlog_errno(ret);
2617
2618	ocfs2_remove_from_cache(ci: et->et_ci, bh);
2619	}
2620	}
2621
2622	static void ocfs2_unlink_subtree(handle_t *handle,
2623	struct ocfs2_extent_tree *et,
2624	struct ocfs2_path *left_path,
2625	struct ocfs2_path *right_path,
2626	int subtree_index,
2627	struct ocfs2_cached_dealloc_ctxt *dealloc)
2628	{
2629	int i;
2630	struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
2631	struct ocfs2_extent_list *root_el = left_path->p_node[subtree_index].el;
2632	struct ocfs2_extent_block *eb;
2633
2634	eb = (struct ocfs2_extent_block *)right_path->p_node[subtree_index + 1].bh->b_data;
2635
2636	for(i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
2637	if (root_el->l_recs[i].e_blkno == eb->h_blkno)
2638	break;
2639
2640	BUG_ON(i >= le16_to_cpu(root_el->l_next_free_rec));
2641
2642	memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
2643	le16_add_cpu(var: &root_el->l_next_free_rec, val: -1);
2644
2645	eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2646	eb->h_next_leaf_blk = 0;
2647
2648	ocfs2_journal_dirty(handle, bh: root_bh);
2649	ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2650
2651	ocfs2_unlink_path(handle, et, dealloc, path: right_path,
2652	unlink_start: subtree_index + 1);
2653	}
2654
2655	static int ocfs2_rotate_subtree_left(handle_t *handle,
2656	struct ocfs2_extent_tree *et,
2657	struct ocfs2_path *left_path,
2658	struct ocfs2_path *right_path,
2659	int subtree_index,
2660	struct ocfs2_cached_dealloc_ctxt *dealloc,
2661	int *deleted)
2662	{
2663	int ret, i, del_right_subtree = 0, right_has_empty = 0;
2664	struct buffer_head *root_bh, *et_root_bh = path_root_bh(right_path);
2665	struct ocfs2_extent_list *right_leaf_el, *left_leaf_el;
2666	struct ocfs2_extent_block *eb;
2667
2668	*deleted = 0;
2669
2670	right_leaf_el = path_leaf_el(right_path);
2671	left_leaf_el = path_leaf_el(left_path);
2672	root_bh = left_path->p_node[subtree_index].bh;
2673	BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
2674
2675	if (!ocfs2_is_empty_extent(rec: &left_leaf_el->l_recs[0]))
2676	return 0;
2677
2678	eb = (struct ocfs2_extent_block *)path_leaf_bh(right_path)->b_data;
2679	if (ocfs2_is_empty_extent(rec: &right_leaf_el->l_recs[0])) {
2680	/*
2681	* It's legal for us to proceed if the right leaf is
2682	* the rightmost one and it has an empty extent. There
2683	* are two cases to handle - whether the leaf will be
2684	* empty after removal or not. If the leaf isn't empty
2685	* then just remove the empty extent up front. The
2686	* next block will handle empty leaves by flagging
2687	* them for unlink.
2688	*
2689	* Non rightmost leaves will throw -EAGAIN and the
2690	* caller can manually move the subtree and retry.
2691	*/
2692
2693	if (eb->h_next_leaf_blk != 0ULL)
2694	return -EAGAIN;
2695
2696	if (le16_to_cpu(right_leaf_el->l_next_free_rec) > 1) {
2697	ret = ocfs2_journal_access_eb(handle, ci: et->et_ci,
2698	path_leaf_bh(right_path),
2699	OCFS2_JOURNAL_ACCESS_WRITE);
2700	if (ret) {
2701	mlog_errno(ret);
2702	goto out;
2703	}
2704
2705	ocfs2_remove_empty_extent(el: right_leaf_el);
2706	} else
2707	right_has_empty = 1;
2708	}
2709
2710	if (eb->h_next_leaf_blk == 0ULL &&
2711	le16_to_cpu(right_leaf_el->l_next_free_rec) == 1) {
2712	/*
2713	* We have to update i_last_eb_blk during the meta
2714	* data delete.
2715	*/
2716	ret = ocfs2_et_root_journal_access(handle, et,
2717	OCFS2_JOURNAL_ACCESS_WRITE);
2718	if (ret) {
2719	mlog_errno(ret);
2720	goto out;
2721	}
2722
2723	del_right_subtree = 1;
2724	}
2725
2726	/*
2727	* Getting here with an empty extent in the right path implies
2728	* that it's the rightmost path and will be deleted.
2729	*/
2730	BUG_ON(right_has_empty && !del_right_subtree);
2731
2732	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci, path: right_path,
2733	idx: subtree_index);
2734	if (ret) {
2735	mlog_errno(ret);
2736	goto out;
2737	}
2738
2739	for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
2740	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci,
2741	path: right_path, idx: i);
2742	if (ret) {
2743	mlog_errno(ret);
2744	goto out;
2745	}
2746
2747	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci,
2748	path: left_path, idx: i);
2749	if (ret) {
2750	mlog_errno(ret);
2751	goto out;
2752	}
2753	}
2754
2755	if (!right_has_empty) {
2756	/*
2757	* Only do this if we're moving a real
2758	* record. Otherwise, the action is delayed until
2759	* after removal of the right path in which case we
2760	* can do a simple shift to remove the empty extent.
2761	*/
2762	ocfs2_rotate_leaf(el: left_leaf_el, insert_rec: &right_leaf_el->l_recs[0]);
2763	memset(&right_leaf_el->l_recs[0], 0,
2764	sizeof(struct ocfs2_extent_rec));
2765	}
2766	if (eb->h_next_leaf_blk == 0ULL) {
2767	/*
2768	* Move recs over to get rid of empty extent, decrease
2769	* next_free. This is allowed to remove the last
2770	* extent in our leaf (setting l_next_free_rec to
2771	* zero) - the delete code below won't care.
2772	*/
2773	ocfs2_remove_empty_extent(el: right_leaf_el);
2774	}
2775
2776	ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
2777	ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
2778
2779	if (del_right_subtree) {
2780	ocfs2_unlink_subtree(handle, et, left_path, right_path,
2781	subtree_index, dealloc);
2782	ret = ocfs2_update_edge_lengths(handle, et, path: left_path);
2783	if (ret) {
2784	mlog_errno(ret);
2785	goto out;
2786	}
2787
2788	eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
2789	ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
2790
2791	/*
2792	* Removal of the extent in the left leaf was skipped
2793	* above so we could delete the right path
2794	* 1st.
2795	*/
2796	if (right_has_empty)
2797	ocfs2_remove_empty_extent(el: left_leaf_el);
2798
2799	ocfs2_journal_dirty(handle, bh: et_root_bh);
2800
2801	*deleted = 1;
2802	} else
2803	ocfs2_complete_edge_insert(handle, left_path, right_path,
2804	subtree_index);
2805
2806	out:
2807	return ret;
2808	}
2809
2810	/*
2811	* Given a full path, determine what cpos value would return us a path
2812	* containing the leaf immediately to the right of the current one.
2813	*
2814	* Will return zero if the path passed in is already the rightmost path.
2815	*
2816	* This looks similar, but is subtly different to
2817	* ocfs2_find_cpos_for_left_leaf().
2818	*/
2819	int ocfs2_find_cpos_for_right_leaf(struct super_block *sb,
2820	struct ocfs2_path *path, u32 *cpos)
2821	{
2822	int i, j, ret = 0;
2823	u64 blkno;
2824	struct ocfs2_extent_list *el;
2825
2826	*cpos = 0;
2827
2828	if (path->p_tree_depth == 0)
2829	return 0;
2830
2831	blkno = path_leaf_bh(path)->b_blocknr;
2832
2833	/* Start at the tree node just above the leaf and work our way up. */
2834	i = path->p_tree_depth - 1;
2835	while (i >= 0) {
2836	int next_free;
2837
2838	el = path->p_node[i].el;
2839
2840	/*
2841	* Find the extent record just after the one in our
2842	* path.
2843	*/
2844	next_free = le16_to_cpu(el->l_next_free_rec);
2845	for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
2846	if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
2847	if (j == (next_free - 1)) {
2848	if (i == 0) {
2849	/*
2850	* We've determined that the
2851	* path specified is already
2852	* the rightmost one - return a
2853	* cpos of zero.
2854	*/
2855	goto out;
2856	}
2857	/*
2858	* The rightmost record points to our
2859	* leaf - we need to travel up the
2860	* tree one level.
2861	*/
2862	goto next_node;
2863	}
2864
2865	*cpos = le32_to_cpu(el->l_recs[j + 1].e_cpos);
2866	goto out;
2867	}
2868	}
2869
2870	/*
2871	* If we got here, we never found a valid node where
2872	* the tree indicated one should be.
2873	*/
2874	ocfs2_error(sb, "Invalid extent tree at extent block %llu\n",
2875	(unsigned long long)blkno);
2876	ret = -EROFS;
2877	goto out;
2878
2879	next_node:
2880	blkno = path->p_node[i].bh->b_blocknr;
2881	i--;
2882	}
2883
2884	out:
2885	return ret;
2886	}
2887
2888	static int ocfs2_rotate_rightmost_leaf_left(handle_t *handle,
2889	struct ocfs2_extent_tree *et,
2890	struct ocfs2_path *path)
2891	{
2892	int ret;
2893	struct buffer_head *bh = path_leaf_bh(path);
2894	struct ocfs2_extent_list *el = path_leaf_el(path);
2895
2896	if (!ocfs2_is_empty_extent(rec: &el->l_recs[0]))
2897	return 0;
2898
2899	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci, path,
2900	path_num_items(path) - 1);
2901	if (ret) {
2902	mlog_errno(ret);
2903	goto out;
2904	}
2905
2906	ocfs2_remove_empty_extent(el);
2907	ocfs2_journal_dirty(handle, bh);
2908
2909	out:
2910	return ret;
2911	}
2912
2913	static int __ocfs2_rotate_tree_left(handle_t *handle,
2914	struct ocfs2_extent_tree *et,
2915	int orig_credits,
2916	struct ocfs2_path *path,
2917	struct ocfs2_cached_dealloc_ctxt *dealloc,
2918	struct ocfs2_path **empty_extent_path)
2919	{
2920	int ret, subtree_root, deleted;
2921	u32 right_cpos;
2922	struct ocfs2_path *left_path = NULL;
2923	struct ocfs2_path *right_path = NULL;
2924	struct super_block *sb = ocfs2_metadata_cache_get_super(ci: et->et_ci);
2925
2926	if (!ocfs2_is_empty_extent(rec: &(path_leaf_el(path)->l_recs[0])))
2927	return 0;
2928
2929	*empty_extent_path = NULL;
2930
2931	ret = ocfs2_find_cpos_for_right_leaf(sb, path, cpos: &right_cpos);
2932	if (ret) {
2933	mlog_errno(ret);
2934	goto out;
2935	}
2936
2937	left_path = ocfs2_new_path_from_path(path);
2938	if (!left_path) {
2939	ret = -ENOMEM;
2940	mlog_errno(ret);
2941	goto out;
2942	}
2943
2944	ocfs2_cp_path(dest: left_path, src: path);
2945
2946	right_path = ocfs2_new_path_from_path(path);
2947	if (!right_path) {
2948	ret = -ENOMEM;
2949	mlog_errno(ret);
2950	goto out;
2951	}
2952
2953	while (right_cpos) {
2954	ret = ocfs2_find_path(ci: et->et_ci, path: right_path, cpos: right_cpos);
2955	if (ret) {
2956	mlog_errno(ret);
2957	goto out;
2958	}
2959
2960	subtree_root = ocfs2_find_subtree_root(et, left: left_path,
2961	right: right_path);
2962
2963	trace_ocfs2_rotate_subtree(subtree_root,
2964	blkno: (unsigned long long)
2965	right_path->p_node[subtree_root].bh->b_blocknr,
2966	depth: right_path->p_tree_depth);
2967
2968	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: 0,
2969	op_credits: orig_credits, path: left_path);
2970	if (ret) {
2971	mlog_errno(ret);
2972	goto out;
2973	}
2974
2975	/*
2976	* Caller might still want to make changes to the
2977	* tree root, so re-add it to the journal here.
2978	*/
2979	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci,
2980	path: left_path, idx: 0);
2981	if (ret) {
2982	mlog_errno(ret);
2983	goto out;
2984	}
2985
2986	ret = ocfs2_rotate_subtree_left(handle, et, left_path,
2987	right_path, subtree_index: subtree_root,
2988	dealloc, deleted: &deleted);
2989	if (ret == -EAGAIN) {
2990	/*
2991	* The rotation has to temporarily stop due to
2992	* the right subtree having an empty
2993	* extent. Pass it back to the caller for a
2994	* fixup.
2995	*/
2996	*empty_extent_path = right_path;
2997	right_path = NULL;
2998	goto out;
2999	}
3000	if (ret) {
3001	mlog_errno(ret);
3002	goto out;
3003	}
3004
3005	/*
3006	* The subtree rotate might have removed records on
3007	* the rightmost edge. If so, then rotation is
3008	* complete.
3009	*/
3010	if (deleted)
3011	break;
3012
3013	ocfs2_mv_path(dest: left_path, src: right_path);
3014
3015	ret = ocfs2_find_cpos_for_right_leaf(sb, path: left_path,
3016	cpos: &right_cpos);
3017	if (ret) {
3018	mlog_errno(ret);
3019	goto out;
3020	}
3021	}
3022
3023	out:
3024	ocfs2_free_path(path: right_path);
3025	ocfs2_free_path(path: left_path);
3026
3027	return ret;
3028	}
3029
3030	static int ocfs2_remove_rightmost_path(handle_t *handle,
3031	struct ocfs2_extent_tree *et,
3032	struct ocfs2_path *path,
3033	struct ocfs2_cached_dealloc_ctxt *dealloc)
3034	{
3035	int ret, subtree_index;
3036	u32 cpos;
3037	struct ocfs2_path *left_path = NULL;
3038	struct ocfs2_extent_block *eb;
3039	struct ocfs2_extent_list *el;
3040
3041	ret = ocfs2_et_sanity_check(et);
3042	if (ret)
3043	goto out;
3044
3045	ret = ocfs2_journal_access_path(ci: et->et_ci, handle, path);
3046	if (ret) {
3047	mlog_errno(ret);
3048	goto out;
3049	}
3050
3051	ret = ocfs2_find_cpos_for_left_leaf(sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
3052	path, cpos: &cpos);
3053	if (ret) {
3054	mlog_errno(ret);
3055	goto out;
3056	}
3057
3058	if (cpos) {
3059	/*
3060	* We have a path to the left of this one - it needs
3061	* an update too.
3062	*/
3063	left_path = ocfs2_new_path_from_path(path);
3064	if (!left_path) {
3065	ret = -ENOMEM;
3066	mlog_errno(ret);
3067	goto out;
3068	}
3069
3070	ret = ocfs2_find_path(ci: et->et_ci, path: left_path, cpos);
3071	if (ret) {
3072	mlog_errno(ret);
3073	goto out;
3074	}
3075
3076	ret = ocfs2_journal_access_path(ci: et->et_ci, handle, path: left_path);
3077	if (ret) {
3078	mlog_errno(ret);
3079	goto out;
3080	}
3081
3082	subtree_index = ocfs2_find_subtree_root(et, left: left_path, right: path);
3083
3084	ocfs2_unlink_subtree(handle, et, left_path, right_path: path,
3085	subtree_index, dealloc);
3086	ret = ocfs2_update_edge_lengths(handle, et, path: left_path);
3087	if (ret) {
3088	mlog_errno(ret);
3089	goto out;
3090	}
3091
3092	eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
3093	ocfs2_et_set_last_eb_blk(et, le64_to_cpu(eb->h_blkno));
3094	} else {
3095	/*
3096	* 'path' is also the leftmost path which
3097	* means it must be the only one. This gets
3098	* handled differently because we want to
3099	* revert the root back to having extents
3100	* in-line.
3101	*/
3102	ocfs2_unlink_path(handle, et, dealloc, path, unlink_start: 1);
3103
3104	el = et->et_root_el;
3105	el->l_tree_depth = 0;
3106	el->l_next_free_rec = 0;
3107	memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
3108
3109	ocfs2_et_set_last_eb_blk(et, new_last_eb_blk: 0);
3110	}
3111
3112	ocfs2_journal_dirty(handle, path_root_bh(path));
3113
3114	out:
3115	ocfs2_free_path(path: left_path);
3116	return ret;
3117	}
3118
3119	static int ocfs2_remove_rightmost_empty_extent(struct ocfs2_super *osb,
3120	struct ocfs2_extent_tree *et,
3121	struct ocfs2_path *path,
3122	struct ocfs2_cached_dealloc_ctxt *dealloc)
3123	{
3124	handle_t *handle;
3125	int ret;
3126	int credits = path->p_tree_depth * 2 + 1;
3127
3128	handle = ocfs2_start_trans(osb, max_buffs: credits);
3129	if (IS_ERR(ptr: handle)) {
3130	ret = PTR_ERR(ptr: handle);
3131	mlog_errno(ret);
3132	return ret;
3133	}
3134
3135	ret = ocfs2_remove_rightmost_path(handle, et, path, dealloc);
3136	if (ret)
3137	mlog_errno(ret);
3138
3139	ocfs2_commit_trans(osb, handle);
3140	return ret;
3141	}
3142
3143	/*
3144	* Left rotation of btree records.
3145	*
3146	* In many ways, this is (unsurprisingly) the opposite of right
3147	* rotation. We start at some non-rightmost path containing an empty
3148	* extent in the leaf block. The code works its way to the rightmost
3149	* path by rotating records to the left in every subtree.
3150	*
3151	* This is used by any code which reduces the number of extent records
3152	* in a leaf. After removal, an empty record should be placed in the
3153	* leftmost list position.
3154	*
3155	* This won't handle a length update of the rightmost path records if
3156	* the rightmost tree leaf record is removed so the caller is
3157	* responsible for detecting and correcting that.
3158	*/
3159	static int ocfs2_rotate_tree_left(handle_t *handle,
3160	struct ocfs2_extent_tree *et,
3161	struct ocfs2_path *path,
3162	struct ocfs2_cached_dealloc_ctxt *dealloc)
3163	{
3164	int ret, orig_credits = jbd2_handle_buffer_credits(handle);
3165	struct ocfs2_path *tmp_path = NULL, *restart_path = NULL;
3166	struct ocfs2_extent_block *eb;
3167	struct ocfs2_extent_list *el;
3168
3169	el = path_leaf_el(path);
3170	if (!ocfs2_is_empty_extent(rec: &el->l_recs[0]))
3171	return 0;
3172
3173	if (path->p_tree_depth == 0) {
3174	rightmost_no_delete:
3175	/*
3176	* Inline extents. This is trivially handled, so do
3177	* it up front.
3178	*/
3179	ret = ocfs2_rotate_rightmost_leaf_left(handle, et, path);
3180	if (ret)
3181	mlog_errno(ret);
3182	goto out;
3183	}
3184
3185	/*
3186	* Handle rightmost branch now. There's several cases:
3187	* 1) simple rotation leaving records in there. That's trivial.
3188	* 2) rotation requiring a branch delete - there's no more
3189	* records left. Two cases of this:
3190	* a) There are branches to the left.
3191	* b) This is also the leftmost (the only) branch.
3192	*
3193	* 1) is handled via ocfs2_rotate_rightmost_leaf_left()
3194	* 2a) we need the left branch so that we can update it with the unlink
3195	* 2b) we need to bring the root back to inline extents.
3196	*/
3197
3198	eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
3199	el = &eb->h_list;
3200	if (eb->h_next_leaf_blk == 0) {
3201	/*
3202	* This gets a bit tricky if we're going to delete the
3203	* rightmost path. Get the other cases out of the way
3204	* 1st.
3205	*/
3206	if (le16_to_cpu(el->l_next_free_rec) > 1)
3207	goto rightmost_no_delete;
3208
3209	if (le16_to_cpu(el->l_next_free_rec) == 0) {
3210	ret = ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
3211	"Owner %llu has empty extent block at %llu\n",
3212	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
3213	(unsigned long long)le64_to_cpu(eb->h_blkno));
3214	goto out;
3215	}
3216
3217	/*
3218	* XXX: The caller can not trust "path" any more after
3219	* this as it will have been deleted. What do we do?
3220	*
3221	* In theory the rotate-for-merge code will never get
3222	* here because it'll always ask for a rotate in a
3223	* nonempty list.
3224	*/
3225
3226	ret = ocfs2_remove_rightmost_path(handle, et, path,
3227	dealloc);
3228	if (ret)
3229	mlog_errno(ret);
3230	goto out;
3231	}
3232
3233	/*
3234	* Now we can loop, remembering the path we get from -EAGAIN
3235	* and restarting from there.
3236	*/
3237	try_rotate:
3238	ret = __ocfs2_rotate_tree_left(handle, et, orig_credits, path,
3239	dealloc, empty_extent_path: &restart_path);
3240	if (ret && ret != -EAGAIN) {
3241	mlog_errno(ret);
3242	goto out;
3243	}
3244
3245	while (ret == -EAGAIN) {
3246	tmp_path = restart_path;
3247	restart_path = NULL;
3248
3249	ret = __ocfs2_rotate_tree_left(handle, et, orig_credits,
3250	path: tmp_path, dealloc,
3251	empty_extent_path: &restart_path);
3252	if (ret && ret != -EAGAIN) {
3253	mlog_errno(ret);
3254	goto out;
3255	}
3256
3257	ocfs2_free_path(path: tmp_path);
3258	tmp_path = NULL;
3259
3260	if (ret == 0)
3261	goto try_rotate;
3262	}
3263
3264	out:
3265	ocfs2_free_path(path: tmp_path);
3266	ocfs2_free_path(path: restart_path);
3267	return ret;
3268	}
3269
3270	static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el,
3271	int index)
3272	{
3273	struct ocfs2_extent_rec *rec = &el->l_recs[index];
3274	unsigned int size;
3275
3276	if (rec->e_leaf_clusters == 0) {
3277	/*
3278	* We consumed all of the merged-from record. An empty
3279	* extent cannot exist anywhere but the 1st array
3280	* position, so move things over if the merged-from
3281	* record doesn't occupy that position.
3282	*
3283	* This creates a new empty extent so the caller
3284	* should be smart enough to have removed any existing
3285	* ones.
3286	*/
3287	if (index > 0) {
3288	BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
3289	size = index * sizeof(struct ocfs2_extent_rec);
3290	memmove(&el->l_recs[1], &el->l_recs[0], size);
3291	}
3292
3293	/*
3294	* Always memset - the caller doesn't check whether it
3295	* created an empty extent, so there could be junk in
3296	* the other fields.
3297	*/
3298	memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
3299	}
3300	}
3301
3302	static int ocfs2_get_right_path(struct ocfs2_extent_tree *et,
3303	struct ocfs2_path *left_path,
3304	struct ocfs2_path **ret_right_path)
3305	{
3306	int ret;
3307	u32 right_cpos;
3308	struct ocfs2_path *right_path = NULL;
3309	struct ocfs2_extent_list *left_el;
3310
3311	*ret_right_path = NULL;
3312
3313	/* This function shouldn't be called for non-trees. */
3314	BUG_ON(left_path->p_tree_depth == 0);
3315
3316	left_el = path_leaf_el(left_path);
3317	BUG_ON(left_el->l_next_free_rec != left_el->l_count);
3318
3319	ret = ocfs2_find_cpos_for_right_leaf(sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
3320	path: left_path, cpos: &right_cpos);
3321	if (ret) {
3322	mlog_errno(ret);
3323	goto out;
3324	}
3325
3326	/* This function shouldn't be called for the rightmost leaf. */
3327	BUG_ON(right_cpos == 0);
3328
3329	right_path = ocfs2_new_path_from_path(path: left_path);
3330	if (!right_path) {
3331	ret = -ENOMEM;
3332	mlog_errno(ret);
3333	goto out;
3334	}
3335
3336	ret = ocfs2_find_path(ci: et->et_ci, path: right_path, cpos: right_cpos);
3337	if (ret) {
3338	mlog_errno(ret);
3339	goto out;
3340	}
3341
3342	*ret_right_path = right_path;
3343	out:
3344	if (ret)
3345	ocfs2_free_path(path: right_path);
3346	return ret;
3347	}
3348
3349	/*
3350	* Remove split_rec clusters from the record at index and merge them
3351	* onto the beginning of the record "next" to it.
3352	* For index < l_count - 1, the next means the extent rec at index + 1.
3353	* For index == l_count - 1, the "next" means the 1st extent rec of the
3354	* next extent block.
3355	*/
3356	static int ocfs2_merge_rec_right(struct ocfs2_path *left_path,
3357	handle_t *handle,
3358	struct ocfs2_extent_tree *et,
3359	struct ocfs2_extent_rec *split_rec,
3360	int index)
3361	{
3362	int ret, next_free, i;
3363	unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3364	struct ocfs2_extent_rec *left_rec;
3365	struct ocfs2_extent_rec *right_rec;
3366	struct ocfs2_extent_list *right_el;
3367	struct ocfs2_path *right_path = NULL;
3368	int subtree_index = 0;
3369	struct ocfs2_extent_list *el = path_leaf_el(left_path);
3370	struct buffer_head *bh = path_leaf_bh(left_path);
3371	struct buffer_head *root_bh = NULL;
3372
3373	BUG_ON(index >= le16_to_cpu(el->l_next_free_rec));
3374	left_rec = &el->l_recs[index];
3375
3376	if (index == le16_to_cpu(el->l_next_free_rec) - 1 &&
3377	le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count)) {
3378	/* we meet with a cross extent block merge. */
3379	ret = ocfs2_get_right_path(et, left_path, ret_right_path: &right_path);
3380	if (ret) {
3381	mlog_errno(ret);
3382	return ret;
3383	}
3384
3385	right_el = path_leaf_el(right_path);
3386	next_free = le16_to_cpu(right_el->l_next_free_rec);
3387	BUG_ON(next_free <= 0);
3388	right_rec = &right_el->l_recs[0];
3389	if (ocfs2_is_empty_extent(rec: right_rec)) {
3390	BUG_ON(next_free <= 1);
3391	right_rec = &right_el->l_recs[1];
3392	}
3393
3394	BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3395	le16_to_cpu(left_rec->e_leaf_clusters) !=
3396	le32_to_cpu(right_rec->e_cpos));
3397
3398	subtree_index = ocfs2_find_subtree_root(et, left: left_path,
3399	right: right_path);
3400
3401	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: subtree_index,
3402	op_credits: jbd2_handle_buffer_credits(handle),
3403	path: right_path);
3404	if (ret) {
3405	mlog_errno(ret);
3406	goto out;
3407	}
3408
3409	root_bh = left_path->p_node[subtree_index].bh;
3410	BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3411
3412	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci, path: right_path,
3413	idx: subtree_index);
3414	if (ret) {
3415	mlog_errno(ret);
3416	goto out;
3417	}
3418
3419	for (i = subtree_index + 1;
3420	i < path_num_items(right_path); i++) {
3421	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci,
3422	path: right_path, idx: i);
3423	if (ret) {
3424	mlog_errno(ret);
3425	goto out;
3426	}
3427
3428	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci,
3429	path: left_path, idx: i);
3430	if (ret) {
3431	mlog_errno(ret);
3432	goto out;
3433	}
3434	}
3435
3436	} else {
3437	BUG_ON(index == le16_to_cpu(el->l_next_free_rec) - 1);
3438	right_rec = &el->l_recs[index + 1];
3439	}
3440
3441	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci, path: left_path,
3442	path_num_items(left_path) - 1);
3443	if (ret) {
3444	mlog_errno(ret);
3445	goto out;
3446	}
3447
3448	le16_add_cpu(var: &left_rec->e_leaf_clusters, val: -split_clusters);
3449
3450	le32_add_cpu(var: &right_rec->e_cpos, val: -split_clusters);
3451	le64_add_cpu(var: &right_rec->e_blkno,
3452	val: -ocfs2_clusters_to_blocks(sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
3453	clusters: split_clusters));
3454	le16_add_cpu(var: &right_rec->e_leaf_clusters, val: split_clusters);
3455
3456	ocfs2_cleanup_merge(el, index);
3457
3458	ocfs2_journal_dirty(handle, bh);
3459	if (right_path) {
3460	ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
3461	ocfs2_complete_edge_insert(handle, left_path, right_path,
3462	subtree_index);
3463	}
3464	out:
3465	ocfs2_free_path(path: right_path);
3466	return ret;
3467	}
3468
3469	static int ocfs2_get_left_path(struct ocfs2_extent_tree *et,
3470	struct ocfs2_path *right_path,
3471	struct ocfs2_path **ret_left_path)
3472	{
3473	int ret;
3474	u32 left_cpos;
3475	struct ocfs2_path *left_path = NULL;
3476
3477	*ret_left_path = NULL;
3478
3479	/* This function shouldn't be called for non-trees. */
3480	BUG_ON(right_path->p_tree_depth == 0);
3481
3482	ret = ocfs2_find_cpos_for_left_leaf(sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
3483	path: right_path, cpos: &left_cpos);
3484	if (ret) {
3485	mlog_errno(ret);
3486	goto out;
3487	}
3488
3489	/* This function shouldn't be called for the leftmost leaf. */
3490	BUG_ON(left_cpos == 0);
3491
3492	left_path = ocfs2_new_path_from_path(path: right_path);
3493	if (!left_path) {
3494	ret = -ENOMEM;
3495	mlog_errno(ret);
3496	goto out;
3497	}
3498
3499	ret = ocfs2_find_path(ci: et->et_ci, path: left_path, cpos: left_cpos);
3500	if (ret) {
3501	mlog_errno(ret);
3502	goto out;
3503	}
3504
3505	*ret_left_path = left_path;
3506	out:
3507	if (ret)
3508	ocfs2_free_path(path: left_path);
3509	return ret;
3510	}
3511
3512	/*
3513	* Remove split_rec clusters from the record at index and merge them
3514	* onto the tail of the record "before" it.
3515	* For index > 0, the "before" means the extent rec at index - 1.
3516	*
3517	* For index == 0, the "before" means the last record of the previous
3518	* extent block. And there is also a situation that we may need to
3519	* remove the rightmost leaf extent block in the right_path and change
3520	* the right path to indicate the new rightmost path.
3521	*/
3522	static int ocfs2_merge_rec_left(struct ocfs2_path *right_path,
3523	handle_t *handle,
3524	struct ocfs2_extent_tree *et,
3525	struct ocfs2_extent_rec *split_rec,
3526	struct ocfs2_cached_dealloc_ctxt *dealloc,
3527	int index)
3528	{
3529	int ret, i, subtree_index = 0, has_empty_extent = 0;
3530	unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
3531	struct ocfs2_extent_rec *left_rec;
3532	struct ocfs2_extent_rec *right_rec;
3533	struct ocfs2_extent_list *el = path_leaf_el(right_path);
3534	struct buffer_head *bh = path_leaf_bh(right_path);
3535	struct buffer_head *root_bh = NULL;
3536	struct ocfs2_path *left_path = NULL;
3537	struct ocfs2_extent_list *left_el;
3538
3539	BUG_ON(index < 0);
3540
3541	right_rec = &el->l_recs[index];
3542	if (index == 0) {
3543	/* we meet with a cross extent block merge. */
3544	ret = ocfs2_get_left_path(et, right_path, ret_left_path: &left_path);
3545	if (ret) {
3546	mlog_errno(ret);
3547	return ret;
3548	}
3549
3550	left_el = path_leaf_el(left_path);
3551	BUG_ON(le16_to_cpu(left_el->l_next_free_rec) !=
3552	le16_to_cpu(left_el->l_count));
3553
3554	left_rec = &left_el->l_recs[
3555	le16_to_cpu(left_el->l_next_free_rec) - 1];
3556	BUG_ON(le32_to_cpu(left_rec->e_cpos) +
3557	le16_to_cpu(left_rec->e_leaf_clusters) !=
3558	le32_to_cpu(split_rec->e_cpos));
3559
3560	subtree_index = ocfs2_find_subtree_root(et, left: left_path,
3561	right: right_path);
3562
3563	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: subtree_index,
3564	op_credits: jbd2_handle_buffer_credits(handle),
3565	path: left_path);
3566	if (ret) {
3567	mlog_errno(ret);
3568	goto out;
3569	}
3570
3571	root_bh = left_path->p_node[subtree_index].bh;
3572	BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
3573
3574	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci, path: right_path,
3575	idx: subtree_index);
3576	if (ret) {
3577	mlog_errno(ret);
3578	goto out;
3579	}
3580
3581	for (i = subtree_index + 1;
3582	i < path_num_items(right_path); i++) {
3583	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci,
3584	path: right_path, idx: i);
3585	if (ret) {
3586	mlog_errno(ret);
3587	goto out;
3588	}
3589
3590	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci,
3591	path: left_path, idx: i);
3592	if (ret) {
3593	mlog_errno(ret);
3594	goto out;
3595	}
3596	}
3597	} else {
3598	left_rec = &el->l_recs[index - 1];
3599	if (ocfs2_is_empty_extent(rec: &el->l_recs[0]))
3600	has_empty_extent = 1;
3601	}
3602
3603	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci, path: right_path,
3604	path_num_items(right_path) - 1);
3605	if (ret) {
3606	mlog_errno(ret);
3607	goto out;
3608	}
3609
3610	if (has_empty_extent && index == 1) {
3611	/*
3612	* The easy case - we can just plop the record right in.
3613	*/
3614	*left_rec = *split_rec;
3615	} else
3616	le16_add_cpu(var: &left_rec->e_leaf_clusters, val: split_clusters);
3617
3618	le32_add_cpu(var: &right_rec->e_cpos, val: split_clusters);
3619	le64_add_cpu(var: &right_rec->e_blkno,
3620	val: ocfs2_clusters_to_blocks(sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
3621	clusters: split_clusters));
3622	le16_add_cpu(var: &right_rec->e_leaf_clusters, val: -split_clusters);
3623
3624	ocfs2_cleanup_merge(el, index);
3625
3626	ocfs2_journal_dirty(handle, bh);
3627	if (left_path) {
3628	ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
3629
3630	/*
3631	* In the situation that the right_rec is empty and the extent
3632	* block is empty also, ocfs2_complete_edge_insert can't handle
3633	* it and we need to delete the right extent block.
3634	*/
3635	if (le16_to_cpu(right_rec->e_leaf_clusters) == 0 &&
3636	le16_to_cpu(el->l_next_free_rec) == 1) {
3637	/* extend credit for ocfs2_remove_rightmost_path */
3638	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: 0,
3639	op_credits: jbd2_handle_buffer_credits(handle),
3640	path: right_path);
3641	if (ret) {
3642	mlog_errno(ret);
3643	goto out;
3644	}
3645
3646	ret = ocfs2_remove_rightmost_path(handle, et,
3647	path: right_path,
3648	dealloc);
3649	if (ret) {
3650	mlog_errno(ret);
3651	goto out;
3652	}
3653
3654	/* Now the rightmost extent block has been deleted.
3655	* So we use the new rightmost path.
3656	*/
3657	ocfs2_mv_path(dest: right_path, src: left_path);
3658	} else
3659	ocfs2_complete_edge_insert(handle, left_path,
3660	right_path, subtree_index);
3661	}
3662	out:
3663	ocfs2_free_path(path: left_path);
3664	return ret;
3665	}
3666
3667	static int ocfs2_try_to_merge_extent(handle_t *handle,
3668	struct ocfs2_extent_tree *et,
3669	struct ocfs2_path *path,
3670	int split_index,
3671	struct ocfs2_extent_rec *split_rec,
3672	struct ocfs2_cached_dealloc_ctxt *dealloc,
3673	struct ocfs2_merge_ctxt *ctxt)
3674	{
3675	int ret = 0;
3676	struct ocfs2_extent_list *el = path_leaf_el(path);
3677	struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
3678
3679	BUG_ON(ctxt->c_contig_type == CONTIG_NONE);
3680
3681	if (ctxt->c_split_covers_rec && ctxt->c_has_empty_extent) {
3682	/* extend credit for ocfs2_remove_rightmost_path */
3683	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: 0,
3684	op_credits: jbd2_handle_buffer_credits(handle),
3685	path);
3686	if (ret) {
3687	mlog_errno(ret);
3688	goto out;
3689	}
3690	/*
3691	* The merge code will need to create an empty
3692	* extent to take the place of the newly
3693	* emptied slot. Remove any pre-existing empty
3694	* extents - having more than one in a leaf is
3695	* illegal.
3696	*/
3697	ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3698	if (ret) {
3699	mlog_errno(ret);
3700	goto out;
3701	}
3702	split_index--;
3703	rec = &el->l_recs[split_index];
3704	}
3705
3706	if (ctxt->c_contig_type == CONTIG_LEFTRIGHT) {
3707	/*
3708	* Left-right contig implies this.
3709	*/
3710	BUG_ON(!ctxt->c_split_covers_rec);
3711
3712	/*
3713	* Since the leftright insert always covers the entire
3714	* extent, this call will delete the insert record
3715	* entirely, resulting in an empty extent record added to
3716	* the extent block.
3717	*
3718	* Since the adding of an empty extent shifts
3719	* everything back to the right, there's no need to
3720	* update split_index here.
3721	*
3722	* When the split_index is zero, we need to merge it to the
3723	* previous extent block. It is more efficient and easier
3724	* if we do merge_right first and merge_left later.
3725	*/
3726	ret = ocfs2_merge_rec_right(left_path: path, handle, et, split_rec,
3727	index: split_index);
3728	if (ret) {
3729	mlog_errno(ret);
3730	goto out;
3731	}
3732
3733	/*
3734	* We can only get this from logic error above.
3735	*/
3736	BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0]));
3737
3738	/* extend credit for ocfs2_remove_rightmost_path */
3739	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: 0,
3740	op_credits: jbd2_handle_buffer_credits(handle),
3741	path);
3742	if (ret) {
3743	mlog_errno(ret);
3744	goto out;
3745	}
3746
3747	/* The merge left us with an empty extent, remove it. */
3748	ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3749	if (ret) {
3750	mlog_errno(ret);
3751	goto out;
3752	}
3753
3754	rec = &el->l_recs[split_index];
3755
3756	/*
3757	* Note that we don't pass split_rec here on purpose -
3758	* we've merged it into the rec already.
3759	*/
3760	ret = ocfs2_merge_rec_left(right_path: path, handle, et, split_rec: rec,
3761	dealloc, index: split_index);
3762
3763	if (ret) {
3764	mlog_errno(ret);
3765	goto out;
3766	}
3767
3768	/* extend credit for ocfs2_remove_rightmost_path */
3769	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: 0,
3770	op_credits: jbd2_handle_buffer_credits(handle),
3771	path);
3772	if (ret) {
3773	mlog_errno(ret);
3774	goto out;
3775	}
3776
3777	ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
3778	/*
3779	* Error from this last rotate is not critical, so
3780	* print but don't bubble it up.
3781	*/
3782	if (ret)
3783	mlog_errno(ret);
3784	ret = 0;
3785	} else {
3786	/*
3787	* Merge a record to the left or right.
3788	*
3789	* 'contig_type' is relative to the existing record,
3790	* so for example, if we're "right contig", it's to
3791	* the record on the left (hence the left merge).
3792	*/
3793	if (ctxt->c_contig_type == CONTIG_RIGHT) {
3794	ret = ocfs2_merge_rec_left(right_path: path, handle, et,
3795	split_rec, dealloc,
3796	index: split_index);
3797	if (ret) {
3798	mlog_errno(ret);
3799	goto out;
3800	}
3801	} else {
3802	ret = ocfs2_merge_rec_right(left_path: path, handle,
3803	et, split_rec,
3804	index: split_index);
3805	if (ret) {
3806	mlog_errno(ret);
3807	goto out;
3808	}
3809	}
3810
3811	if (ctxt->c_split_covers_rec) {
3812	/* extend credit for ocfs2_remove_rightmost_path */
3813	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: 0,
3814	op_credits: jbd2_handle_buffer_credits(handle),
3815	path);
3816	if (ret) {
3817	mlog_errno(ret);
3818	ret = 0;
3819	goto out;
3820	}
3821
3822	/*
3823	* The merge may have left an empty extent in
3824	* our leaf. Try to rotate it away.
3825	*/
3826	ret = ocfs2_rotate_tree_left(handle, et, path,
3827	dealloc);
3828	if (ret)
3829	mlog_errno(ret);
3830	ret = 0;
3831	}
3832	}
3833
3834	out:
3835	return ret;
3836	}
3837
3838	static void ocfs2_subtract_from_rec(struct super_block *sb,
3839	enum ocfs2_split_type split,
3840	struct ocfs2_extent_rec *rec,
3841	struct ocfs2_extent_rec *split_rec)
3842	{
3843	u64 len_blocks;
3844
3845	len_blocks = ocfs2_clusters_to_blocks(sb,
3846	le16_to_cpu(split_rec->e_leaf_clusters));
3847
3848	if (split == SPLIT_LEFT) {
3849	/*
3850	* Region is on the left edge of the existing
3851	* record.
3852	*/
3853	le32_add_cpu(var: &rec->e_cpos,
3854	le16_to_cpu(split_rec->e_leaf_clusters));
3855	le64_add_cpu(var: &rec->e_blkno, val: len_blocks);
3856	le16_add_cpu(var: &rec->e_leaf_clusters,
3857	val: -le16_to_cpu(split_rec->e_leaf_clusters));
3858	} else {
3859	/*
3860	* Region is on the right edge of the existing
3861	* record.
3862	*/
3863	le16_add_cpu(var: &rec->e_leaf_clusters,
3864	val: -le16_to_cpu(split_rec->e_leaf_clusters));
3865	}
3866	}
3867
3868	/*
3869	* Do the final bits of extent record insertion at the target leaf
3870	* list. If this leaf is part of an allocation tree, it is assumed
3871	* that the tree above has been prepared.
3872	*/
3873	static void ocfs2_insert_at_leaf(struct ocfs2_extent_tree *et,
3874	struct ocfs2_extent_rec *insert_rec,
3875	struct ocfs2_extent_list *el,
3876	struct ocfs2_insert_type *insert)
3877	{
3878	int i = insert->ins_contig_index;
3879	unsigned int range;
3880	struct ocfs2_extent_rec *rec;
3881
3882	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
3883
3884	if (insert->ins_split != SPLIT_NONE) {
3885	i = ocfs2_search_extent_list(el, le32_to_cpu(insert_rec->e_cpos));
3886	BUG_ON(i == -1);
3887	rec = &el->l_recs[i];
3888	ocfs2_subtract_from_rec(sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
3889	split: insert->ins_split, rec,
3890	split_rec: insert_rec);
3891	goto rotate;
3892	}
3893
3894	/*
3895	* Contiguous insert - either left or right.
3896	*/
3897	if (insert->ins_contig != CONTIG_NONE) {
3898	rec = &el->l_recs[i];
3899	if (insert->ins_contig == CONTIG_LEFT) {
3900	rec->e_blkno = insert_rec->e_blkno;
3901	rec->e_cpos = insert_rec->e_cpos;
3902	}
3903	le16_add_cpu(var: &rec->e_leaf_clusters,
3904	le16_to_cpu(insert_rec->e_leaf_clusters));
3905	return;
3906	}
3907
3908	/*
3909	* Handle insert into an empty leaf.
3910	*/
3911	if (le16_to_cpu(el->l_next_free_rec) == 0 ||
3912	((le16_to_cpu(el->l_next_free_rec) == 1) &&
3913	ocfs2_is_empty_extent(rec: &el->l_recs[0]))) {
3914	el->l_recs[0] = *insert_rec;
3915	el->l_next_free_rec = cpu_to_le16(1);
3916	return;
3917	}
3918
3919	/*
3920	* Appending insert.
3921	*/
3922	if (insert->ins_appending == APPEND_TAIL) {
3923	i = le16_to_cpu(el->l_next_free_rec) - 1;
3924	rec = &el->l_recs[i];
3925	range = le32_to_cpu(rec->e_cpos)
3926	+ le16_to_cpu(rec->e_leaf_clusters);
3927	BUG_ON(le32_to_cpu(insert_rec->e_cpos) < range);
3928
3929	mlog_bug_on_msg(le16_to_cpu(el->l_next_free_rec) >=
3930	le16_to_cpu(el->l_count),
3931	"owner %llu, depth %u, count %u, next free %u, "
3932	"rec.cpos %u, rec.clusters %u, "
3933	"insert.cpos %u, insert.clusters %u\n",
3934	ocfs2_metadata_cache_owner(et->et_ci),
3935	le16_to_cpu(el->l_tree_depth),
3936	le16_to_cpu(el->l_count),
3937	le16_to_cpu(el->l_next_free_rec),
3938	le32_to_cpu(el->l_recs[i].e_cpos),
3939	le16_to_cpu(el->l_recs[i].e_leaf_clusters),
3940	le32_to_cpu(insert_rec->e_cpos),
3941	le16_to_cpu(insert_rec->e_leaf_clusters));
3942	i++;
3943	el->l_recs[i] = *insert_rec;
3944	le16_add_cpu(var: &el->l_next_free_rec, val: 1);
3945	return;
3946	}
3947
3948	rotate:
3949	/*
3950	* Ok, we have to rotate.
3951	*
3952	* At this point, it is safe to assume that inserting into an
3953	* empty leaf and appending to a leaf have both been handled
3954	* above.
3955	*
3956	* This leaf needs to have space, either by the empty 1st
3957	* extent record, or by virtue of an l_next_free_rec < l_count.
3958	*/
3959	ocfs2_rotate_leaf(el, insert_rec);
3960	}
3961
3962	static void ocfs2_adjust_rightmost_records(handle_t *handle,
3963	struct ocfs2_extent_tree *et,
3964	struct ocfs2_path *path,
3965	struct ocfs2_extent_rec *insert_rec)
3966	{
3967	int i, next_free;
3968	struct buffer_head *bh;
3969	struct ocfs2_extent_list *el;
3970	struct ocfs2_extent_rec *rec;
3971
3972	/*
3973	* Update everything except the leaf block.
3974	*/
3975	for (i = 0; i < path->p_tree_depth; i++) {
3976	bh = path->p_node[i].bh;
3977	el = path->p_node[i].el;
3978
3979	next_free = le16_to_cpu(el->l_next_free_rec);
3980	if (next_free == 0) {
3981	ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
3982	"Owner %llu has a bad extent list\n",
3983	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci));
3984	return;
3985	}
3986
3987	rec = &el->l_recs[next_free - 1];
3988
3989	rec->e_int_clusters = insert_rec->e_cpos;
3990	le32_add_cpu(var: &rec->e_int_clusters,
3991	le16_to_cpu(insert_rec->e_leaf_clusters));
3992	le32_add_cpu(var: &rec->e_int_clusters,
3993	val: -le32_to_cpu(rec->e_cpos));
3994
3995	ocfs2_journal_dirty(handle, bh);
3996	}
3997	}
3998
3999	static int ocfs2_append_rec_to_path(handle_t *handle,
4000	struct ocfs2_extent_tree *et,
4001	struct ocfs2_extent_rec *insert_rec,
4002	struct ocfs2_path *right_path,
4003	struct ocfs2_path **ret_left_path)
4004	{
4005	int ret, next_free;
4006	struct ocfs2_extent_list *el;
4007	struct ocfs2_path *left_path = NULL;
4008
4009	*ret_left_path = NULL;
4010
4011	/*
4012	* This shouldn't happen for non-trees. The extent rec cluster
4013	* count manipulation below only works for interior nodes.
4014	*/
4015	BUG_ON(right_path->p_tree_depth == 0);
4016
4017	/*
4018	* If our appending insert is at the leftmost edge of a leaf,
4019	* then we might need to update the rightmost records of the
4020	* neighboring path.
4021	*/
4022	el = path_leaf_el(right_path);
4023	next_free = le16_to_cpu(el->l_next_free_rec);
4024	if (next_free == 0 ||
4025	(next_free == 1 && ocfs2_is_empty_extent(rec: &el->l_recs[0]))) {
4026	u32 left_cpos;
4027
4028	ret = ocfs2_find_cpos_for_left_leaf(sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
4029	path: right_path, cpos: &left_cpos);
4030	if (ret) {
4031	mlog_errno(ret);
4032	goto out;
4033	}
4034
4035	trace_ocfs2_append_rec_to_path(
4036	owner: (unsigned long long)
4037	ocfs2_metadata_cache_owner(ci: et->et_ci),
4038	le32_to_cpu(insert_rec->e_cpos),
4039	value2: left_cpos);
4040
4041	/*
4042	* No need to worry if the append is already in the
4043	* leftmost leaf.
4044	*/
4045	if (left_cpos) {
4046	left_path = ocfs2_new_path_from_path(path: right_path);
4047	if (!left_path) {
4048	ret = -ENOMEM;
4049	mlog_errno(ret);
4050	goto out;
4051	}
4052
4053	ret = ocfs2_find_path(ci: et->et_ci, path: left_path,
4054	cpos: left_cpos);
4055	if (ret) {
4056	mlog_errno(ret);
4057	goto out;
4058	}
4059
4060	/*
4061	* ocfs2_insert_path() will pass the left_path to the
4062	* journal for us.
4063	*/
4064	}
4065	}
4066
4067	ret = ocfs2_journal_access_path(ci: et->et_ci, handle, path: right_path);
4068	if (ret) {
4069	mlog_errno(ret);
4070	goto out;
4071	}
4072
4073	ocfs2_adjust_rightmost_records(handle, et, path: right_path, insert_rec);
4074
4075	*ret_left_path = left_path;
4076	ret = 0;
4077	out:
4078	if (ret != 0)
4079	ocfs2_free_path(path: left_path);
4080
4081	return ret;
4082	}
4083
4084	static void ocfs2_split_record(struct ocfs2_extent_tree *et,
4085	struct ocfs2_path *left_path,
4086	struct ocfs2_path *right_path,
4087	struct ocfs2_extent_rec *split_rec,
4088	enum ocfs2_split_type split)
4089	{
4090	int index;
4091	u32 cpos = le32_to_cpu(split_rec->e_cpos);
4092	struct ocfs2_extent_list *left_el = NULL, *right_el, *insert_el, *el;
4093	struct ocfs2_extent_rec *rec, *tmprec;
4094
4095	right_el = path_leaf_el(right_path);
4096	if (left_path)
4097	left_el = path_leaf_el(left_path);
4098
4099	el = right_el;
4100	insert_el = right_el;
4101	index = ocfs2_search_extent_list(el, v_cluster: cpos);
4102	if (index != -1) {
4103	if (index == 0 && left_path) {
4104	BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
4105
4106	/*
4107	* This typically means that the record
4108	* started in the left path but moved to the
4109	* right as a result of rotation. We either
4110	* move the existing record to the left, or we
4111	* do the later insert there.
4112	*
4113	* In this case, the left path should always
4114	* exist as the rotate code will have passed
4115	* it back for a post-insert update.
4116	*/
4117
4118	if (split == SPLIT_LEFT) {
4119	/*
4120	* It's a left split. Since we know
4121	* that the rotate code gave us an
4122	* empty extent in the left path, we
4123	* can just do the insert there.
4124	*/
4125	insert_el = left_el;
4126	} else {
4127	/*
4128	* Right split - we have to move the
4129	* existing record over to the left
4130	* leaf. The insert will be into the
4131	* newly created empty extent in the
4132	* right leaf.
4133	*/
4134	tmprec = &right_el->l_recs[index];
4135	ocfs2_rotate_leaf(el: left_el, insert_rec: tmprec);
4136	el = left_el;
4137
4138	memset(tmprec, 0, sizeof(*tmprec));
4139	index = ocfs2_search_extent_list(el: left_el, v_cluster: cpos);
4140	BUG_ON(index == -1);
4141	}
4142	}
4143	} else {
4144	BUG_ON(!left_path);
4145	BUG_ON(!ocfs2_is_empty_extent(&left_el->l_recs[0]));
4146	/*
4147	* Left path is easy - we can just allow the insert to
4148	* happen.
4149	*/
4150	el = left_el;
4151	insert_el = left_el;
4152	index = ocfs2_search_extent_list(el, v_cluster: cpos);
4153	BUG_ON(index == -1);
4154	}
4155
4156	rec = &el->l_recs[index];
4157	ocfs2_subtract_from_rec(sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
4158	split, rec, split_rec);
4159	ocfs2_rotate_leaf(el: insert_el, insert_rec: split_rec);
4160	}
4161
4162	/*
4163	* This function only does inserts on an allocation b-tree. For tree
4164	* depth = 0, ocfs2_insert_at_leaf() is called directly.
4165	*
4166	* right_path is the path we want to do the actual insert
4167	* in. left_path should only be passed in if we need to update that
4168	* portion of the tree after an edge insert.
4169	*/
4170	static int ocfs2_insert_path(handle_t *handle,
4171	struct ocfs2_extent_tree *et,
4172	struct ocfs2_path *left_path,
4173	struct ocfs2_path *right_path,
4174	struct ocfs2_extent_rec *insert_rec,
4175	struct ocfs2_insert_type *insert)
4176	{
4177	int ret, subtree_index;
4178	struct buffer_head *leaf_bh = path_leaf_bh(right_path);
4179
4180	if (left_path) {
4181	/*
4182	* There's a chance that left_path got passed back to
4183	* us without being accounted for in the
4184	* journal. Extend our transaction here to be sure we
4185	* can change those blocks.
4186	*/
4187	ret = ocfs2_extend_trans(handle, nblocks: left_path->p_tree_depth);
4188	if (ret < 0) {
4189	mlog_errno(ret);
4190	goto out;
4191	}
4192
4193	ret = ocfs2_journal_access_path(ci: et->et_ci, handle, path: left_path);
4194	if (ret < 0) {
4195	mlog_errno(ret);
4196	goto out;
4197	}
4198	}
4199
4200	/*
4201	* Pass both paths to the journal. The majority of inserts
4202	* will be touching all components anyway.
4203	*/
4204	ret = ocfs2_journal_access_path(ci: et->et_ci, handle, path: right_path);
4205	if (ret < 0) {
4206	mlog_errno(ret);
4207	goto out;
4208	}
4209
4210	if (insert->ins_split != SPLIT_NONE) {
4211	/*
4212	* We could call ocfs2_insert_at_leaf() for some types
4213	* of splits, but it's easier to just let one separate
4214	* function sort it all out.
4215	*/
4216	ocfs2_split_record(et, left_path, right_path,
4217	split_rec: insert_rec, split: insert->ins_split);
4218
4219	/*
4220	* Split might have modified either leaf and we don't
4221	* have a guarantee that the later edge insert will
4222	* dirty this for us.
4223	*/
4224	if (left_path)
4225	ocfs2_journal_dirty(handle,
4226	path_leaf_bh(left_path));
4227	} else
4228	ocfs2_insert_at_leaf(et, insert_rec, path_leaf_el(right_path),
4229	insert);
4230
4231	ocfs2_journal_dirty(handle, bh: leaf_bh);
4232
4233	if (left_path) {
4234	/*
4235	* The rotate code has indicated that we need to fix
4236	* up portions of the tree after the insert.
4237	*
4238	* XXX: Should we extend the transaction here?
4239	*/
4240	subtree_index = ocfs2_find_subtree_root(et, left: left_path,
4241	right: right_path);
4242	ocfs2_complete_edge_insert(handle, left_path, right_path,
4243	subtree_index);
4244	}
4245
4246	ret = 0;
4247	out:
4248	return ret;
4249	}
4250
4251	static int ocfs2_do_insert_extent(handle_t *handle,
4252	struct ocfs2_extent_tree *et,
4253	struct ocfs2_extent_rec *insert_rec,
4254	struct ocfs2_insert_type *type)
4255	{
4256	int ret, rotate = 0;
4257	u32 cpos;
4258	struct ocfs2_path *right_path = NULL;
4259	struct ocfs2_path *left_path = NULL;
4260	struct ocfs2_extent_list *el;
4261
4262	el = et->et_root_el;
4263
4264	ret = ocfs2_et_root_journal_access(handle, et,
4265	OCFS2_JOURNAL_ACCESS_WRITE);
4266	if (ret) {
4267	mlog_errno(ret);
4268	goto out;
4269	}
4270
4271	if (le16_to_cpu(el->l_tree_depth) == 0) {
4272	ocfs2_insert_at_leaf(et, insert_rec, el, insert: type);
4273	goto out_update_clusters;
4274	}
4275
4276	right_path = ocfs2_new_path_from_et(et);
4277	if (!right_path) {
4278	ret = -ENOMEM;
4279	mlog_errno(ret);
4280	goto out;
4281	}
4282
4283	/*
4284	* Determine the path to start with. Rotations need the
4285	* rightmost path, everything else can go directly to the
4286	* target leaf.
4287	*/
4288	cpos = le32_to_cpu(insert_rec->e_cpos);
4289	if (type->ins_appending == APPEND_NONE &&
4290	type->ins_contig == CONTIG_NONE) {
4291	rotate = 1;
4292	cpos = UINT_MAX;
4293	}
4294
4295	ret = ocfs2_find_path(ci: et->et_ci, path: right_path, cpos);
4296	if (ret) {
4297	mlog_errno(ret);
4298	goto out;
4299	}
4300
4301	/*
4302	* Rotations and appends need special treatment - they modify
4303	* parts of the tree's above them.
4304	*
4305	* Both might pass back a path immediate to the left of the
4306	* one being inserted to. This will be cause
4307	* ocfs2_insert_path() to modify the rightmost records of
4308	* left_path to account for an edge insert.
4309	*
4310	* XXX: When modifying this code, keep in mind that an insert
4311	* can wind up skipping both of these two special cases...
4312	*/
4313	if (rotate) {
4314	ret = ocfs2_rotate_tree_right(handle, et, split: type->ins_split,
4315	le32_to_cpu(insert_rec->e_cpos),
4316	right_path, ret_left_path: &left_path);
4317	if (ret) {
4318	mlog_errno(ret);
4319	goto out;
4320	}
4321
4322	/*
4323	* ocfs2_rotate_tree_right() might have extended the
4324	* transaction without re-journaling our tree root.
4325	*/
4326	ret = ocfs2_et_root_journal_access(handle, et,
4327	OCFS2_JOURNAL_ACCESS_WRITE);
4328	if (ret) {
4329	mlog_errno(ret);
4330	goto out;
4331	}
4332	} else if (type->ins_appending == APPEND_TAIL
4333	&& type->ins_contig != CONTIG_LEFT) {
4334	ret = ocfs2_append_rec_to_path(handle, et, insert_rec,
4335	right_path, ret_left_path: &left_path);
4336	if (ret) {
4337	mlog_errno(ret);
4338	goto out;
4339	}
4340	}
4341
4342	ret = ocfs2_insert_path(handle, et, left_path, right_path,
4343	insert_rec, insert: type);
4344	if (ret) {
4345	mlog_errno(ret);
4346	goto out;
4347	}
4348
4349	out_update_clusters:
4350	if (type->ins_split == SPLIT_NONE)
4351	ocfs2_et_update_clusters(et,
4352	le16_to_cpu(insert_rec->e_leaf_clusters));
4353
4354	ocfs2_journal_dirty(handle, bh: et->et_root_bh);
4355
4356	out:
4357	ocfs2_free_path(path: left_path);
4358	ocfs2_free_path(path: right_path);
4359
4360	return ret;
4361	}
4362
4363	static int ocfs2_figure_merge_contig_type(struct ocfs2_extent_tree *et,
4364	struct ocfs2_path *path,
4365	struct ocfs2_extent_list *el, int index,
4366	struct ocfs2_extent_rec *split_rec,
4367	struct ocfs2_merge_ctxt *ctxt)
4368	{
4369	int status = 0;
4370	enum ocfs2_contig_type ret = CONTIG_NONE;
4371	u32 left_cpos, right_cpos;
4372	struct ocfs2_extent_rec *rec = NULL;
4373	struct ocfs2_extent_list *new_el;
4374	struct ocfs2_path *left_path = NULL, *right_path = NULL;
4375	struct buffer_head *bh;
4376	struct ocfs2_extent_block *eb;
4377	struct super_block *sb = ocfs2_metadata_cache_get_super(ci: et->et_ci);
4378
4379	if (index > 0) {
4380	rec = &el->l_recs[index - 1];
4381	} else if (path->p_tree_depth > 0) {
4382	status = ocfs2_find_cpos_for_left_leaf(sb, path, cpos: &left_cpos);
4383	if (status)
4384	goto exit;
4385
4386	if (left_cpos != 0) {
4387	left_path = ocfs2_new_path_from_path(path);
4388	if (!left_path) {
4389	status = -ENOMEM;
4390	mlog_errno(status);
4391	goto exit;
4392	}
4393
4394	status = ocfs2_find_path(ci: et->et_ci, path: left_path,
4395	cpos: left_cpos);
4396	if (status)
4397	goto free_left_path;
4398
4399	new_el = path_leaf_el(left_path);
4400
4401	if (le16_to_cpu(new_el->l_next_free_rec) !=
4402	le16_to_cpu(new_el->l_count)) {
4403	bh = path_leaf_bh(left_path);
4404	eb = (struct ocfs2_extent_block *)bh->b_data;
4405	status = ocfs2_error(sb,
4406	"Extent block #%llu has an invalid l_next_free_rec of %d. It should have matched the l_count of %d\n",
4407	(unsigned long long)le64_to_cpu(eb->h_blkno),
4408	le16_to_cpu(new_el->l_next_free_rec),
4409	le16_to_cpu(new_el->l_count));
4410	goto free_left_path;
4411	}
4412	rec = &new_el->l_recs[
4413	le16_to_cpu(new_el->l_next_free_rec) - 1];
4414	}
4415	}
4416
4417	/*
4418	* We're careful to check for an empty extent record here -
4419	* the merge code will know what to do if it sees one.
4420	*/
4421	if (rec) {
4422	if (index == 1 && ocfs2_is_empty_extent(rec)) {
4423	if (split_rec->e_cpos == el->l_recs[index].e_cpos)
4424	ret = CONTIG_RIGHT;
4425	} else {
4426	ret = ocfs2_et_extent_contig(et, rec, insert_rec: split_rec);
4427	}
4428	}
4429
4430	rec = NULL;
4431	if (index < (le16_to_cpu(el->l_next_free_rec) - 1))
4432	rec = &el->l_recs[index + 1];
4433	else if (le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count) &&
4434	path->p_tree_depth > 0) {
4435	status = ocfs2_find_cpos_for_right_leaf(sb, path, cpos: &right_cpos);
4436	if (status)
4437	goto free_left_path;
4438
4439	if (right_cpos == 0)
4440	goto free_left_path;
4441
4442	right_path = ocfs2_new_path_from_path(path);
4443	if (!right_path) {
4444	status = -ENOMEM;
4445	mlog_errno(status);
4446	goto free_left_path;
4447	}
4448
4449	status = ocfs2_find_path(ci: et->et_ci, path: right_path, cpos: right_cpos);
4450	if (status)
4451	goto free_right_path;
4452
4453	new_el = path_leaf_el(right_path);
4454	rec = &new_el->l_recs[0];
4455	if (ocfs2_is_empty_extent(rec)) {
4456	if (le16_to_cpu(new_el->l_next_free_rec) <= 1) {
4457	bh = path_leaf_bh(right_path);
4458	eb = (struct ocfs2_extent_block *)bh->b_data;
4459	status = ocfs2_error(sb,
4460	"Extent block #%llu has an invalid l_next_free_rec of %d\n",
4461	(unsigned long long)le64_to_cpu(eb->h_blkno),
4462	le16_to_cpu(new_el->l_next_free_rec));
4463	goto free_right_path;
4464	}
4465	rec = &new_el->l_recs[1];
4466	}
4467	}
4468
4469	if (rec) {
4470	enum ocfs2_contig_type contig_type;
4471
4472	contig_type = ocfs2_et_extent_contig(et, rec, insert_rec: split_rec);
4473
4474	if (contig_type == CONTIG_LEFT && ret == CONTIG_RIGHT)
4475	ret = CONTIG_LEFTRIGHT;
4476	else if (ret == CONTIG_NONE)
4477	ret = contig_type;
4478	}
4479
4480	free_right_path:
4481	ocfs2_free_path(path: right_path);
4482	free_left_path:
4483	ocfs2_free_path(path: left_path);
4484	exit:
4485	if (status == 0)
4486	ctxt->c_contig_type = ret;
4487
4488	return status;
4489	}
4490
4491	static void ocfs2_figure_contig_type(struct ocfs2_extent_tree *et,
4492	struct ocfs2_insert_type *insert,
4493	struct ocfs2_extent_list *el,
4494	struct ocfs2_extent_rec *insert_rec)
4495	{
4496	int i;
4497	enum ocfs2_contig_type contig_type = CONTIG_NONE;
4498
4499	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4500
4501	for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
4502	contig_type = ocfs2_et_extent_contig(et, rec: &el->l_recs[i],
4503	insert_rec);
4504	if (contig_type != CONTIG_NONE) {
4505	insert->ins_contig_index = i;
4506	break;
4507	}
4508	}
4509	insert->ins_contig = contig_type;
4510
4511	if (insert->ins_contig != CONTIG_NONE) {
4512	struct ocfs2_extent_rec *rec =
4513	&el->l_recs[insert->ins_contig_index];
4514	unsigned int len = le16_to_cpu(rec->e_leaf_clusters) +
4515	le16_to_cpu(insert_rec->e_leaf_clusters);
4516
4517	/*
4518	* Caller might want us to limit the size of extents, don't
4519	* calculate contiguousness if we might exceed that limit.
4520	*/
4521	if (et->et_max_leaf_clusters &&
4522	(len > et->et_max_leaf_clusters))
4523	insert->ins_contig = CONTIG_NONE;
4524	}
4525	}
4526
4527	/*
4528	* This should only be called against the rightmost leaf extent list.
4529	*
4530	* ocfs2_figure_appending_type() will figure out whether we'll have to
4531	* insert at the tail of the rightmost leaf.
4532	*
4533	* This should also work against the root extent list for tree's with 0
4534	* depth. If we consider the root extent list to be the rightmost leaf node
4535	* then the logic here makes sense.
4536	*/
4537	static void ocfs2_figure_appending_type(struct ocfs2_insert_type *insert,
4538	struct ocfs2_extent_list *el,
4539	struct ocfs2_extent_rec *insert_rec)
4540	{
4541	int i;
4542	u32 cpos = le32_to_cpu(insert_rec->e_cpos);
4543	struct ocfs2_extent_rec *rec;
4544
4545	insert->ins_appending = APPEND_NONE;
4546
4547	BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
4548
4549	if (!el->l_next_free_rec)
4550	goto set_tail_append;
4551
4552	if (ocfs2_is_empty_extent(rec: &el->l_recs[0])) {
4553	/* Were all records empty? */
4554	if (le16_to_cpu(el->l_next_free_rec) == 1)
4555	goto set_tail_append;
4556	}
4557
4558	i = le16_to_cpu(el->l_next_free_rec) - 1;
4559	rec = &el->l_recs[i];
4560
4561	if (cpos >=
4562	(le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)))
4563	goto set_tail_append;
4564
4565	return;
4566
4567	set_tail_append:
4568	insert->ins_appending = APPEND_TAIL;
4569	}
4570
4571	/*
4572	* Helper function called at the beginning of an insert.
4573	*
4574	* This computes a few things that are commonly used in the process of
4575	* inserting into the btree:
4576	* - Whether the new extent is contiguous with an existing one.
4577	* - The current tree depth.
4578	* - Whether the insert is an appending one.
4579	* - The total # of free records in the tree.
4580	*
4581	* All of the information is stored on the ocfs2_insert_type
4582	* structure.
4583	*/
4584	static int ocfs2_figure_insert_type(struct ocfs2_extent_tree *et,
4585	struct buffer_head **last_eb_bh,
4586	struct ocfs2_extent_rec *insert_rec,
4587	int *free_records,
4588	struct ocfs2_insert_type *insert)
4589	{
4590	int ret;
4591	struct ocfs2_extent_block *eb;
4592	struct ocfs2_extent_list *el;
4593	struct ocfs2_path *path = NULL;
4594	struct buffer_head *bh = NULL;
4595
4596	insert->ins_split = SPLIT_NONE;
4597
4598	el = et->et_root_el;
4599	insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth);
4600
4601	if (el->l_tree_depth) {
4602	/*
4603	* If we have tree depth, we read in the
4604	* rightmost extent block ahead of time as
4605	* ocfs2_figure_insert_type() and ocfs2_add_branch()
4606	* may want it later.
4607	*/
4608	ret = ocfs2_read_extent_block(ci: et->et_ci,
4609	eb_blkno: ocfs2_et_get_last_eb_blk(et),
4610	bh: &bh);
4611	if (ret) {
4612	mlog_errno(ret);
4613	goto out;
4614	}
4615	eb = (struct ocfs2_extent_block *) bh->b_data;
4616	el = &eb->h_list;
4617	}
4618
4619	/*
4620	* Unless we have a contiguous insert, we'll need to know if
4621	* there is room left in our allocation tree for another
4622	* extent record.
4623	*
4624	* XXX: This test is simplistic, we can search for empty
4625	* extent records too.
4626	*/
4627	*free_records = le16_to_cpu(el->l_count) -
4628	le16_to_cpu(el->l_next_free_rec);
4629
4630	if (!insert->ins_tree_depth) {
4631	ocfs2_figure_contig_type(et, insert, el, insert_rec);
4632	ocfs2_figure_appending_type(insert, el, insert_rec);
4633	return 0;
4634	}
4635
4636	path = ocfs2_new_path_from_et(et);
4637	if (!path) {
4638	ret = -ENOMEM;
4639	mlog_errno(ret);
4640	goto out;
4641	}
4642
4643	/*
4644	* In the case that we're inserting past what the tree
4645	* currently accounts for, ocfs2_find_path() will return for
4646	* us the rightmost tree path. This is accounted for below in
4647	* the appending code.
4648	*/
4649	ret = ocfs2_find_path(ci: et->et_ci, path, le32_to_cpu(insert_rec->e_cpos));
4650	if (ret) {
4651	mlog_errno(ret);
4652	goto out;
4653	}
4654
4655	el = path_leaf_el(path);
4656
4657	/*
4658	* Now that we have the path, there's two things we want to determine:
4659	* 1) Contiguousness (also set contig_index if this is so)
4660	*
4661	* 2) Are we doing an append? We can trivially break this up
4662	* into two types of appends: simple record append, or a
4663	* rotate inside the tail leaf.
4664	*/
4665	ocfs2_figure_contig_type(et, insert, el, insert_rec);
4666
4667	/*
4668	* The insert code isn't quite ready to deal with all cases of
4669	* left contiguousness. Specifically, if it's an insert into
4670	* the 1st record in a leaf, it will require the adjustment of
4671	* cluster count on the last record of the path directly to it's
4672	* left. For now, just catch that case and fool the layers
4673	* above us. This works just fine for tree_depth == 0, which
4674	* is why we allow that above.
4675	*/
4676	if (insert->ins_contig == CONTIG_LEFT &&
4677	insert->ins_contig_index == 0)
4678	insert->ins_contig = CONTIG_NONE;
4679
4680	/*
4681	* Ok, so we can simply compare against last_eb to figure out
4682	* whether the path doesn't exist. This will only happen in
4683	* the case that we're doing a tail append, so maybe we can
4684	* take advantage of that information somehow.
4685	*/
4686	if (ocfs2_et_get_last_eb_blk(et) ==
4687	path_leaf_bh(path)->b_blocknr) {
4688	/*
4689	* Ok, ocfs2_find_path() returned us the rightmost
4690	* tree path. This might be an appending insert. There are
4691	* two cases:
4692	* 1) We're doing a true append at the tail:
4693	* -This might even be off the end of the leaf
4694	* 2) We're "appending" by rotating in the tail
4695	*/
4696	ocfs2_figure_appending_type(insert, el, insert_rec);
4697	}
4698
4699	out:
4700	ocfs2_free_path(path);
4701
4702	if (ret == 0)
4703	*last_eb_bh = bh;
4704	else
4705	brelse(bh);
4706	return ret;
4707	}
4708
4709	/*
4710	* Insert an extent into a btree.
4711	*
4712	* The caller needs to update the owning btree's cluster count.
4713	*/
4714	int ocfs2_insert_extent(handle_t *handle,
4715	struct ocfs2_extent_tree *et,
4716	u32 cpos,
4717	u64 start_blk,
4718	u32 new_clusters,
4719	u8 flags,
4720	struct ocfs2_alloc_context *meta_ac)
4721	{
4722	int status;
4723	int free_records;
4724	struct buffer_head *last_eb_bh = NULL;
4725	struct ocfs2_insert_type insert = {0, };
4726	struct ocfs2_extent_rec rec;
4727
4728	trace_ocfs2_insert_extent_start(
4729	owner: (unsigned long long)ocfs2_metadata_cache_owner(ci: et->et_ci),
4730	value1: cpos, value2: new_clusters);
4731
4732	memset(&rec, 0, sizeof(rec));
4733	rec.e_cpos = cpu_to_le32(cpos);
4734	rec.e_blkno = cpu_to_le64(start_blk);
4735	rec.e_leaf_clusters = cpu_to_le16(new_clusters);
4736	rec.e_flags = flags;
4737	status = ocfs2_et_insert_check(et, rec: &rec);
4738	if (status) {
4739	mlog_errno(status);
4740	goto bail;
4741	}
4742
4743	status = ocfs2_figure_insert_type(et, last_eb_bh: &last_eb_bh, insert_rec: &rec,
4744	free_records: &free_records, insert: &insert);
4745	if (status < 0) {
4746	mlog_errno(status);
4747	goto bail;
4748	}
4749
4750	trace_ocfs2_insert_extent(ins_appending: insert.ins_appending, ins_contig: insert.ins_contig,
4751	ins_contig_index: insert.ins_contig_index, free_records,
4752	ins_tree_depth: insert.ins_tree_depth);
4753
4754	if (insert.ins_contig == CONTIG_NONE && free_records == 0) {
4755	status = ocfs2_grow_tree(handle, et,
4756	final_depth: &insert.ins_tree_depth, last_eb_bh: &last_eb_bh,
4757	meta_ac);
4758	if (status) {
4759	mlog_errno(status);
4760	goto bail;
4761	}
4762	}
4763
4764	/* Finally, we can add clusters. This might rotate the tree for us. */
4765	status = ocfs2_do_insert_extent(handle, et, insert_rec: &rec, type: &insert);
4766	if (status < 0)
4767	mlog_errno(status);
4768	else
4769	ocfs2_et_extent_map_insert(et, rec: &rec);
4770
4771	bail:
4772	brelse(bh: last_eb_bh);
4773
4774	return status;
4775	}
4776
4777	/*
4778	* Allocate and add clusters into the extent b-tree.
4779	* The new clusters(clusters_to_add) will be inserted at logical_offset.
4780	* The extent b-tree's root is specified by et, and
4781	* it is not limited to the file storage. Any extent tree can use this
4782	* function if it implements the proper ocfs2_extent_tree.
4783	*/
4784	int ocfs2_add_clusters_in_btree(handle_t *handle,
4785	struct ocfs2_extent_tree *et,
4786	u32 *logical_offset,
4787	u32 clusters_to_add,
4788	int mark_unwritten,
4789	struct ocfs2_alloc_context *data_ac,
4790	struct ocfs2_alloc_context *meta_ac,
4791	enum ocfs2_alloc_restarted *reason_ret)
4792	{
4793	int status = 0, err = 0;
4794	int need_free = 0;
4795	int free_extents;
4796	enum ocfs2_alloc_restarted reason = RESTART_NONE;
4797	u32 bit_off, num_bits;
4798	u64 block;
4799	u8 flags = 0;
4800	struct ocfs2_super *osb =
4801	OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
4802
4803	BUG_ON(!clusters_to_add);
4804
4805	if (mark_unwritten)
4806	flags = OCFS2_EXT_UNWRITTEN;
4807
4808	free_extents = ocfs2_num_free_extents(et);
4809	if (free_extents < 0) {
4810	status = free_extents;
4811	mlog_errno(status);
4812	goto leave;
4813	}
4814
4815	/* there are two cases which could cause us to EAGAIN in the
4816	* we-need-more-metadata case:
4817	* 1) we haven't reserved *any*
4818	* 2) we are so fragmented, we've needed to add metadata too
4819	* many times. */
4820	if (!free_extents && !meta_ac) {
4821	err = -1;
4822	status = -EAGAIN;
4823	reason = RESTART_META;
4824	goto leave;
4825	} else if ((!free_extents)
4826	&& (ocfs2_alloc_context_bits_left(ac: meta_ac)
4827	< ocfs2_extend_meta_needed(root_el: et->et_root_el))) {
4828	err = -2;
4829	status = -EAGAIN;
4830	reason = RESTART_META;
4831	goto leave;
4832	}
4833
4834	status = __ocfs2_claim_clusters(handle, ac: data_ac, min_clusters: 1,
4835	max_clusters: clusters_to_add, cluster_start: &bit_off, num_clusters: &num_bits);
4836	if (status < 0) {
4837	if (status != -ENOSPC)
4838	mlog_errno(status);
4839	goto leave;
4840	}
4841
4842	BUG_ON(num_bits > clusters_to_add);
4843
4844	/* reserve our write early -- insert_extent may update the tree root */
4845	status = ocfs2_et_root_journal_access(handle, et,
4846	OCFS2_JOURNAL_ACCESS_WRITE);
4847	if (status < 0) {
4848	mlog_errno(status);
4849	need_free = 1;
4850	goto bail;
4851	}
4852
4853	block = ocfs2_clusters_to_blocks(sb: osb->sb, clusters: bit_off);
4854	trace_ocfs2_add_clusters_in_btree(
4855	owner: (unsigned long long)ocfs2_metadata_cache_owner(ci: et->et_ci),
4856	value1: bit_off, value2: num_bits);
4857	status = ocfs2_insert_extent(handle, et, cpos: *logical_offset, start_blk: block,
4858	new_clusters: num_bits, flags, meta_ac);
4859	if (status < 0) {
4860	mlog_errno(status);
4861	need_free = 1;
4862	goto bail;
4863	}
4864
4865	ocfs2_journal_dirty(handle, bh: et->et_root_bh);
4866
4867	clusters_to_add -= num_bits;
4868	*logical_offset += num_bits;
4869
4870	if (clusters_to_add) {
4871	err = clusters_to_add;
4872	status = -EAGAIN;
4873	reason = RESTART_TRANS;
4874	}
4875
4876	bail:
4877	if (need_free) {
4878	if (data_ac->ac_which == OCFS2_AC_USE_LOCAL)
4879	ocfs2_free_local_alloc_bits(osb, handle, ac: data_ac,
4880	bit_off, num_bits);
4881	else
4882	ocfs2_free_clusters(handle,
4883	bitmap_inode: data_ac->ac_inode,
4884	bitmap_bh: data_ac->ac_bh,
4885	start_blk: ocfs2_clusters_to_blocks(sb: osb->sb, clusters: bit_off),
4886	num_clusters: num_bits);
4887	}
4888
4889	leave:
4890	if (reason_ret)
4891	*reason_ret = reason;
4892	trace_ocfs2_add_clusters_in_btree_ret(status, reason, err);
4893	return status;
4894	}
4895
4896	static void ocfs2_make_right_split_rec(struct super_block *sb,
4897	struct ocfs2_extent_rec *split_rec,
4898	u32 cpos,
4899	struct ocfs2_extent_rec *rec)
4900	{
4901	u32 rec_cpos = le32_to_cpu(rec->e_cpos);
4902	u32 rec_range = rec_cpos + le16_to_cpu(rec->e_leaf_clusters);
4903
4904	memset(split_rec, 0, sizeof(struct ocfs2_extent_rec));
4905
4906	split_rec->e_cpos = cpu_to_le32(cpos);
4907	split_rec->e_leaf_clusters = cpu_to_le16(rec_range - cpos);
4908
4909	split_rec->e_blkno = rec->e_blkno;
4910	le64_add_cpu(var: &split_rec->e_blkno,
4911	val: ocfs2_clusters_to_blocks(sb, clusters: cpos - rec_cpos));
4912
4913	split_rec->e_flags = rec->e_flags;
4914	}
4915
4916	static int ocfs2_split_and_insert(handle_t *handle,
4917	struct ocfs2_extent_tree *et,
4918	struct ocfs2_path *path,
4919	struct buffer_head **last_eb_bh,
4920	int split_index,
4921	struct ocfs2_extent_rec *orig_split_rec,
4922	struct ocfs2_alloc_context *meta_ac)
4923	{
4924	int ret = 0, depth;
4925	unsigned int insert_range, rec_range, do_leftright = 0;
4926	struct ocfs2_extent_rec tmprec;
4927	struct ocfs2_extent_list *rightmost_el;
4928	struct ocfs2_extent_rec rec;
4929	struct ocfs2_extent_rec split_rec = *orig_split_rec;
4930	struct ocfs2_insert_type insert;
4931	struct ocfs2_extent_block *eb;
4932
4933	leftright:
4934	/*
4935	* Store a copy of the record on the stack - it might move
4936	* around as the tree is manipulated below.
4937	*/
4938	rec = path_leaf_el(path)->l_recs[split_index];
4939
4940	rightmost_el = et->et_root_el;
4941
4942	depth = le16_to_cpu(rightmost_el->l_tree_depth);
4943	if (depth) {
4944	BUG_ON(!(*last_eb_bh));
4945	eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
4946	rightmost_el = &eb->h_list;
4947	}
4948
4949	if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
4950	le16_to_cpu(rightmost_el->l_count)) {
4951	ret = ocfs2_grow_tree(handle, et,
4952	final_depth: &depth, last_eb_bh, meta_ac);
4953	if (ret) {
4954	mlog_errno(ret);
4955	goto out;
4956	}
4957	}
4958
4959	memset(&insert, 0, sizeof(struct ocfs2_insert_type));
4960	insert.ins_appending = APPEND_NONE;
4961	insert.ins_contig = CONTIG_NONE;
4962	insert.ins_tree_depth = depth;
4963
4964	insert_range = le32_to_cpu(split_rec.e_cpos) +
4965	le16_to_cpu(split_rec.e_leaf_clusters);
4966	rec_range = le32_to_cpu(rec.e_cpos) +
4967	le16_to_cpu(rec.e_leaf_clusters);
4968
4969	if (split_rec.e_cpos == rec.e_cpos) {
4970	insert.ins_split = SPLIT_LEFT;
4971	} else if (insert_range == rec_range) {
4972	insert.ins_split = SPLIT_RIGHT;
4973	} else {
4974	/*
4975	* Left/right split. We fake this as a right split
4976	* first and then make a second pass as a left split.
4977	*/
4978	insert.ins_split = SPLIT_RIGHT;
4979
4980	ocfs2_make_right_split_rec(sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
4981	split_rec: &tmprec, cpos: insert_range, rec: &rec);
4982
4983	split_rec = tmprec;
4984
4985	BUG_ON(do_leftright);
4986	do_leftright = 1;
4987	}
4988
4989	ret = ocfs2_do_insert_extent(handle, et, insert_rec: &split_rec, type: &insert);
4990	if (ret) {
4991	mlog_errno(ret);
4992	goto out;
4993	}
4994
4995	if (do_leftright == 1) {
4996	u32 cpos;
4997	struct ocfs2_extent_list *el;
4998
4999	do_leftright++;
5000	split_rec = *orig_split_rec;
5001
5002	ocfs2_reinit_path(path, keep_root: 1);
5003
5004	cpos = le32_to_cpu(split_rec.e_cpos);
5005	ret = ocfs2_find_path(ci: et->et_ci, path, cpos);
5006	if (ret) {
5007	mlog_errno(ret);
5008	goto out;
5009	}
5010
5011	el = path_leaf_el(path);
5012	split_index = ocfs2_search_extent_list(el, v_cluster: cpos);
5013	if (split_index == -1) {
5014	ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5015	"Owner %llu has an extent at cpos %u which can no longer be found\n",
5016	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5017	cpos);
5018	ret = -EROFS;
5019	goto out;
5020	}
5021	goto leftright;
5022	}
5023	out:
5024
5025	return ret;
5026	}
5027
5028	static int ocfs2_replace_extent_rec(handle_t *handle,
5029	struct ocfs2_extent_tree *et,
5030	struct ocfs2_path *path,
5031	struct ocfs2_extent_list *el,
5032	int split_index,
5033	struct ocfs2_extent_rec *split_rec)
5034	{
5035	int ret;
5036
5037	ret = ocfs2_path_bh_journal_access(handle, ci: et->et_ci, path,
5038	path_num_items(path) - 1);
5039	if (ret) {
5040	mlog_errno(ret);
5041	goto out;
5042	}
5043
5044	el->l_recs[split_index] = *split_rec;
5045
5046	ocfs2_journal_dirty(handle, path_leaf_bh(path));
5047	out:
5048	return ret;
5049	}
5050
5051	/*
5052	* Split part or all of the extent record at split_index in the leaf
5053	* pointed to by path. Merge with the contiguous extent record if needed.
5054	*
5055	* Care is taken to handle contiguousness so as to not grow the tree.
5056	*
5057	* meta_ac is not strictly necessary - we only truly need it if growth
5058	* of the tree is required. All other cases will degrade into a less
5059	* optimal tree layout.
5060	*
5061	* last_eb_bh should be the rightmost leaf block for any extent
5062	* btree. Since a split may grow the tree or a merge might shrink it,
5063	* the caller cannot trust the contents of that buffer after this call.
5064	*
5065	* This code is optimized for readability - several passes might be
5066	* made over certain portions of the tree. All of those blocks will
5067	* have been brought into cache (and pinned via the journal), so the
5068	* extra overhead is not expressed in terms of disk reads.
5069	*/
5070	int ocfs2_split_extent(handle_t *handle,
5071	struct ocfs2_extent_tree *et,
5072	struct ocfs2_path *path,
5073	int split_index,
5074	struct ocfs2_extent_rec *split_rec,
5075	struct ocfs2_alloc_context *meta_ac,
5076	struct ocfs2_cached_dealloc_ctxt *dealloc)
5077	{
5078	int ret = 0;
5079	struct ocfs2_extent_list *el = path_leaf_el(path);
5080	struct buffer_head *last_eb_bh = NULL;
5081	struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
5082	struct ocfs2_merge_ctxt ctxt;
5083
5084	if (le32_to_cpu(rec->e_cpos) > le32_to_cpu(split_rec->e_cpos) ||
5085	((le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)) <
5086	(le32_to_cpu(split_rec->e_cpos) + le16_to_cpu(split_rec->e_leaf_clusters)))) {
5087	ret = -EIO;
5088	mlog_errno(ret);
5089	goto out;
5090	}
5091
5092	ret = ocfs2_figure_merge_contig_type(et, path, el,
5093	index: split_index,
5094	split_rec,
5095	ctxt: &ctxt);
5096	if (ret) {
5097	mlog_errno(ret);
5098	goto out;
5099	}
5100
5101	/*
5102	* The core merge / split code wants to know how much room is
5103	* left in this allocation tree, so we pass the
5104	* rightmost extent list.
5105	*/
5106	if (path->p_tree_depth) {
5107	ret = ocfs2_read_extent_block(ci: et->et_ci,
5108	eb_blkno: ocfs2_et_get_last_eb_blk(et),
5109	bh: &last_eb_bh);
5110	if (ret) {
5111	mlog_errno(ret);
5112	goto out;
5113	}
5114	}
5115
5116	if (rec->e_cpos == split_rec->e_cpos &&
5117	rec->e_leaf_clusters == split_rec->e_leaf_clusters)
5118	ctxt.c_split_covers_rec = 1;
5119	else
5120	ctxt.c_split_covers_rec = 0;
5121
5122	ctxt.c_has_empty_extent = ocfs2_is_empty_extent(rec: &el->l_recs[0]);
5123
5124	trace_ocfs2_split_extent(split_index, c_contig_type: ctxt.c_contig_type,
5125	c_has_empty_extent: ctxt.c_has_empty_extent,
5126	c_split_covers_rec: ctxt.c_split_covers_rec);
5127
5128	if (ctxt.c_contig_type == CONTIG_NONE) {
5129	if (ctxt.c_split_covers_rec)
5130	ret = ocfs2_replace_extent_rec(handle, et, path, el,
5131	split_index, split_rec);
5132	else
5133	ret = ocfs2_split_and_insert(handle, et, path,
5134	last_eb_bh: &last_eb_bh, split_index,
5135	orig_split_rec: split_rec, meta_ac);
5136	if (ret)
5137	mlog_errno(ret);
5138	} else {
5139	ret = ocfs2_try_to_merge_extent(handle, et, path,
5140	split_index, split_rec,
5141	dealloc, ctxt: &ctxt);
5142	if (ret)
5143	mlog_errno(ret);
5144	}
5145
5146	out:
5147	brelse(bh: last_eb_bh);
5148	return ret;
5149	}
5150
5151	/*
5152	* Change the flags of the already-existing extent at cpos for len clusters.
5153	*
5154	* new_flags: the flags we want to set.
5155	* clear_flags: the flags we want to clear.
5156	* phys: the new physical offset we want this new extent starts from.
5157	*
5158	* If the existing extent is larger than the request, initiate a
5159	* split. An attempt will be made at merging with adjacent extents.
5160	*
5161	* The caller is responsible for passing down meta_ac if we'll need it.
5162	*/
5163	int ocfs2_change_extent_flag(handle_t *handle,
5164	struct ocfs2_extent_tree *et,
5165	u32 cpos, u32 len, u32 phys,
5166	struct ocfs2_alloc_context *meta_ac,
5167	struct ocfs2_cached_dealloc_ctxt *dealloc,
5168	int new_flags, int clear_flags)
5169	{
5170	int ret, index;
5171	struct super_block *sb = ocfs2_metadata_cache_get_super(ci: et->et_ci);
5172	u64 start_blkno = ocfs2_clusters_to_blocks(sb, clusters: phys);
5173	struct ocfs2_extent_rec split_rec;
5174	struct ocfs2_path *left_path = NULL;
5175	struct ocfs2_extent_list *el;
5176	struct ocfs2_extent_rec *rec;
5177
5178	left_path = ocfs2_new_path_from_et(et);
5179	if (!left_path) {
5180	ret = -ENOMEM;
5181	mlog_errno(ret);
5182	goto out;
5183	}
5184
5185	ret = ocfs2_find_path(ci: et->et_ci, path: left_path, cpos);
5186	if (ret) {
5187	mlog_errno(ret);
5188	goto out;
5189	}
5190	el = path_leaf_el(left_path);
5191
5192	index = ocfs2_search_extent_list(el, v_cluster: cpos);
5193	if (index == -1) {
5194	ocfs2_error(sb,
5195	"Owner %llu has an extent at cpos %u which can no longer be found\n",
5196	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5197	cpos);
5198	ret = -EROFS;
5199	goto out;
5200	}
5201
5202	ret = -EIO;
5203	rec = &el->l_recs[index];
5204	if (new_flags && (rec->e_flags & new_flags)) {
5205	mlog(ML_ERROR, "Owner %llu tried to set %d flags on an "
5206	"extent that already had them\n",
5207	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5208	new_flags);
5209	goto out;
5210	}
5211
5212	if (clear_flags && !(rec->e_flags & clear_flags)) {
5213	mlog(ML_ERROR, "Owner %llu tried to clear %d flags on an "
5214	"extent that didn't have them\n",
5215	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5216	clear_flags);
5217	goto out;
5218	}
5219
5220	memset(&split_rec, 0, sizeof(struct ocfs2_extent_rec));
5221	split_rec.e_cpos = cpu_to_le32(cpos);
5222	split_rec.e_leaf_clusters = cpu_to_le16(len);
5223	split_rec.e_blkno = cpu_to_le64(start_blkno);
5224	split_rec.e_flags = rec->e_flags;
5225	if (new_flags)
5226	split_rec.e_flags |= new_flags;
5227	if (clear_flags)
5228	split_rec.e_flags &= ~clear_flags;
5229
5230	ret = ocfs2_split_extent(handle, et, path: left_path,
5231	split_index: index, split_rec: &split_rec, meta_ac,
5232	dealloc);
5233	if (ret)
5234	mlog_errno(ret);
5235
5236	out:
5237	ocfs2_free_path(path: left_path);
5238	return ret;
5239
5240	}
5241
5242	/*
5243	* Mark the already-existing extent at cpos as written for len clusters.
5244	* This removes the unwritten extent flag.
5245	*
5246	* If the existing extent is larger than the request, initiate a
5247	* split. An attempt will be made at merging with adjacent extents.
5248	*
5249	* The caller is responsible for passing down meta_ac if we'll need it.
5250	*/
5251	int ocfs2_mark_extent_written(struct inode *inode,
5252	struct ocfs2_extent_tree *et,
5253	handle_t *handle, u32 cpos, u32 len, u32 phys,
5254	struct ocfs2_alloc_context *meta_ac,
5255	struct ocfs2_cached_dealloc_ctxt *dealloc)
5256	{
5257	int ret;
5258
5259	trace_ocfs2_mark_extent_written(
5260	owner: (unsigned long long)OCFS2_I(inode)->ip_blkno,
5261	cpos, len, phys);
5262
5263	if (!ocfs2_writes_unwritten_extents(OCFS2_SB(inode->i_sb))) {
5264	ocfs2_error(inode->i_sb, "Inode %llu has unwritten extents that are being written to, but the feature bit is not set in the super block\n",
5265	(unsigned long long)OCFS2_I(inode)->ip_blkno);
5266	ret = -EROFS;
5267	goto out;
5268	}
5269
5270	/*
5271	* XXX: This should be fixed up so that we just re-insert the
5272	* next extent records.
5273	*/
5274	ocfs2_et_extent_map_truncate(et, clusters: 0);
5275
5276	ret = ocfs2_change_extent_flag(handle, et, cpos,
5277	len, phys, meta_ac, dealloc,
5278	new_flags: 0, OCFS2_EXT_UNWRITTEN);
5279	if (ret)
5280	mlog_errno(ret);
5281
5282	out:
5283	return ret;
5284	}
5285
5286	static int ocfs2_split_tree(handle_t *handle, struct ocfs2_extent_tree *et,
5287	struct ocfs2_path *path,
5288	int index, u32 new_range,
5289	struct ocfs2_alloc_context *meta_ac)
5290	{
5291	int ret, depth, credits;
5292	struct buffer_head *last_eb_bh = NULL;
5293	struct ocfs2_extent_block *eb;
5294	struct ocfs2_extent_list *rightmost_el, *el;
5295	struct ocfs2_extent_rec split_rec;
5296	struct ocfs2_extent_rec *rec;
5297	struct ocfs2_insert_type insert;
5298
5299	/*
5300	* Setup the record to split before we grow the tree.
5301	*/
5302	el = path_leaf_el(path);
5303	rec = &el->l_recs[index];
5304	ocfs2_make_right_split_rec(sb: ocfs2_metadata_cache_get_super(ci: et->et_ci),
5305	split_rec: &split_rec, cpos: new_range, rec);
5306
5307	depth = path->p_tree_depth;
5308	if (depth > 0) {
5309	ret = ocfs2_read_extent_block(ci: et->et_ci,
5310	eb_blkno: ocfs2_et_get_last_eb_blk(et),
5311	bh: &last_eb_bh);
5312	if (ret < 0) {
5313	mlog_errno(ret);
5314	goto out;
5315	}
5316
5317	eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
5318	rightmost_el = &eb->h_list;
5319	} else
5320	rightmost_el = path_leaf_el(path);
5321
5322	credits = path->p_tree_depth +
5323	ocfs2_extend_meta_needed(root_el: et->et_root_el);
5324	ret = ocfs2_extend_trans(handle, nblocks: credits);
5325	if (ret) {
5326	mlog_errno(ret);
5327	goto out;
5328	}
5329
5330	if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
5331	le16_to_cpu(rightmost_el->l_count)) {
5332	ret = ocfs2_grow_tree(handle, et, final_depth: &depth, last_eb_bh: &last_eb_bh,
5333	meta_ac);
5334	if (ret) {
5335	mlog_errno(ret);
5336	goto out;
5337	}
5338	}
5339
5340	memset(&insert, 0, sizeof(struct ocfs2_insert_type));
5341	insert.ins_appending = APPEND_NONE;
5342	insert.ins_contig = CONTIG_NONE;
5343	insert.ins_split = SPLIT_RIGHT;
5344	insert.ins_tree_depth = depth;
5345
5346	ret = ocfs2_do_insert_extent(handle, et, insert_rec: &split_rec, type: &insert);
5347	if (ret)
5348	mlog_errno(ret);
5349
5350	out:
5351	brelse(bh: last_eb_bh);
5352	return ret;
5353	}
5354
5355	static int ocfs2_truncate_rec(handle_t *handle,
5356	struct ocfs2_extent_tree *et,
5357	struct ocfs2_path *path, int index,
5358	struct ocfs2_cached_dealloc_ctxt *dealloc,
5359	u32 cpos, u32 len)
5360	{
5361	int ret;
5362	u32 left_cpos, rec_range, trunc_range;
5363	int is_rightmost_tree_rec = 0;
5364	struct super_block *sb = ocfs2_metadata_cache_get_super(ci: et->et_ci);
5365	struct ocfs2_path *left_path = NULL;
5366	struct ocfs2_extent_list *el = path_leaf_el(path);
5367	struct ocfs2_extent_rec *rec;
5368	struct ocfs2_extent_block *eb;
5369
5370	if (ocfs2_is_empty_extent(rec: &el->l_recs[0]) && index > 0) {
5371	/* extend credit for ocfs2_remove_rightmost_path */
5372	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: 0,
5373	op_credits: jbd2_handle_buffer_credits(handle),
5374	path);
5375	if (ret) {
5376	mlog_errno(ret);
5377	goto out;
5378	}
5379
5380	ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
5381	if (ret) {
5382	mlog_errno(ret);
5383	goto out;
5384	}
5385
5386	index--;
5387	}
5388
5389	if (index == (le16_to_cpu(el->l_next_free_rec) - 1) &&
5390	path->p_tree_depth) {
5391	/*
5392	* Check whether this is the rightmost tree record. If
5393	* we remove all of this record or part of its right
5394	* edge then an update of the record lengths above it
5395	* will be required.
5396	*/
5397	eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
5398	if (eb->h_next_leaf_blk == 0)
5399	is_rightmost_tree_rec = 1;
5400	}
5401
5402	rec = &el->l_recs[index];
5403	if (index == 0 && path->p_tree_depth &&
5404	le32_to_cpu(rec->e_cpos) == cpos) {
5405	/*
5406	* Changing the leftmost offset (via partial or whole
5407	* record truncate) of an interior (or rightmost) path
5408	* means we have to update the subtree that is formed
5409	* by this leaf and the one to it's left.
5410	*
5411	* There are two cases we can skip:
5412	* 1) Path is the leftmost one in our btree.
5413	* 2) The leaf is rightmost and will be empty after
5414	* we remove the extent record - the rotate code
5415	* knows how to update the newly formed edge.
5416	*/
5417
5418	ret = ocfs2_find_cpos_for_left_leaf(sb, path, cpos: &left_cpos);
5419	if (ret) {
5420	mlog_errno(ret);
5421	goto out;
5422	}
5423
5424	if (left_cpos && le16_to_cpu(el->l_next_free_rec) > 1) {
5425	left_path = ocfs2_new_path_from_path(path);
5426	if (!left_path) {
5427	ret = -ENOMEM;
5428	mlog_errno(ret);
5429	goto out;
5430	}
5431
5432	ret = ocfs2_find_path(ci: et->et_ci, path: left_path,
5433	cpos: left_cpos);
5434	if (ret) {
5435	mlog_errno(ret);
5436	goto out;
5437	}
5438	}
5439	}
5440
5441	ret = ocfs2_extend_rotate_transaction(handle, subtree_depth: 0,
5442	op_credits: jbd2_handle_buffer_credits(handle),
5443	path);
5444	if (ret) {
5445	mlog_errno(ret);
5446	goto out;
5447	}
5448
5449	ret = ocfs2_journal_access_path(ci: et->et_ci, handle, path);
5450	if (ret) {
5451	mlog_errno(ret);
5452	goto out;
5453	}
5454
5455	ret = ocfs2_journal_access_path(ci: et->et_ci, handle, path: left_path);
5456	if (ret) {
5457	mlog_errno(ret);
5458	goto out;
5459	}
5460
5461	rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5462	trunc_range = cpos + len;
5463
5464	if (le32_to_cpu(rec->e_cpos) == cpos && rec_range == trunc_range) {
5465	int next_free;
5466
5467	memset(rec, 0, sizeof(*rec));
5468	ocfs2_cleanup_merge(el, index);
5469
5470	next_free = le16_to_cpu(el->l_next_free_rec);
5471	if (is_rightmost_tree_rec && next_free > 1) {
5472	/*
5473	* We skip the edge update if this path will
5474	* be deleted by the rotate code.
5475	*/
5476	rec = &el->l_recs[next_free - 1];
5477	ocfs2_adjust_rightmost_records(handle, et, path,
5478	insert_rec: rec);
5479	}
5480	} else if (le32_to_cpu(rec->e_cpos) == cpos) {
5481	/* Remove leftmost portion of the record. */
5482	le32_add_cpu(var: &rec->e_cpos, val: len);
5483	le64_add_cpu(var: &rec->e_blkno, val: ocfs2_clusters_to_blocks(sb, clusters: len));
5484	le16_add_cpu(var: &rec->e_leaf_clusters, val: -len);
5485	} else if (rec_range == trunc_range) {
5486	/* Remove rightmost portion of the record */
5487	le16_add_cpu(var: &rec->e_leaf_clusters, val: -len);
5488	if (is_rightmost_tree_rec)
5489	ocfs2_adjust_rightmost_records(handle, et, path, insert_rec: rec);
5490	} else {
5491	/* Caller should have trapped this. */
5492	mlog(ML_ERROR, "Owner %llu: Invalid record truncate: (%u, %u) "
5493	"(%u, %u)\n",
5494	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5495	le32_to_cpu(rec->e_cpos),
5496	le16_to_cpu(rec->e_leaf_clusters), cpos, len);
5497	BUG();
5498	}
5499
5500	if (left_path) {
5501	int subtree_index;
5502
5503	subtree_index = ocfs2_find_subtree_root(et, left: left_path, right: path);
5504	ocfs2_complete_edge_insert(handle, left_path, right_path: path,
5505	subtree_index);
5506	}
5507
5508	ocfs2_journal_dirty(handle, path_leaf_bh(path));
5509
5510	ret = ocfs2_rotate_tree_left(handle, et, path, dealloc);
5511	if (ret)
5512	mlog_errno(ret);
5513
5514	out:
5515	ocfs2_free_path(path: left_path);
5516	return ret;
5517	}
5518
5519	int ocfs2_remove_extent(handle_t *handle,
5520	struct ocfs2_extent_tree *et,
5521	u32 cpos, u32 len,
5522	struct ocfs2_alloc_context *meta_ac,
5523	struct ocfs2_cached_dealloc_ctxt *dealloc)
5524	{
5525	int ret, index;
5526	u32 rec_range, trunc_range;
5527	struct ocfs2_extent_rec *rec;
5528	struct ocfs2_extent_list *el;
5529	struct ocfs2_path *path = NULL;
5530
5531	/*
5532	* XXX: Why are we truncating to 0 instead of wherever this
5533	* affects us?
5534	*/
5535	ocfs2_et_extent_map_truncate(et, clusters: 0);
5536
5537	path = ocfs2_new_path_from_et(et);
5538	if (!path) {
5539	ret = -ENOMEM;
5540	mlog_errno(ret);
5541	goto out;
5542	}
5543
5544	ret = ocfs2_find_path(ci: et->et_ci, path, cpos);
5545	if (ret) {
5546	mlog_errno(ret);
5547	goto out;
5548	}
5549
5550	el = path_leaf_el(path);
5551	index = ocfs2_search_extent_list(el, v_cluster: cpos);
5552	if (index == -1) {
5553	ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5554	"Owner %llu has an extent at cpos %u which can no longer be found\n",
5555	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5556	cpos);
5557	ret = -EROFS;
5558	goto out;
5559	}
5560
5561	/*
5562	* We have 3 cases of extent removal:
5563	* 1) Range covers the entire extent rec
5564	* 2) Range begins or ends on one edge of the extent rec
5565	* 3) Range is in the middle of the extent rec (no shared edges)
5566	*
5567	* For case 1 we remove the extent rec and left rotate to
5568	* fill the hole.
5569	*
5570	* For case 2 we just shrink the existing extent rec, with a
5571	* tree update if the shrinking edge is also the edge of an
5572	* extent block.
5573	*
5574	* For case 3 we do a right split to turn the extent rec into
5575	* something case 2 can handle.
5576	*/
5577	rec = &el->l_recs[index];
5578	rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
5579	trunc_range = cpos + len;
5580
5581	BUG_ON(cpos < le32_to_cpu(rec->e_cpos) || trunc_range > rec_range);
5582
5583	trace_ocfs2_remove_extent(
5584	owner: (unsigned long long)ocfs2_metadata_cache_owner(ci: et->et_ci),
5585	cpos, len, index, le32_to_cpu(rec->e_cpos),
5586	clusters: ocfs2_rec_clusters(el, rec));
5587
5588	if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) {
5589	ret = ocfs2_truncate_rec(handle, et, path, index, dealloc,
5590	cpos, len);
5591	if (ret) {
5592	mlog_errno(ret);
5593	goto out;
5594	}
5595	} else {
5596	ret = ocfs2_split_tree(handle, et, path, index,
5597	new_range: trunc_range, meta_ac);
5598	if (ret) {
5599	mlog_errno(ret);
5600	goto out;
5601	}
5602
5603	/*
5604	* The split could have manipulated the tree enough to
5605	* move the record location, so we have to look for it again.
5606	*/
5607	ocfs2_reinit_path(path, keep_root: 1);
5608
5609	ret = ocfs2_find_path(ci: et->et_ci, path, cpos);
5610	if (ret) {
5611	mlog_errno(ret);
5612	goto out;
5613	}
5614
5615	el = path_leaf_el(path);
5616	index = ocfs2_search_extent_list(el, v_cluster: cpos);
5617	if (index == -1) {
5618	ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5619	"Owner %llu: split at cpos %u lost record\n",
5620	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5621	cpos);
5622	ret = -EROFS;
5623	goto out;
5624	}
5625
5626	/*
5627	* Double check our values here. If anything is fishy,
5628	* it's easier to catch it at the top level.
5629	*/
5630	rec = &el->l_recs[index];
5631	rec_range = le32_to_cpu(rec->e_cpos) +
5632	ocfs2_rec_clusters(el, rec);
5633	if (rec_range != trunc_range) {
5634	ocfs2_error(ocfs2_metadata_cache_get_super(et->et_ci),
5635	"Owner %llu: error after split at cpos %u trunc len %u, existing record is (%u,%u)\n",
5636	(unsigned long long)ocfs2_metadata_cache_owner(et->et_ci),
5637	cpos, len, le32_to_cpu(rec->e_cpos),
5638	ocfs2_rec_clusters(el, rec));
5639	ret = -EROFS;
5640	goto out;
5641	}
5642
5643	ret = ocfs2_truncate_rec(handle, et, path, index, dealloc,
5644	cpos, len);
5645	if (ret)
5646	mlog_errno(ret);
5647	}
5648
5649	out:
5650	ocfs2_free_path(path);
5651	return ret;
5652	}
5653
5654	/*
5655	* ocfs2_reserve_blocks_for_rec_trunc() would look basically the
5656	* same as ocfs2_lock_alloctors(), except for it accepts a blocks
5657	* number to reserve some extra blocks, and it only handles meta
5658	* data allocations.
5659	*
5660	* Currently, only ocfs2_remove_btree_range() uses it for truncating
5661	* and punching holes.
5662	*/
5663	static int ocfs2_reserve_blocks_for_rec_trunc(struct inode *inode,
5664	struct ocfs2_extent_tree *et,
5665	u32 extents_to_split,
5666	struct ocfs2_alloc_context **ac,
5667	int extra_blocks)
5668	{
5669	int ret = 0, num_free_extents;
5670	unsigned int max_recs_needed = 2 * extents_to_split;
5671	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5672
5673	*ac = NULL;
5674
5675	num_free_extents = ocfs2_num_free_extents(et);
5676	if (num_free_extents < 0) {
5677	ret = num_free_extents;
5678	mlog_errno(ret);
5679	goto out;
5680	}
5681
5682	if (!num_free_extents ||
5683	(ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed))
5684	extra_blocks += ocfs2_extend_meta_needed(root_el: et->et_root_el);
5685
5686	if (extra_blocks) {
5687	ret = ocfs2_reserve_new_metadata_blocks(osb, blocks: extra_blocks, ac);
5688	if (ret < 0) {
5689	if (ret != -ENOSPC)
5690	mlog_errno(ret);
5691	}
5692	}
5693
5694	out:
5695	if (ret) {
5696	if (*ac) {
5697	ocfs2_free_alloc_context(ac: *ac);
5698	*ac = NULL;
5699	}
5700	}
5701
5702	return ret;
5703	}
5704
5705	int ocfs2_remove_btree_range(struct inode *inode,
5706	struct ocfs2_extent_tree *et,
5707	u32 cpos, u32 phys_cpos, u32 len, int flags,
5708	struct ocfs2_cached_dealloc_ctxt *dealloc,
5709	u64 refcount_loc, bool refcount_tree_locked)
5710	{
5711	int ret, credits = 0, extra_blocks = 0;
5712	u64 phys_blkno = ocfs2_clusters_to_blocks(sb: inode->i_sb, clusters: phys_cpos);
5713	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
5714	struct inode *tl_inode = osb->osb_tl_inode;
5715	handle_t *handle;
5716	struct ocfs2_alloc_context *meta_ac = NULL;
5717	struct ocfs2_refcount_tree *ref_tree = NULL;
5718
5719	if ((flags & OCFS2_EXT_REFCOUNTED) && len) {
5720	BUG_ON(!ocfs2_is_refcount_inode(inode));
5721
5722	if (!refcount_tree_locked) {
5723	ret = ocfs2_lock_refcount_tree(osb, ref_blkno: refcount_loc, rw: 1,
5724	tree: &ref_tree, NULL);
5725	if (ret) {
5726	mlog_errno(ret);
5727	goto bail;
5728	}
5729	}
5730
5731	ret = ocfs2_prepare_refcount_change_for_del(inode,
5732	refcount_loc,
5733	phys_blkno,
5734	clusters: len,
5735	credits: &credits,
5736	ref_blocks: &extra_blocks);
5737	if (ret < 0) {
5738	mlog_errno(ret);
5739	goto bail;
5740	}
5741	}
5742
5743	ret = ocfs2_reserve_blocks_for_rec_trunc(inode, et, extents_to_split: 1, ac: &meta_ac,
5744	extra_blocks);
5745	if (ret) {
5746	mlog_errno(ret);
5747	goto bail;
5748	}
5749
5750	inode_lock(inode: tl_inode);
5751
5752	if (ocfs2_truncate_log_needs_flush(osb)) {
5753	ret = __ocfs2_flush_truncate_log(osb);
5754	if (ret < 0) {
5755	mlog_errno(ret);
5756	goto out;
5757	}
5758	}
5759
5760	handle = ocfs2_start_trans(osb,
5761	max_buffs: ocfs2_remove_extent_credits(sb: osb->sb) + credits);
5762	if (IS_ERR(ptr: handle)) {
5763	ret = PTR_ERR(ptr: handle);
5764	mlog_errno(ret);
5765	goto out;
5766	}
5767
5768	ret = ocfs2_et_root_journal_access(handle, et,
5769	OCFS2_JOURNAL_ACCESS_WRITE);
5770	if (ret) {
5771	mlog_errno(ret);
5772	goto out_commit;
5773	}
5774
5775	dquot_free_space_nodirty(inode,
5776	nr: ocfs2_clusters_to_bytes(sb: inode->i_sb, clusters: len));
5777
5778	ret = ocfs2_remove_extent(handle, et, cpos, len, meta_ac, dealloc);
5779	if (ret) {
5780	mlog_errno(ret);
5781	goto out_commit;
5782	}
5783
5784	ocfs2_et_update_clusters(et, clusters: -len);
5785	ocfs2_update_inode_fsync_trans(handle, inode, datasync: 1);
5786
5787	ocfs2_journal_dirty(handle, bh: et->et_root_bh);
5788
5789	if (phys_blkno) {
5790	if (flags & OCFS2_EXT_REFCOUNTED)
5791	ret = ocfs2_decrease_refcount(inode, handle,
5792	cpos: ocfs2_blocks_to_clusters(sb: osb->sb,
5793	blocks: phys_blkno),
5794	len, meta_ac,
5795	dealloc, delete: 1);
5796	else
5797	ret = ocfs2_truncate_log_append(osb, handle,
5798	start_blk: phys_blkno, num_clusters: len);
5799	if (ret)
5800	mlog_errno(ret);
5801
5802	}
5803
5804	out_commit:
5805	ocfs2_commit_trans(osb, handle);
5806	out:
5807	inode_unlock(inode: tl_inode);
5808	bail:
5809	if (meta_ac)
5810	ocfs2_free_alloc_context(ac: meta_ac);
5811
5812	if (ref_tree)
5813	ocfs2_unlock_refcount_tree(osb, tree: ref_tree, rw: 1);
5814
5815	return ret;
5816	}
5817
5818	int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb)
5819	{
5820	struct buffer_head *tl_bh = osb->osb_tl_bh;
5821	struct ocfs2_dinode *di;
5822	struct ocfs2_truncate_log *tl;
5823
5824	di = (struct ocfs2_dinode *) tl_bh->b_data;
5825	tl = &di->id2.i_dealloc;
5826
5827	mlog_bug_on_msg(le16_to_cpu(tl->tl_used) > le16_to_cpu(tl->tl_count),
5828	"slot %d, invalid truncate log parameters: used = "
5829	"%u, count = %u\n", osb->slot_num,
5830	le16_to_cpu(tl->tl_used), le16_to_cpu(tl->tl_count));
5831	return le16_to_cpu(tl->tl_used) == le16_to_cpu(tl->tl_count);
5832	}
5833
5834	static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl,
5835	unsigned int new_start)
5836	{
5837	unsigned int tail_index;
5838	unsigned int current_tail;
5839
5840	/* No records, nothing to coalesce */
5841	if (!le16_to_cpu(tl->tl_used))
5842	return 0;
5843
5844	tail_index = le16_to_cpu(tl->tl_used) - 1;
5845	current_tail = le32_to_cpu(tl->tl_recs[tail_index].t_start);
5846	current_tail += le32_to_cpu(tl->tl_recs[tail_index].t_clusters);
5847
5848	return current_tail == new_start;
5849	}
5850
5851	int ocfs2_truncate_log_append(struct ocfs2_super *osb,
5852	handle_t *handle,
5853	u64 start_blk,
5854	unsigned int num_clusters)
5855	{
5856	int status, index;
5857	unsigned int start_cluster, tl_count;
5858	struct inode *tl_inode = osb->osb_tl_inode;
5859	struct buffer_head *tl_bh = osb->osb_tl_bh;
5860	struct ocfs2_dinode *di;
5861	struct ocfs2_truncate_log *tl;
5862
5863	BUG_ON(inode_trylock(tl_inode));
5864
5865	start_cluster = ocfs2_blocks_to_clusters(sb: osb->sb, blocks: start_blk);
5866
5867	di = (struct ocfs2_dinode *) tl_bh->b_data;
5868
5869	/* tl_bh is loaded from ocfs2_truncate_log_init(). It's validated
5870	* by the underlying call to ocfs2_read_inode_block(), so any
5871	* corruption is a code bug */
5872	BUG_ON(!OCFS2_IS_VALID_DINODE(di));
5873
5874	tl = &di->id2.i_dealloc;
5875	tl_count = le16_to_cpu(tl->tl_count);
5876	mlog_bug_on_msg(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) ||
5877	tl_count == 0,
5878	"Truncate record count on #%llu invalid "
5879	"wanted %u, actual %u\n",
5880	(unsigned long long)OCFS2_I(tl_inode)->ip_blkno,
5881	ocfs2_truncate_recs_per_inode(osb->sb),
5882	le16_to_cpu(tl->tl_count));
5883
5884	/* Caller should have known to flush before calling us. */
5885	index = le16_to_cpu(tl->tl_used);
5886	if (index >= tl_count) {
5887	status = -ENOSPC;
5888	mlog_errno(status);
5889	goto bail;
5890	}
5891
5892	status = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode: tl_inode), bh: tl_bh,
5893	OCFS2_JOURNAL_ACCESS_WRITE);
5894	if (status < 0) {
5895	mlog_errno(status);
5896	goto bail;
5897	}
5898
5899	trace_ocfs2_truncate_log_append(
5900	blkno: (unsigned long long)OCFS2_I(inode: tl_inode)->ip_blkno, index,
5901	start: start_cluster, num: num_clusters);
5902	if (ocfs2_truncate_log_can_coalesce(tl, new_start: start_cluster)) {
5903	/*
5904	* Move index back to the record we are coalescing with.
5905	* ocfs2_truncate_log_can_coalesce() guarantees nonzero
5906	*/
5907	index--;
5908
5909	num_clusters += le32_to_cpu(tl->tl_recs[index].t_clusters);
5910	trace_ocfs2_truncate_log_append(
5911	blkno: (unsigned long long)OCFS2_I(inode: tl_inode)->ip_blkno,
5912	index, le32_to_cpu(tl->tl_recs[index].t_start),
5913	num: num_clusters);
5914	} else {
5915	tl->tl_recs[index].t_start = cpu_to_le32(start_cluster);
5916	tl->tl_used = cpu_to_le16(index + 1);
5917	}
5918	tl->tl_recs[index].t_clusters = cpu_to_le32(num_clusters);
5919
5920	ocfs2_journal_dirty(handle, bh: tl_bh);
5921
5922	osb->truncated_clusters += num_clusters;
5923	bail:
5924	return status;
5925	}
5926
5927	static int ocfs2_replay_truncate_records(struct ocfs2_super *osb,
5928	struct inode *data_alloc_inode,
5929	struct buffer_head *data_alloc_bh)
5930	{
5931	int status = 0;
5932	int i;
5933	unsigned int num_clusters;
5934	u64 start_blk;
5935	struct ocfs2_truncate_rec rec;
5936	struct ocfs2_dinode *di;
5937	struct ocfs2_truncate_log *tl;
5938	struct inode *tl_inode = osb->osb_tl_inode;
5939	struct buffer_head *tl_bh = osb->osb_tl_bh;
5940	handle_t *handle;
5941
5942	di = (struct ocfs2_dinode *) tl_bh->b_data;
5943	tl = &di->id2.i_dealloc;
5944	i = le16_to_cpu(tl->tl_used) - 1;
5945	while (i >= 0) {
5946	handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC);
5947	if (IS_ERR(ptr: handle)) {
5948	status = PTR_ERR(ptr: handle);
5949	mlog_errno(status);
5950	goto bail;
5951	}
5952
5953	/* Caller has given us at least enough credits to
5954	* update the truncate log dinode */
5955	status = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode: tl_inode), bh: tl_bh,
5956	OCFS2_JOURNAL_ACCESS_WRITE);
5957	if (status < 0) {
5958	ocfs2_commit_trans(osb, handle);
5959	mlog_errno(status);
5960	goto bail;
5961	}
5962
5963	tl->tl_used = cpu_to_le16(i);
5964
5965	ocfs2_journal_dirty(handle, bh: tl_bh);
5966
5967	rec = tl->tl_recs[i];
5968	start_blk = ocfs2_clusters_to_blocks(sb: data_alloc_inode->i_sb,
5969	le32_to_cpu(rec.t_start));
5970	num_clusters = le32_to_cpu(rec.t_clusters);
5971
5972	/* if start_blk is not set, we ignore the record as
5973	* invalid. */
5974	if (start_blk) {
5975	trace_ocfs2_replay_truncate_records(
5976	blkno: (unsigned long long)OCFS2_I(inode: tl_inode)->ip_blkno,
5977	index: i, le32_to_cpu(rec.t_start), num: num_clusters);
5978
5979	status = ocfs2_free_clusters(handle, bitmap_inode: data_alloc_inode,
5980	bitmap_bh: data_alloc_bh, start_blk,
5981	num_clusters);
5982	if (status < 0) {
5983	ocfs2_commit_trans(osb, handle);
5984	mlog_errno(status);
5985	goto bail;
5986	}
5987	}
5988
5989	ocfs2_commit_trans(osb, handle);
5990	i--;
5991	}
5992
5993	osb->truncated_clusters = 0;
5994
5995	bail:
5996	return status;
5997	}
5998
5999	/* Expects you to already be holding tl_inode->i_rwsem */
6000	int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
6001	{
6002	int status;
6003	unsigned int num_to_flush;
6004	struct inode *tl_inode = osb->osb_tl_inode;
6005	struct inode *data_alloc_inode = NULL;
6006	struct buffer_head *tl_bh = osb->osb_tl_bh;
6007	struct buffer_head *data_alloc_bh = NULL;
6008	struct ocfs2_dinode *di;
6009	struct ocfs2_truncate_log *tl;
6010	struct ocfs2_journal *journal = osb->journal;
6011
6012	BUG_ON(inode_trylock(tl_inode));
6013
6014	di = (struct ocfs2_dinode *) tl_bh->b_data;
6015
6016	/* tl_bh is loaded from ocfs2_truncate_log_init(). It's validated
6017	* by the underlying call to ocfs2_read_inode_block(), so any
6018	* corruption is a code bug */
6019	BUG_ON(!OCFS2_IS_VALID_DINODE(di));
6020
6021	tl = &di->id2.i_dealloc;
6022	num_to_flush = le16_to_cpu(tl->tl_used);
6023	trace_ocfs2_flush_truncate_log(
6024	val1: (unsigned long long)OCFS2_I(inode: tl_inode)->ip_blkno,
6025	val2: num_to_flush);
6026	if (!num_to_flush) {
6027	status = 0;
6028	goto out;
6029	}
6030
6031	/* Appending truncate log(TA) and flushing truncate log(TF) are
6032	* two separated transactions. They can be both committed but not
6033	* checkpointed. If crash occurs then, both two transaction will be
6034	* replayed with several already released to global bitmap clusters.
6035	* Then truncate log will be replayed resulting in cluster double free.
6036	*/
6037	jbd2_journal_lock_updates(journal->j_journal);
6038	status = jbd2_journal_flush(journal: journal->j_journal, flags: 0);
6039	jbd2_journal_unlock_updates(journal->j_journal);
6040	if (status < 0) {
6041	mlog_errno(status);
6042	goto out;
6043	}
6044
6045	data_alloc_inode = ocfs2_get_system_file_inode(osb,
6046	type: GLOBAL_BITMAP_SYSTEM_INODE,
6047	OCFS2_INVALID_SLOT);
6048	if (!data_alloc_inode) {
6049	status = -EINVAL;
6050	mlog(ML_ERROR, "Could not get bitmap inode!\n");
6051	goto out;
6052	}
6053
6054	inode_lock(inode: data_alloc_inode);
6055
6056	status = ocfs2_inode_lock(data_alloc_inode, &data_alloc_bh, 1);
6057	if (status < 0) {
6058	mlog_errno(status);
6059	goto out_mutex;
6060	}
6061
6062	status = ocfs2_replay_truncate_records(osb, data_alloc_inode,
6063	data_alloc_bh);
6064	if (status < 0)
6065	mlog_errno(status);
6066
6067	brelse(bh: data_alloc_bh);
6068	ocfs2_inode_unlock(inode: data_alloc_inode, ex: 1);
6069
6070	out_mutex:
6071	inode_unlock(inode: data_alloc_inode);
6072	iput(data_alloc_inode);
6073
6074	out:
6075	return status;
6076	}
6077
6078	int ocfs2_flush_truncate_log(struct ocfs2_super *osb)
6079	{
6080	int status;
6081	struct inode *tl_inode = osb->osb_tl_inode;
6082
6083	inode_lock(inode: tl_inode);
6084	status = __ocfs2_flush_truncate_log(osb);
6085	inode_unlock(inode: tl_inode);
6086
6087	return status;
6088	}
6089
6090	static void ocfs2_truncate_log_worker(struct work_struct *work)
6091	{
6092	int status;
6093	struct ocfs2_super *osb =
6094	container_of(work, struct ocfs2_super,
6095	osb_truncate_log_wq.work);
6096
6097	status = ocfs2_flush_truncate_log(osb);
6098	if (status < 0)
6099	mlog_errno(status);
6100	else
6101	ocfs2_init_steal_slots(osb);
6102	}
6103
6104	#define OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL (2 * HZ)
6105	void ocfs2_schedule_truncate_log_flush(struct ocfs2_super *osb,
6106	int cancel)
6107	{
6108	if (osb->osb_tl_inode &&
6109	atomic_read(v: &osb->osb_tl_disable) == 0) {
6110	/* We want to push off log flushes while truncates are
6111	* still running. */
6112	if (cancel)
6113	cancel_delayed_work(dwork: &osb->osb_truncate_log_wq);
6114
6115	queue_delayed_work(wq: osb->ocfs2_wq, dwork: &osb->osb_truncate_log_wq,
6116	OCFS2_TRUNCATE_LOG_FLUSH_INTERVAL);
6117	}
6118	}
6119
6120	/*
6121	* Try to flush truncate logs if we can free enough clusters from it.
6122	* As for return value, "< 0" means error, "0" no space and "1" means
6123	* we have freed enough spaces and let the caller try to allocate again.
6124	*/
6125	int ocfs2_try_to_free_truncate_log(struct ocfs2_super *osb,
6126	unsigned int needed)
6127	{
6128	tid_t target;
6129	int ret = 0;
6130	unsigned int truncated_clusters;
6131
6132	inode_lock(inode: osb->osb_tl_inode);
6133	truncated_clusters = osb->truncated_clusters;
6134	inode_unlock(inode: osb->osb_tl_inode);
6135
6136	/*
6137	* Check whether we can succeed in allocating if we free
6138	* the truncate log.
6139	*/
6140	if (truncated_clusters < needed)
6141	goto out;
6142
6143	ret = ocfs2_flush_truncate_log(osb);
6144	if (ret) {
6145	mlog_errno(ret);
6146	goto out;
6147	}
6148
6149	if (jbd2_journal_start_commit(journal: osb->journal->j_journal, tid: &target)) {
6150	jbd2_log_wait_commit(journal: osb->journal->j_journal, tid: target);
6151	ret = 1;
6152	}
6153	out:
6154	return ret;
6155	}
6156
6157	static int ocfs2_get_truncate_log_info(struct ocfs2_super *osb,
6158	int slot_num,
6159	struct inode **tl_inode,
6160	struct buffer_head **tl_bh)
6161	{
6162	int status;
6163	struct inode *inode = NULL;
6164	struct buffer_head *bh = NULL;
6165	struct ocfs2_dinode *di;
6166	struct ocfs2_truncate_log *tl;
6167	unsigned int tl_count, tl_used;
6168
6169	inode = ocfs2_get_system_file_inode(osb,
6170	type: TRUNCATE_LOG_SYSTEM_INODE,
6171	slot: slot_num);
6172	if (!inode) {
6173	status = -EINVAL;
6174	mlog(ML_ERROR, "Could not get load truncate log inode!\n");
6175	goto bail;
6176	}
6177
6178	status = ocfs2_read_inode_block(inode, bh: &bh);
6179	if (status < 0) {
6180	iput(inode);
6181	mlog_errno(status);
6182	goto bail;
6183	}
6184
6185	di = (struct ocfs2_dinode *)bh->b_data;
6186	tl = &di->id2.i_dealloc;
6187	tl_count = le16_to_cpu(tl->tl_count);
6188	tl_used = le16_to_cpu(tl->tl_used);
6189	if (unlikely(tl_count > ocfs2_truncate_recs_per_inode(osb->sb) ||
6190	tl_count == 0 ||
6191	tl_used > tl_count)) {
6192	status = -EFSCORRUPTED;
6193	iput(inode);
6194	brelse(bh);
6195	mlog_errno(status);
6196	goto bail;
6197	}
6198
6199	*tl_inode = inode;
6200	*tl_bh = bh;
6201	bail:
6202	return status;
6203	}
6204
6205	/* called during the 1st stage of node recovery. we stamp a clean
6206	* truncate log and pass back a copy for processing later. if the
6207	* truncate log does not require processing, a *tl_copy is set to
6208	* NULL. */
6209	int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
6210	int slot_num,
6211	struct ocfs2_dinode **tl_copy)
6212	{
6213	int status;
6214	struct inode *tl_inode = NULL;
6215	struct buffer_head *tl_bh = NULL;
6216	struct ocfs2_dinode *di;
6217	struct ocfs2_truncate_log *tl;
6218
6219	*tl_copy = NULL;
6220
6221	trace_ocfs2_begin_truncate_log_recovery(num: slot_num);
6222
6223	status = ocfs2_get_truncate_log_info(osb, slot_num, tl_inode: &tl_inode, tl_bh: &tl_bh);
6224	if (status < 0) {
6225	mlog_errno(status);
6226	goto bail;
6227	}
6228
6229	di = (struct ocfs2_dinode *) tl_bh->b_data;
6230
6231	/* tl_bh is loaded from ocfs2_get_truncate_log_info(). It's
6232	* validated by the underlying call to ocfs2_read_inode_block(),
6233	* so any corruption is a code bug */
6234	BUG_ON(!OCFS2_IS_VALID_DINODE(di));
6235
6236	tl = &di->id2.i_dealloc;
6237	if (le16_to_cpu(tl->tl_used)) {
6238	trace_ocfs2_truncate_log_recovery_num(le16_to_cpu(tl->tl_used));
6239
6240	/*
6241	* Assuming the write-out below goes well, this copy will be
6242	* passed back to recovery for processing.
6243	*/
6244	*tl_copy = kmemdup(tl_bh->b_data, tl_bh->b_size, GFP_KERNEL);
6245	if (!(*tl_copy)) {
6246	status = -ENOMEM;
6247	mlog_errno(status);
6248	goto bail;
6249	}
6250
6251	/* All we need to do to clear the truncate log is set
6252	* tl_used. */
6253	tl->tl_used = 0;
6254
6255	ocfs2_compute_meta_ecc(sb: osb->sb, data: tl_bh->b_data, bc: &di->i_check);
6256	status = ocfs2_write_block(osb, bh: tl_bh, ci: INODE_CACHE(inode: tl_inode));
6257	if (status < 0) {
6258	mlog_errno(status);
6259	goto bail;
6260	}
6261	}
6262
6263	bail:
6264	iput(tl_inode);
6265	brelse(bh: tl_bh);
6266
6267	if (status < 0) {
6268	kfree(objp: *tl_copy);
6269	*tl_copy = NULL;
6270	mlog_errno(status);
6271	}
6272
6273	return status;
6274	}
6275
6276	int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
6277	struct ocfs2_dinode *tl_copy)
6278	{
6279	int status = 0;
6280	int i;
6281	unsigned int clusters, num_recs, start_cluster;
6282	u64 start_blk;
6283	handle_t *handle;
6284	struct inode *tl_inode = osb->osb_tl_inode;
6285	struct ocfs2_truncate_log *tl;
6286
6287	if (OCFS2_I(inode: tl_inode)->ip_blkno == le64_to_cpu(tl_copy->i_blkno)) {
6288	mlog(ML_ERROR, "Asked to recover my own truncate log!\n");
6289	return -EINVAL;
6290	}
6291
6292	tl = &tl_copy->id2.i_dealloc;
6293	num_recs = le16_to_cpu(tl->tl_used);
6294	trace_ocfs2_complete_truncate_log_recovery(
6295	val1: (unsigned long long)le64_to_cpu(tl_copy->i_blkno),
6296	val2: num_recs);
6297
6298	inode_lock(inode: tl_inode);
6299	for(i = 0; i < num_recs; i++) {
6300	if (ocfs2_truncate_log_needs_flush(osb)) {
6301	status = __ocfs2_flush_truncate_log(osb);
6302	if (status < 0) {
6303	mlog_errno(status);
6304	goto bail_up;
6305	}
6306	}
6307
6308	handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
6309	if (IS_ERR(ptr: handle)) {
6310	status = PTR_ERR(ptr: handle);
6311	mlog_errno(status);
6312	goto bail_up;
6313	}
6314
6315	clusters = le32_to_cpu(tl->tl_recs[i].t_clusters);
6316	start_cluster = le32_to_cpu(tl->tl_recs[i].t_start);
6317	start_blk = ocfs2_clusters_to_blocks(sb: osb->sb, clusters: start_cluster);
6318
6319	status = ocfs2_truncate_log_append(osb, handle,
6320	start_blk, num_clusters: clusters);
6321	ocfs2_commit_trans(osb, handle);
6322	if (status < 0) {
6323	mlog_errno(status);
6324	goto bail_up;
6325	}
6326	}
6327
6328	bail_up:
6329	inode_unlock(inode: tl_inode);
6330
6331	return status;
6332	}
6333
6334	void ocfs2_truncate_log_shutdown(struct ocfs2_super *osb)
6335	{
6336	int status;
6337	struct inode *tl_inode = osb->osb_tl_inode;
6338
6339	atomic_set(v: &osb->osb_tl_disable, i: 1);
6340
6341	if (tl_inode) {
6342	cancel_delayed_work(dwork: &osb->osb_truncate_log_wq);
6343	flush_workqueue(osb->ocfs2_wq);
6344
6345	status = ocfs2_flush_truncate_log(osb);
6346	if (status < 0)
6347	mlog_errno(status);
6348
6349	brelse(bh: osb->osb_tl_bh);
6350	iput(osb->osb_tl_inode);
6351	}
6352	}
6353
6354	int ocfs2_truncate_log_init(struct ocfs2_super *osb)
6355	{
6356	int status;
6357	struct inode *tl_inode = NULL;
6358	struct buffer_head *tl_bh = NULL;
6359
6360	status = ocfs2_get_truncate_log_info(osb,
6361	slot_num: osb->slot_num,
6362	tl_inode: &tl_inode,
6363	tl_bh: &tl_bh);
6364	if (status < 0)
6365	mlog_errno(status);
6366
6367	/* ocfs2_truncate_log_shutdown keys on the existence of
6368	* osb->osb_tl_inode so we don't set any of the osb variables
6369	* until we're sure all is well. */
6370	INIT_DELAYED_WORK(&osb->osb_truncate_log_wq,
6371	ocfs2_truncate_log_worker);
6372	atomic_set(v: &osb->osb_tl_disable, i: 0);
6373	osb->osb_tl_bh = tl_bh;
6374	osb->osb_tl_inode = tl_inode;
6375
6376	return status;
6377	}
6378
6379	/*
6380	* Delayed de-allocation of suballocator blocks.
6381	*
6382	* Some sets of block de-allocations might involve multiple suballocator inodes.
6383	*
6384	* The locking for this can get extremely complicated, especially when
6385	* the suballocator inodes to delete from aren't known until deep
6386	* within an unrelated codepath.
6387	*
6388	* ocfs2_extent_block structures are a good example of this - an inode
6389	* btree could have been grown by any number of nodes each allocating
6390	* out of their own suballoc inode.
6391	*
6392	* These structures allow the delay of block de-allocation until a
6393	* later time, when locking of multiple cluster inodes won't cause
6394	* deadlock.
6395	*/
6396
6397	/*
6398	* Describe a single bit freed from a suballocator. For the block
6399	* suballocators, it represents one block. For the global cluster
6400	* allocator, it represents some clusters and free_bit indicates
6401	* clusters number.
6402	*/
6403	struct ocfs2_cached_block_free {
6404	struct ocfs2_cached_block_free *free_next;
6405	u64 free_bg;
6406	u64 free_blk;
6407	unsigned int free_bit;
6408	};
6409
6410	struct ocfs2_per_slot_free_list {
6411	struct ocfs2_per_slot_free_list *f_next_suballocator;
6412	int f_inode_type;
6413	int f_slot;
6414	struct ocfs2_cached_block_free *f_first;
6415	};
6416
6417	static int ocfs2_free_cached_blocks(struct ocfs2_super *osb,
6418	int sysfile_type,
6419	int slot,
6420	struct ocfs2_cached_block_free *head)
6421	{
6422	int ret;
6423	u64 bg_blkno;
6424	handle_t *handle;
6425	struct inode *inode;
6426	struct buffer_head *di_bh = NULL;
6427	struct ocfs2_cached_block_free *tmp;
6428
6429	inode = ocfs2_get_system_file_inode(osb, type: sysfile_type, slot);
6430	if (!inode) {
6431	ret = -EINVAL;
6432	mlog_errno(ret);
6433	goto out;
6434	}
6435
6436	inode_lock(inode);
6437
6438	ret = ocfs2_inode_lock(inode, &di_bh, 1);
6439	if (ret) {
6440	mlog_errno(ret);
6441	goto out_mutex;
6442	}
6443
6444	while (head) {
6445	if (head->free_bg)
6446	bg_blkno = head->free_bg;
6447	else
6448	bg_blkno = ocfs2_which_suballoc_group(block: head->free_blk,
6449	bit: head->free_bit);
6450	handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
6451	if (IS_ERR(ptr: handle)) {
6452	ret = PTR_ERR(ptr: handle);
6453	mlog_errno(ret);
6454	goto out_unlock;
6455	}
6456
6457	trace_ocfs2_free_cached_blocks(
6458	val1: (unsigned long long)head->free_blk, val2: head->free_bit);
6459
6460	ret = ocfs2_free_suballoc_bits(handle, alloc_inode: inode, alloc_bh: di_bh,
6461	start_bit: head->free_bit, bg_blkno, count: 1);
6462	if (ret)
6463	mlog_errno(ret);
6464
6465	ocfs2_commit_trans(osb, handle);
6466
6467	tmp = head;
6468	head = head->free_next;
6469	kfree(objp: tmp);
6470	}
6471
6472	out_unlock:
6473	ocfs2_inode_unlock(inode, ex: 1);
6474	brelse(bh: di_bh);
6475	out_mutex:
6476	inode_unlock(inode);
6477	iput(inode);
6478	out:
6479	while(head) {
6480	/* Premature exit may have left some dangling items. */
6481	tmp = head;
6482	head = head->free_next;
6483	kfree(objp: tmp);
6484	}
6485
6486	return ret;
6487	}
6488
6489	int ocfs2_cache_cluster_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
6490	u64 blkno, unsigned int bit)
6491	{
6492	int ret = 0;
6493	struct ocfs2_cached_block_free *item;
6494
6495	item = kzalloc(sizeof(*item), GFP_NOFS);
6496	if (item == NULL) {
6497	ret = -ENOMEM;
6498	mlog_errno(ret);
6499	return ret;
6500	}
6501
6502	trace_ocfs2_cache_cluster_dealloc(val1: (unsigned long long)blkno, val2: bit);
6503
6504	item->free_blk = blkno;
6505	item->free_bit = bit;
6506	item->free_next = ctxt->c_global_allocator;
6507
6508	ctxt->c_global_allocator = item;
6509	return ret;
6510	}
6511
6512	static int ocfs2_free_cached_clusters(struct ocfs2_super *osb,
6513	struct ocfs2_cached_block_free *head)
6514	{
6515	struct ocfs2_cached_block_free *tmp;
6516	struct inode *tl_inode = osb->osb_tl_inode;
6517	handle_t *handle;
6518	int ret = 0;
6519
6520	inode_lock(inode: tl_inode);
6521
6522	while (head) {
6523	if (ocfs2_truncate_log_needs_flush(osb)) {
6524	ret = __ocfs2_flush_truncate_log(osb);
6525	if (ret < 0) {
6526	mlog_errno(ret);
6527	break;
6528	}
6529	}
6530
6531	handle = ocfs2_start_trans(osb, OCFS2_TRUNCATE_LOG_UPDATE);
6532	if (IS_ERR(ptr: handle)) {
6533	ret = PTR_ERR(ptr: handle);
6534	mlog_errno(ret);
6535	break;
6536	}
6537
6538	ret = ocfs2_truncate_log_append(osb, handle, start_blk: head->free_blk,
6539	num_clusters: head->free_bit);
6540
6541	ocfs2_commit_trans(osb, handle);
6542	tmp = head;
6543	head = head->free_next;
6544	kfree(objp: tmp);
6545
6546	if (ret < 0) {
6547	mlog_errno(ret);
6548	break;
6549	}
6550	}
6551
6552	inode_unlock(inode: tl_inode);
6553
6554	while (head) {
6555	/* Premature exit may have left some dangling items. */
6556	tmp = head;
6557	head = head->free_next;
6558	kfree(objp: tmp);
6559	}
6560
6561	return ret;
6562	}
6563
6564	int ocfs2_run_deallocs(struct ocfs2_super *osb,
6565	struct ocfs2_cached_dealloc_ctxt *ctxt)
6566	{
6567	int ret = 0, ret2;
6568	struct ocfs2_per_slot_free_list *fl;
6569
6570	if (!ctxt)
6571	return 0;
6572
6573	while (ctxt->c_first_suballocator) {
6574	fl = ctxt->c_first_suballocator;
6575
6576	if (fl->f_first) {
6577	trace_ocfs2_run_deallocs(val1: fl->f_inode_type,
6578	val2: fl->f_slot);
6579	ret2 = ocfs2_free_cached_blocks(osb,
6580	sysfile_type: fl->f_inode_type,
6581	slot: fl->f_slot,
6582	head: fl->f_first);
6583	if (ret2)
6584	mlog_errno(ret2);
6585	if (!ret)
6586	ret = ret2;
6587	}
6588
6589	ctxt->c_first_suballocator = fl->f_next_suballocator;
6590	kfree(objp: fl);
6591	}
6592
6593	if (ctxt->c_global_allocator) {
6594	ret2 = ocfs2_free_cached_clusters(osb,
6595	head: ctxt->c_global_allocator);
6596	if (ret2)
6597	mlog_errno(ret2);
6598	if (!ret)
6599	ret = ret2;
6600
6601	ctxt->c_global_allocator = NULL;
6602	}
6603
6604	return ret;
6605	}
6606
6607	static struct ocfs2_per_slot_free_list *
6608	ocfs2_find_per_slot_free_list(int type,
6609	int slot,
6610	struct ocfs2_cached_dealloc_ctxt *ctxt)
6611	{
6612	struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
6613
6614	while (fl) {
6615	if (fl->f_inode_type == type && fl->f_slot == slot)
6616	return fl;
6617
6618	fl = fl->f_next_suballocator;
6619	}
6620
6621	fl = kmalloc(sizeof(*fl), GFP_NOFS);
6622	if (fl) {
6623	fl->f_inode_type = type;
6624	fl->f_slot = slot;
6625	fl->f_first = NULL;
6626	fl->f_next_suballocator = ctxt->c_first_suballocator;
6627
6628	ctxt->c_first_suballocator = fl;
6629	}
6630	return fl;
6631	}
6632
6633	static struct ocfs2_per_slot_free_list *
6634	ocfs2_find_preferred_free_list(int type,
6635	int preferred_slot,
6636	int *real_slot,
6637	struct ocfs2_cached_dealloc_ctxt *ctxt)
6638	{
6639	struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
6640
6641	while (fl) {
6642	if (fl->f_inode_type == type && fl->f_slot == preferred_slot) {
6643	*real_slot = fl->f_slot;
6644	return fl;
6645	}
6646
6647	fl = fl->f_next_suballocator;
6648	}
6649
6650	/* If we can't find any free list matching preferred slot, just use
6651	* the first one.
6652	*/
6653	fl = ctxt->c_first_suballocator;
6654	*real_slot = fl->f_slot;
6655
6656	return fl;
6657	}
6658
6659	/* Return Value 1 indicates empty */
6660	static int ocfs2_is_dealloc_empty(struct ocfs2_extent_tree *et)
6661	{
6662	struct ocfs2_per_slot_free_list *fl = NULL;
6663
6664	if (!et->et_dealloc)
6665	return 1;
6666
6667	fl = et->et_dealloc->c_first_suballocator;
6668	if (!fl)
6669	return 1;
6670
6671	if (!fl->f_first)
6672	return 1;
6673
6674	return 0;
6675	}
6676
6677	/* If extent was deleted from tree due to extent rotation and merging, and
6678	* no metadata is reserved ahead of time. Try to reuse some extents
6679	* just deleted. This is only used to reuse extent blocks.
6680	* It is supposed to find enough extent blocks in dealloc if our estimation
6681	* on metadata is accurate.
6682	*/
6683	static int ocfs2_reuse_blk_from_dealloc(handle_t *handle,
6684	struct ocfs2_extent_tree *et,
6685	struct buffer_head **new_eb_bh,
6686	int blk_wanted, int *blk_given)
6687	{
6688	int i, status = 0, real_slot;
6689	struct ocfs2_cached_dealloc_ctxt *dealloc;
6690	struct ocfs2_per_slot_free_list *fl;
6691	struct ocfs2_cached_block_free *bf;
6692	struct ocfs2_extent_block *eb;
6693	struct ocfs2_super *osb =
6694	OCFS2_SB(ocfs2_metadata_cache_get_super(et->et_ci));
6695
6696	*blk_given = 0;
6697
6698	/* If extent tree doesn't have a dealloc, this is not faulty. Just
6699	* tell upper caller dealloc can't provide any block and it should
6700	* ask for alloc to claim more space.
6701	*/
6702	dealloc = et->et_dealloc;
6703	if (!dealloc)
6704	goto bail;
6705
6706	for (i = 0; i < blk_wanted; i++) {
6707	/* Prefer to use local slot */
6708	fl = ocfs2_find_preferred_free_list(type: EXTENT_ALLOC_SYSTEM_INODE,
6709	preferred_slot: osb->slot_num, real_slot: &real_slot,
6710	ctxt: dealloc);
6711	/* If no more block can be reused, we should claim more
6712	* from alloc. Just return here normally.
6713	*/
6714	if (!fl) {
6715	status = 0;
6716	break;
6717	}
6718
6719	bf = fl->f_first;
6720	fl->f_first = bf->free_next;
6721
6722	new_eb_bh[i] = sb_getblk(sb: osb->sb, block: bf->free_blk);
6723	if (new_eb_bh[i] == NULL) {
6724	status = -ENOMEM;
6725	mlog_errno(status);
6726	goto bail;
6727	}
6728
6729	mlog(0, "Reusing block(%llu) from "
6730	"dealloc(local slot:%d, real slot:%d)\n",
6731	bf->free_blk, osb->slot_num, real_slot);
6732
6733	ocfs2_set_new_buffer_uptodate(ci: et->et_ci, bh: new_eb_bh[i]);
6734
6735	status = ocfs2_journal_access_eb(handle, ci: et->et_ci,
6736	bh: new_eb_bh[i],
6737	OCFS2_JOURNAL_ACCESS_CREATE);
6738	if (status < 0) {
6739	mlog_errno(status);
6740	goto bail;
6741	}
6742
6743	memset(new_eb_bh[i]->b_data, 0, osb->sb->s_blocksize);
6744	eb = (struct ocfs2_extent_block *) new_eb_bh[i]->b_data;
6745
6746	/* We can't guarantee that buffer head is still cached, so
6747	* polutlate the extent block again.
6748	*/
6749	strscpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
6750	eb->h_blkno = cpu_to_le64(bf->free_blk);
6751	eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
6752	eb->h_suballoc_slot = cpu_to_le16(real_slot);
6753	eb->h_suballoc_loc = cpu_to_le64(bf->free_bg);
6754	eb->h_suballoc_bit = cpu_to_le16(bf->free_bit);
6755	eb->h_list.l_count =
6756	cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
6757
6758	/* We'll also be dirtied by the caller, so
6759	* this isn't absolutely necessary.
6760	*/
6761	ocfs2_journal_dirty(handle, bh: new_eb_bh[i]);
6762
6763	if (!fl->f_first) {
6764	dealloc->c_first_suballocator = fl->f_next_suballocator;
6765	kfree(objp: fl);
6766	}
6767	kfree(objp: bf);
6768	}
6769
6770	*blk_given = i;
6771
6772	bail:
6773	if (unlikely(status < 0)) {
6774	for (i = 0; i < blk_wanted; i++)
6775	brelse(bh: new_eb_bh[i]);
6776	}
6777
6778	return status;
6779	}
6780
6781	int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
6782	int type, int slot, u64 suballoc,
6783	u64 blkno, unsigned int bit)
6784	{
6785	int ret;
6786	struct ocfs2_per_slot_free_list *fl;
6787	struct ocfs2_cached_block_free *item;
6788
6789	fl = ocfs2_find_per_slot_free_list(type, slot, ctxt);
6790	if (fl == NULL) {
6791	ret = -ENOMEM;
6792	mlog_errno(ret);
6793	goto out;
6794	}
6795
6796	item = kzalloc(sizeof(*item), GFP_NOFS);
6797	if (item == NULL) {
6798	ret = -ENOMEM;
6799	mlog_errno(ret);
6800	goto out;
6801	}
6802
6803	trace_ocfs2_cache_block_dealloc(type, slot,
6804	suballoc: (unsigned long long)suballoc,
6805	blkno: (unsigned long long)blkno, bit);
6806
6807	item->free_bg = suballoc;
6808	item->free_blk = blkno;
6809	item->free_bit = bit;
6810	item->free_next = fl->f_first;
6811
6812	fl->f_first = item;
6813
6814	ret = 0;
6815	out:
6816	return ret;
6817	}
6818
6819	static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
6820	struct ocfs2_extent_block *eb)
6821	{
6822	return ocfs2_cache_block_dealloc(ctxt, type: EXTENT_ALLOC_SYSTEM_INODE,
6823	le16_to_cpu(eb->h_suballoc_slot),
6824	le64_to_cpu(eb->h_suballoc_loc),
6825	le64_to_cpu(eb->h_blkno),
6826	le16_to_cpu(eb->h_suballoc_bit));
6827	}
6828
6829	static int ocfs2_zero_func(handle_t *handle, struct buffer_head *bh)
6830	{
6831	set_buffer_uptodate(bh);
6832	mark_buffer_dirty(bh);
6833	return 0;
6834	}
6835
6836	void ocfs2_map_and_dirty_folio(struct inode *inode, handle_t *handle,
6837	size_t from, size_t to, struct folio *folio, int zero,
6838	u64 *phys)
6839	{
6840	int ret, partial = 0;
6841	loff_t start_byte = folio_pos(folio) + from;
6842	loff_t length = to - from;
6843
6844	ret = ocfs2_map_folio_blocks(folio, p_blkno: phys, inode, from, to, new: 0);
6845	if (ret)
6846	mlog_errno(ret);
6847
6848	if (zero)
6849	folio_zero_segment(folio, start: from, xend: to);
6850
6851	/*
6852	* Need to set the buffers we zero'd into uptodate
6853	* here if they aren't - ocfs2_map_page_blocks()
6854	* might've skipped some
6855	*/
6856	ret = walk_page_buffers(handle, folio_buffers(folio),
6857	from, to, partial: &partial,
6858	fn: ocfs2_zero_func);
6859	if (ret < 0)
6860	mlog_errno(ret);
6861	else if (ocfs2_should_order_data(inode)) {
6862	ret = ocfs2_jbd2_inode_add_write(handle, inode,
6863	start_byte, length);
6864	if (ret < 0)
6865	mlog_errno(ret);
6866	}
6867
6868	if (!partial)
6869	folio_mark_uptodate(folio);
6870
6871	flush_dcache_folio(folio);
6872	}
6873
6874	static void ocfs2_zero_cluster_folios(struct inode *inode, loff_t start,
6875	loff_t end, struct folio **folios, int numfolios,
6876	u64 phys, handle_t *handle)
6877	{
6878	int i;
6879	struct super_block *sb = inode->i_sb;
6880
6881	BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(sb)));
6882
6883	if (numfolios == 0)
6884	goto out;
6885
6886	for (i = 0; i < numfolios; i++) {
6887	struct folio *folio = folios[i];
6888	size_t to = folio_size(folio);
6889	size_t from = offset_in_folio(folio, start);
6890
6891	if (to > end - folio_pos(folio))
6892	to = end - folio_pos(folio);
6893
6894	ocfs2_map_and_dirty_folio(inode, handle, from, to, folio, zero: 1,
6895	phys: &phys);
6896
6897	start = folio_next_pos(folio);
6898	}
6899	out:
6900	if (folios)
6901	ocfs2_unlock_and_free_folios(folios, num_folios: numfolios);
6902	}
6903
6904	static int ocfs2_grab_folios(struct inode *inode, loff_t start, loff_t end,
6905	struct folio **folios, int *num)
6906	{
6907	int numfolios, ret = 0;
6908	struct address_space *mapping = inode->i_mapping;
6909	unsigned long index;
6910	loff_t last_page_bytes;
6911
6912	BUG_ON(start > end);
6913
6914	numfolios = 0;
6915	last_page_bytes = PAGE_ALIGN(end);
6916	index = start >> PAGE_SHIFT;
6917	do {
6918	folios[numfolios] = __filemap_get_folio(mapping, index,
6919	FGP_LOCK | FGP_ACCESSED | FGP_CREAT, GFP_NOFS);
6920	if (IS_ERR(ptr: folios[numfolios])) {
6921	ret = PTR_ERR(ptr: folios[numfolios]);
6922	mlog_errno(ret);
6923	folios[numfolios] = NULL;
6924	goto out;
6925	}
6926
6927	index = folio_next_index(folio: folios[numfolios]);
6928	numfolios++;
6929	} while (index < (last_page_bytes >> PAGE_SHIFT));
6930
6931	out:
6932	if (ret != 0) {
6933	ocfs2_unlock_and_free_folios(folios, num_folios: numfolios);
6934	numfolios = 0;
6935	}
6936
6937	*num = numfolios;
6938
6939	return ret;
6940	}
6941
6942	static int ocfs2_grab_eof_folios(struct inode *inode, loff_t start, loff_t end,
6943	struct folio **folios, int *num)
6944	{
6945	struct super_block *sb = inode->i_sb;
6946
6947	BUG_ON(start >> OCFS2_SB(sb)->s_clustersize_bits !=
6948	(end - 1) >> OCFS2_SB(sb)->s_clustersize_bits);
6949
6950	return ocfs2_grab_folios(inode, start, end, folios, num);
6951	}
6952
6953	/*
6954	* Zero partial cluster for a hole punch or truncate. This avoids exposing
6955	* nonzero data on subsequent file extends.
6956	*
6957	* We need to call this before i_size is updated on the inode because
6958	* otherwise block_write_full_folio() will skip writeout of pages past
6959	* i_size.
6960	*/
6961	int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle,
6962	u64 range_start, u64 range_end)
6963	{
6964	int ret = 0, numfolios;
6965	struct folio **folios = NULL;
6966	u64 phys;
6967	unsigned int ext_flags;
6968	struct super_block *sb = inode->i_sb;
6969
6970	/*
6971	* File systems which don't support sparse files zero on every
6972	* extend.
6973	*/
6974	if (!ocfs2_sparse_alloc(OCFS2_SB(sb)))
6975	return 0;
6976
6977	/*
6978	* Avoid zeroing folios fully beyond current i_size. It is pointless as
6979	* underlying blocks of those folios should be already zeroed out and
6980	* page writeback will skip them anyway.
6981	*/
6982	range_end = min_t(u64, range_end, i_size_read(inode));
6983	if (range_start >= range_end)
6984	return 0;
6985
6986	folios = kcalloc(ocfs2_pages_per_cluster(sb),
6987	sizeof(struct folio *), GFP_NOFS);
6988	if (folios == NULL) {
6989	ret = -ENOMEM;
6990	mlog_errno(ret);
6991	goto out;
6992	}
6993
6994	ret = ocfs2_extent_map_get_blocks(inode,
6995	v_blkno: range_start >> sb->s_blocksize_bits,
6996	p_blkno: &phys, NULL, extent_flags: &ext_flags);
6997	if (ret) {
6998	mlog_errno(ret);
6999	goto out;
7000	}
7001
7002	/*
7003	* Tail is a hole, or is marked unwritten. In either case, we
7004	* can count on read and write to return/push zero's.
7005	*/
7006	if (phys == 0 || ext_flags & OCFS2_EXT_UNWRITTEN)
7007	goto out;
7008
7009	ret = ocfs2_grab_eof_folios(inode, start: range_start, end: range_end, folios,
7010	num: &numfolios);
7011	if (ret) {
7012	mlog_errno(ret);
7013	goto out;
7014	}
7015
7016	ocfs2_zero_cluster_folios(inode, start: range_start, end: range_end, folios,
7017	numfolios, phys, handle);
7018
7019	/*
7020	* Initiate writeout of the folios we zero'd here. We don't
7021	* wait on them - the truncate_inode_pages() call later will
7022	* do that for us.
7023	*/
7024	ret = filemap_fdatawrite_range(mapping: inode->i_mapping, start: range_start,
7025	end: range_end - 1);
7026	if (ret)
7027	mlog_errno(ret);
7028
7029	out:
7030	kfree(objp: folios);
7031
7032	return ret;
7033	}
7034
7035	static void ocfs2_zero_dinode_id2_with_xattr(struct inode *inode,
7036	struct ocfs2_dinode *di)
7037	{
7038	unsigned int blocksize = 1 << inode->i_sb->s_blocksize_bits;
7039	unsigned int xattrsize = le16_to_cpu(di->i_xattr_inline_size);
7040
7041	if (le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_XATTR_FL)
7042	memset(&di->id2, 0, blocksize -
7043	offsetof(struct ocfs2_dinode, id2) -
7044	xattrsize);
7045	else
7046	memset(&di->id2, 0, blocksize -
7047	offsetof(struct ocfs2_dinode, id2));
7048	}
7049
7050	void ocfs2_dinode_new_extent_list(struct inode *inode,
7051	struct ocfs2_dinode *di)
7052	{
7053	ocfs2_zero_dinode_id2_with_xattr(inode, di);
7054	di->id2.i_list.l_tree_depth = 0;
7055	di->id2.i_list.l_next_free_rec = 0;
7056	di->id2.i_list.l_count = cpu_to_le16(
7057	ocfs2_extent_recs_per_inode_with_xattr(inode->i_sb, di));
7058	}
7059
7060	void ocfs2_set_inode_data_inline(struct inode *inode, struct ocfs2_dinode *di)
7061	{
7062	struct ocfs2_inode_info *oi = OCFS2_I(inode);
7063	struct ocfs2_inline_data *idata = &di->id2.i_data;
7064
7065	spin_lock(lock: &oi->ip_lock);
7066	oi->ip_dyn_features |= OCFS2_INLINE_DATA_FL;
7067	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
7068	spin_unlock(lock: &oi->ip_lock);
7069
7070	/*
7071	* We clear the entire i_data structure here so that all
7072	* fields can be properly initialized.
7073	*/
7074	ocfs2_zero_dinode_id2_with_xattr(inode, di);
7075
7076	idata->id_count = cpu_to_le16(
7077	ocfs2_max_inline_data_with_xattr(inode->i_sb, di));
7078	}
7079
7080	int ocfs2_convert_inline_data_to_extents(struct inode *inode,
7081	struct buffer_head *di_bh)
7082	{
7083	int ret, has_data, num_folios = 0;
7084	int need_free = 0;
7085	u32 bit_off, num;
7086	handle_t *handle;
7087	u64 block;
7088	struct ocfs2_inode_info *oi = OCFS2_I(inode);
7089	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7090	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7091	struct ocfs2_alloc_context *data_ac = NULL;
7092	struct folio *folio = NULL;
7093	struct ocfs2_extent_tree et;
7094	int did_quota = 0;
7095
7096	has_data = i_size_read(inode) ? 1 : 0;
7097
7098	if (has_data) {
7099	ret = ocfs2_reserve_clusters(osb, bits_wanted: 1, ac: &data_ac);
7100	if (ret) {
7101	mlog_errno(ret);
7102	goto out;
7103	}
7104	}
7105
7106	handle = ocfs2_start_trans(osb,
7107	max_buffs: ocfs2_inline_to_extents_credits(sb: osb->sb));
7108	if (IS_ERR(ptr: handle)) {
7109	ret = PTR_ERR(ptr: handle);
7110	mlog_errno(ret);
7111	goto out;
7112	}
7113
7114	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode), bh: di_bh,
7115	OCFS2_JOURNAL_ACCESS_WRITE);
7116	if (ret) {
7117	mlog_errno(ret);
7118	goto out_commit;
7119	}
7120
7121	if (has_data) {
7122	unsigned int page_end = min_t(unsigned, PAGE_SIZE,
7123	osb->s_clustersize);
7124	u64 phys;
7125
7126	ret = dquot_alloc_space_nodirty(inode,
7127	nr: ocfs2_clusters_to_bytes(sb: osb->sb, clusters: 1));
7128	if (ret)
7129	goto out_commit;
7130	did_quota = 1;
7131
7132	data_ac->ac_resv = &oi->ip_la_data_resv;
7133
7134	ret = ocfs2_claim_clusters(handle, ac: data_ac, min_clusters: 1, cluster_start: &bit_off,
7135	num_clusters: &num);
7136	if (ret) {
7137	mlog_errno(ret);
7138	goto out_commit;
7139	}
7140
7141	/*
7142	* Save two copies, one for insert, and one that can
7143	* be changed by ocfs2_map_and_dirty_folio() below.
7144	*/
7145	block = phys = ocfs2_clusters_to_blocks(sb: inode->i_sb, clusters: bit_off);
7146
7147	ret = ocfs2_grab_eof_folios(inode, start: 0, end: page_end, folios: &folio,
7148	num: &num_folios);
7149	if (ret) {
7150	mlog_errno(ret);
7151	need_free = 1;
7152	goto out_commit;
7153	}
7154
7155	/*
7156	* This should populate the 1st page for us and mark
7157	* it up to date.
7158	*/
7159	ret = ocfs2_read_inline_data(inode, folio, di_bh);
7160	if (ret) {
7161	mlog_errno(ret);
7162	need_free = 1;
7163	goto out_unlock;
7164	}
7165
7166	ocfs2_map_and_dirty_folio(inode, handle, from: 0, to: page_end, folio, zero: 0,
7167	phys: &phys);
7168	}
7169
7170	spin_lock(lock: &oi->ip_lock);
7171	oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL;
7172	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
7173	spin_unlock(lock: &oi->ip_lock);
7174
7175	ocfs2_update_inode_fsync_trans(handle, inode, datasync: 1);
7176	ocfs2_dinode_new_extent_list(inode, di);
7177
7178	ocfs2_journal_dirty(handle, bh: di_bh);
7179
7180	if (has_data) {
7181	/*
7182	* An error at this point should be extremely rare. If
7183	* this proves to be false, we could always re-build
7184	* the in-inode data from our pages.
7185	*/
7186	ocfs2_init_dinode_extent_tree(et: &et, ci: INODE_CACHE(inode), bh: di_bh);
7187	ret = ocfs2_insert_extent(handle, et: &et, cpos: 0, start_blk: block, new_clusters: 1, flags: 0, NULL);
7188	if (ret) {
7189	mlog_errno(ret);
7190	need_free = 1;
7191	goto out_unlock;
7192	}
7193
7194	inode->i_blocks = ocfs2_inode_sector_count(inode);
7195	}
7196
7197	out_unlock:
7198	if (folio)
7199	ocfs2_unlock_and_free_folios(folios: &folio, num_folios);
7200
7201	out_commit:
7202	if (ret < 0 && did_quota)
7203	dquot_free_space_nodirty(inode,
7204	nr: ocfs2_clusters_to_bytes(sb: osb->sb, clusters: 1));
7205
7206	if (need_free) {
7207	if (data_ac->ac_which == OCFS2_AC_USE_LOCAL)
7208	ocfs2_free_local_alloc_bits(osb, handle, ac: data_ac,
7209	bit_off, num_bits: num);
7210	else
7211	ocfs2_free_clusters(handle,
7212	bitmap_inode: data_ac->ac_inode,
7213	bitmap_bh: data_ac->ac_bh,
7214	start_blk: ocfs2_clusters_to_blocks(sb: osb->sb, clusters: bit_off),
7215	num_clusters: num);
7216	}
7217
7218	ocfs2_commit_trans(osb, handle);
7219
7220	out:
7221	if (data_ac)
7222	ocfs2_free_alloc_context(ac: data_ac);
7223	return ret;
7224	}
7225
7226	/*
7227	* It is expected, that by the time you call this function,
7228	* inode->i_size and fe->i_size have been adjusted.
7229	*
7230	* WARNING: This will kfree the truncate context
7231	*/
7232	int ocfs2_commit_truncate(struct ocfs2_super *osb,
7233	struct inode *inode,
7234	struct buffer_head *di_bh)
7235	{
7236	int status = 0, i, flags = 0;
7237	u32 new_highest_cpos, range, trunc_cpos, trunc_len, phys_cpos, coff;
7238	u64 blkno = 0;
7239	struct ocfs2_extent_list *el;
7240	struct ocfs2_extent_rec *rec;
7241	struct ocfs2_path *path = NULL;
7242	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7243	struct ocfs2_extent_list *root_el = &(di->id2.i_list);
7244	u64 refcount_loc = le64_to_cpu(di->i_refcount_loc);
7245	struct ocfs2_extent_tree et;
7246	struct ocfs2_cached_dealloc_ctxt dealloc;
7247	struct ocfs2_refcount_tree *ref_tree = NULL;
7248
7249	ocfs2_init_dinode_extent_tree(et: &et, ci: INODE_CACHE(inode), bh: di_bh);
7250	ocfs2_init_dealloc_ctxt(c: &dealloc);
7251
7252	new_highest_cpos = ocfs2_clusters_for_bytes(sb: osb->sb,
7253	bytes: i_size_read(inode));
7254
7255	path = ocfs2_new_path(root_bh: di_bh, root_el: &di->id2.i_list,
7256	access: ocfs2_journal_access_di);
7257	if (!path) {
7258	status = -ENOMEM;
7259	mlog_errno(status);
7260	goto bail;
7261	}
7262
7263	ocfs2_extent_map_trunc(inode, cluster: new_highest_cpos);
7264
7265	start:
7266	/*
7267	* Check that we still have allocation to delete.
7268	*/
7269	if (OCFS2_I(inode)->ip_clusters == 0) {
7270	status = 0;
7271	goto bail;
7272	}
7273
7274	/*
7275	* Truncate always works against the rightmost tree branch.
7276	*/
7277	status = ocfs2_find_path(ci: INODE_CACHE(inode), path, UINT_MAX);
7278	if (status) {
7279	mlog_errno(status);
7280	goto bail;
7281	}
7282
7283	trace_ocfs2_commit_truncate(
7284	ino: (unsigned long long)OCFS2_I(inode)->ip_blkno,
7285	new_cpos: new_highest_cpos,
7286	clusters: OCFS2_I(inode)->ip_clusters,
7287	depth: path->p_tree_depth);
7288
7289	/*
7290	* By now, el will point to the extent list on the bottom most
7291	* portion of this tree. Only the tail record is considered in
7292	* each pass.
7293	*
7294	* We handle the following cases, in order:
7295	* - empty extent: delete the remaining branch
7296	* - remove the entire record
7297	* - remove a partial record
7298	* - no record needs to be removed (truncate has completed)
7299	*/
7300	el = path_leaf_el(path);
7301	if (le16_to_cpu(el->l_next_free_rec) == 0) {
7302	ocfs2_error(inode->i_sb,
7303	"Inode %llu has empty extent block at %llu\n",
7304	(unsigned long long)OCFS2_I(inode)->ip_blkno,
7305	(unsigned long long)path_leaf_bh(path)->b_blocknr);
7306	status = -EROFS;
7307	goto bail;
7308	}
7309
7310	i = le16_to_cpu(el->l_next_free_rec) - 1;
7311	rec = &el->l_recs[i];
7312	flags = rec->e_flags;
7313	range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
7314
7315	if (i == 0 && ocfs2_is_empty_extent(rec)) {
7316	/*
7317	* Lower levels depend on this never happening, but it's best
7318	* to check it up here before changing the tree.
7319	*/
7320	if (root_el->l_tree_depth && rec->e_int_clusters == 0) {
7321	mlog(ML_ERROR, "Inode %lu has an empty "
7322	"extent record, depth %u\n", inode->i_ino,
7323	le16_to_cpu(root_el->l_tree_depth));
7324	status = ocfs2_remove_rightmost_empty_extent(osb,
7325	et: &et, path, dealloc: &dealloc);
7326	if (status) {
7327	mlog_errno(status);
7328	goto bail;
7329	}
7330
7331	ocfs2_reinit_path(path, keep_root: 1);
7332	goto start;
7333	} else {
7334	trunc_cpos = le32_to_cpu(rec->e_cpos);
7335	trunc_len = 0;
7336	blkno = 0;
7337	}
7338	} else if (le32_to_cpu(rec->e_cpos) >= new_highest_cpos) {
7339	/*
7340	* Truncate entire record.
7341	*/
7342	trunc_cpos = le32_to_cpu(rec->e_cpos);
7343	trunc_len = ocfs2_rec_clusters(el, rec);
7344	blkno = le64_to_cpu(rec->e_blkno);
7345	} else if (range > new_highest_cpos) {
7346	/*
7347	* Partial truncate. it also should be
7348	* the last truncate we're doing.
7349	*/
7350	trunc_cpos = new_highest_cpos;
7351	trunc_len = range - new_highest_cpos;
7352	coff = new_highest_cpos - le32_to_cpu(rec->e_cpos);
7353	blkno = le64_to_cpu(rec->e_blkno) +
7354	ocfs2_clusters_to_blocks(sb: inode->i_sb, clusters: coff);
7355	} else {
7356	/*
7357	* Truncate completed, leave happily.
7358	*/
7359	status = 0;
7360	goto bail;
7361	}
7362
7363	phys_cpos = ocfs2_blocks_to_clusters(sb: inode->i_sb, blocks: blkno);
7364
7365	if ((flags & OCFS2_EXT_REFCOUNTED) && trunc_len && !ref_tree) {
7366	status = ocfs2_lock_refcount_tree(osb, ref_blkno: refcount_loc, rw: 1,
7367	tree: &ref_tree, NULL);
7368	if (status) {
7369	mlog_errno(status);
7370	goto bail;
7371	}
7372	}
7373
7374	status = ocfs2_remove_btree_range(inode, et: &et, cpos: trunc_cpos,
7375	phys_cpos, len: trunc_len, flags, dealloc: &dealloc,
7376	refcount_loc, refcount_tree_locked: true);
7377	if (status < 0) {
7378	mlog_errno(status);
7379	goto bail;
7380	}
7381
7382	ocfs2_reinit_path(path, keep_root: 1);
7383
7384	/*
7385	* The check above will catch the case where we've truncated
7386	* away all allocation.
7387	*/
7388	goto start;
7389
7390	bail:
7391	if (ref_tree)
7392	ocfs2_unlock_refcount_tree(osb, tree: ref_tree, rw: 1);
7393
7394	ocfs2_schedule_truncate_log_flush(osb, cancel: 1);
7395
7396	ocfs2_run_deallocs(osb, ctxt: &dealloc);
7397
7398	ocfs2_free_path(path);
7399
7400	return status;
7401	}
7402
7403	/*
7404	* 'start' is inclusive, 'end' is not.
7405	*/
7406	int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh,
7407	unsigned int start, unsigned int end, int trunc)
7408	{
7409	int ret;
7410	unsigned int numbytes;
7411	handle_t *handle;
7412	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
7413	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
7414	struct ocfs2_inline_data *idata = &di->id2.i_data;
7415
7416	/* No need to punch hole beyond i_size. */
7417	if (start >= i_size_read(inode))
7418	return 0;
7419
7420	if (end > i_size_read(inode))
7421	end = i_size_read(inode);
7422
7423	BUG_ON(start > end);
7424
7425	if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) ||
7426	!(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL) ||
7427	!ocfs2_supports_inline_data(osb)) {
7428	ocfs2_error(inode->i_sb,
7429	"Inline data flags for inode %llu don't agree! Disk: 0x%x, Memory: 0x%x, Superblock: 0x%x\n",
7430	(unsigned long long)OCFS2_I(inode)->ip_blkno,
7431	le16_to_cpu(di->i_dyn_features),
7432	OCFS2_I(inode)->ip_dyn_features,
7433	osb->s_feature_incompat);
7434	ret = -EROFS;
7435	goto out;
7436	}
7437
7438	handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
7439	if (IS_ERR(ptr: handle)) {
7440	ret = PTR_ERR(ptr: handle);
7441	mlog_errno(ret);
7442	goto out;
7443	}
7444
7445	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode), bh: di_bh,
7446	OCFS2_JOURNAL_ACCESS_WRITE);
7447	if (ret) {
7448	mlog_errno(ret);
7449	goto out_commit;
7450	}
7451
7452	numbytes = end - start;
7453	memset(idata->id_data + start, 0, numbytes);
7454
7455	/*
7456	* No need to worry about the data page here - it's been
7457	* truncated already and inline data doesn't need it for
7458	* pushing zero's to disk, so we'll let read_folio pick it up
7459	* later.
7460	*/
7461	if (trunc) {
7462	i_size_write(inode, i_size: start);
7463	di->i_size = cpu_to_le64(start);
7464	}
7465
7466	inode->i_blocks = ocfs2_inode_sector_count(inode);
7467	inode_set_mtime_to_ts(inode, ts: inode_set_ctime_current(inode));
7468
7469	di->i_ctime = di->i_mtime = cpu_to_le64(inode_get_ctime_sec(inode));
7470	di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
7471
7472	ocfs2_update_inode_fsync_trans(handle, inode, datasync: 1);
7473	ocfs2_journal_dirty(handle, bh: di_bh);
7474
7475	out_commit:
7476	ocfs2_commit_trans(osb, handle);
7477
7478	out:
7479	return ret;
7480	}
7481
7482	static int ocfs2_trim_extent(struct super_block *sb,
7483	struct ocfs2_group_desc *gd,
7484	u64 group, u32 start, u32 count)
7485	{
7486	u64 discard, bcount;
7487	struct ocfs2_super *osb = OCFS2_SB(sb);
7488
7489	bcount = ocfs2_clusters_to_blocks(sb, clusters: count);
7490	discard = ocfs2_clusters_to_blocks(sb, clusters: start);
7491
7492	/*
7493	* For the first cluster group, the gd->bg_blkno is not at the start
7494	* of the group, but at an offset from the start. If we add it while
7495	* calculating discard for first group, we will wrongly start fstrim a
7496	* few blocks after the desried start block and the range can cross
7497	* over into the next cluster group. So, add it only if this is not
7498	* the first cluster group.
7499	*/
7500	if (group != osb->first_cluster_group_blkno)
7501	discard += le64_to_cpu(gd->bg_blkno);
7502
7503	trace_ocfs2_trim_extent(sb, blk: (unsigned long long)discard, count: bcount);
7504
7505	return sb_issue_discard(sb, block: discard, nr_blocks: bcount, GFP_NOFS, flags: 0);
7506	}
7507
7508	static int ocfs2_trim_group(struct super_block *sb,
7509	struct ocfs2_group_desc *gd, u64 group,
7510	u32 start, u32 max, u32 minbits)
7511	{
7512	int ret = 0, count = 0, next;
7513	void *bitmap = gd->bg_bitmap;
7514
7515	if (le16_to_cpu(gd->bg_free_bits_count) < minbits)
7516	return 0;
7517
7518	trace_ocfs2_trim_group(ull: (unsigned long long)le64_to_cpu(gd->bg_blkno),
7519	value1: start, value2: max, value3: minbits);
7520
7521	while (start < max) {
7522	start = ocfs2_find_next_zero_bit(addr: bitmap, size: max, offset: start);
7523	if (start >= max)
7524	break;
7525	next = ocfs2_find_next_bit(addr: bitmap, size: max, offset: start);
7526
7527	if ((next - start) >= minbits) {
7528	ret = ocfs2_trim_extent(sb, gd, group,
7529	start, count: next - start);
7530	if (ret < 0) {
7531	mlog_errno(ret);
7532	break;
7533	}
7534	count += next - start;
7535	}
7536	start = next + 1;
7537
7538	if (fatal_signal_pending(current)) {
7539	count = -ERESTARTSYS;
7540	break;
7541	}
7542
7543	if ((le16_to_cpu(gd->bg_free_bits_count) - count) < minbits)
7544	break;
7545	}
7546
7547	if (ret < 0)
7548	count = ret;
7549
7550	return count;
7551	}
7552
7553	static
7554	int ocfs2_trim_mainbm(struct super_block *sb, struct fstrim_range *range)
7555	{
7556	struct ocfs2_super *osb = OCFS2_SB(sb);
7557	u64 start, len, trimmed = 0, first_group, last_group = 0, group = 0;
7558	int ret, cnt;
7559	u32 first_bit, last_bit, minlen;
7560	struct buffer_head *main_bm_bh = NULL;
7561	struct inode *main_bm_inode = NULL;
7562	struct buffer_head *gd_bh = NULL;
7563	struct ocfs2_dinode *main_bm;
7564	struct ocfs2_group_desc *gd = NULL;
7565
7566	start = range->start >> osb->s_clustersize_bits;
7567	len = range->len >> osb->s_clustersize_bits;
7568	minlen = range->minlen >> osb->s_clustersize_bits;
7569
7570	if (minlen >= osb->bitmap_cpg || range->len < sb->s_blocksize)
7571	return -EINVAL;
7572
7573	trace_ocfs2_trim_mainbm(value1: start, value2: len, value3: minlen);
7574
7575	next_group:
7576	main_bm_inode = ocfs2_get_system_file_inode(osb,
7577	type: GLOBAL_BITMAP_SYSTEM_INODE,
7578	OCFS2_INVALID_SLOT);
7579	if (!main_bm_inode) {
7580	ret = -EIO;
7581	mlog_errno(ret);
7582	goto out;
7583	}
7584
7585	inode_lock(inode: main_bm_inode);
7586
7587	ret = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 0);
7588	if (ret < 0) {
7589	mlog_errno(ret);
7590	goto out_mutex;
7591	}
7592	main_bm = (struct ocfs2_dinode *)main_bm_bh->b_data;
7593
7594	/*
7595	* Do some check before trim the first group.
7596	*/
7597	if (!group) {
7598	if (start >= le32_to_cpu(main_bm->i_clusters)) {
7599	ret = -EINVAL;
7600	goto out_unlock;
7601	}
7602
7603	if (start + len > le32_to_cpu(main_bm->i_clusters))
7604	len = le32_to_cpu(main_bm->i_clusters) - start;
7605
7606	/*
7607	* Determine first and last group to examine based on
7608	* start and len
7609	*/
7610	first_group = ocfs2_which_cluster_group(inode: main_bm_inode, cluster: start);
7611	if (first_group == osb->first_cluster_group_blkno)
7612	first_bit = start;
7613	else
7614	first_bit = start - ocfs2_blocks_to_clusters(sb,
7615	blocks: first_group);
7616	last_group = ocfs2_which_cluster_group(inode: main_bm_inode,
7617	cluster: start + len - 1);
7618	group = first_group;
7619	}
7620
7621	do {
7622	if (first_bit + len >= osb->bitmap_cpg)
7623	last_bit = osb->bitmap_cpg;
7624	else
7625	last_bit = first_bit + len;
7626
7627	ret = ocfs2_read_group_descriptor(inode: main_bm_inode,
7628	di: main_bm, gd_blkno: group,
7629	bh: &gd_bh);
7630	if (ret < 0) {
7631	mlog_errno(ret);
7632	break;
7633	}
7634
7635	gd = (struct ocfs2_group_desc *)gd_bh->b_data;
7636	cnt = ocfs2_trim_group(sb, gd, group,
7637	start: first_bit, max: last_bit, minbits: minlen);
7638	brelse(bh: gd_bh);
7639	gd_bh = NULL;
7640	if (cnt < 0) {
7641	ret = cnt;
7642	mlog_errno(ret);
7643	break;
7644	}
7645
7646	trimmed += cnt;
7647	len -= osb->bitmap_cpg - first_bit;
7648	first_bit = 0;
7649	if (group == osb->first_cluster_group_blkno)
7650	group = ocfs2_clusters_to_blocks(sb, clusters: osb->bitmap_cpg);
7651	else
7652	group += ocfs2_clusters_to_blocks(sb, clusters: osb->bitmap_cpg);
7653	} while (0);
7654
7655	out_unlock:
7656	ocfs2_inode_unlock(inode: main_bm_inode, ex: 0);
7657	brelse(bh: main_bm_bh);
7658	main_bm_bh = NULL;
7659	out_mutex:
7660	inode_unlock(inode: main_bm_inode);
7661	iput(main_bm_inode);
7662
7663	/*
7664	* If all the groups trim are not done or failed, but we should release
7665	* main_bm related locks for avoiding the current IO starve, then go to
7666	* trim the next group
7667	*/
7668	if (ret >= 0 && group <= last_group) {
7669	cond_resched();
7670	goto next_group;
7671	}
7672	out:
7673	range->len = trimmed * osb->s_clustersize;
7674	return ret;
7675	}
7676
7677	int ocfs2_trim_fs(struct super_block *sb, struct fstrim_range *range)
7678	{
7679	int ret;
7680	struct ocfs2_super *osb = OCFS2_SB(sb);
7681	struct ocfs2_trim_fs_info info, *pinfo = NULL;
7682
7683	ocfs2_trim_fs_lock_res_init(osb);
7684
7685	trace_ocfs2_trim_fs(value1: range->start, value2: range->len, value3: range->minlen);
7686
7687	ret = ocfs2_trim_fs_lock(osb, NULL, trylock: 1);
7688	if (ret < 0) {
7689	if (ret != -EAGAIN) {
7690	mlog_errno(ret);
7691	ocfs2_trim_fs_lock_res_uninit(osb);
7692	return ret;
7693	}
7694
7695	mlog(ML_NOTICE, "Wait for trim on device (%s) to "
7696	"finish, which is running from another node.\n",
7697	osb->dev_str);
7698	ret = ocfs2_trim_fs_lock(osb, info: &info, trylock: 0);
7699	if (ret < 0) {
7700	mlog_errno(ret);
7701	ocfs2_trim_fs_lock_res_uninit(osb);
7702	return ret;
7703	}
7704
7705	if (info.tf_valid && info.tf_success &&
7706	info.tf_start == range->start &&
7707	info.tf_len == range->len &&
7708	info.tf_minlen == range->minlen) {
7709	/* Avoid sending duplicated trim to a shared device */
7710	mlog(ML_NOTICE, "The same trim on device (%s) was "
7711	"just done from node (%u), return.\n",
7712	osb->dev_str, info.tf_nodenum);
7713	range->len = info.tf_trimlen;
7714	goto out;
7715	}
7716	}
7717
7718	info.tf_nodenum = osb->node_num;
7719	info.tf_start = range->start;
7720	info.tf_len = range->len;
7721	info.tf_minlen = range->minlen;
7722
7723	ret = ocfs2_trim_mainbm(sb, range);
7724
7725	info.tf_trimlen = range->len;
7726	info.tf_success = (ret < 0 ? 0 : 1);
7727	pinfo = &info;
7728	out:
7729	ocfs2_trim_fs_unlock(osb, info: pinfo);
7730	ocfs2_trim_fs_lock_res_uninit(osb);
7731	return ret;
7732	}
7733