1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* refcounttree.c
4	*
5	* Copyright (C) 2009 Oracle. All rights reserved.
6	*/
7
8	#include <linux/sort.h>
9	#include <cluster/masklog.h>
10	#include "ocfs2.h"
11	#include "inode.h"
12	#include "alloc.h"
13	#include "suballoc.h"
14	#include "journal.h"
15	#include "uptodate.h"
16	#include "super.h"
17	#include "buffer_head_io.h"
18	#include "blockcheck.h"
19	#include "refcounttree.h"
20	#include "sysfile.h"
21	#include "dlmglue.h"
22	#include "extent_map.h"
23	#include "aops.h"
24	#include "xattr.h"
25	#include "namei.h"
26	#include "ocfs2_trace.h"
27	#include "file.h"
28
29	#include <linux/bio.h>
30	#include <linux/blkdev.h>
31	#include <linux/slab.h>
32	#include <linux/writeback.h>
33	#include <linux/pagevec.h>
34	#include <linux/swap.h>
35	#include <linux/security.h>
36	#include <linux/fsnotify.h>
37	#include <linux/quotaops.h>
38	#include <linux/namei.h>
39	#include <linux/mount.h>
40	#include <linux/posix_acl.h>
41
42	struct ocfs2_cow_context {
43	struct inode *inode;
44	u32 cow_start;
45	u32 cow_len;
46	struct ocfs2_extent_tree data_et;
47	struct ocfs2_refcount_tree *ref_tree;
48	struct buffer_head *ref_root_bh;
49	struct ocfs2_alloc_context *meta_ac;
50	struct ocfs2_alloc_context *data_ac;
51	struct ocfs2_cached_dealloc_ctxt dealloc;
52	void *cow_object;
53	struct ocfs2_post_refcount *post_refcount;
54	int extra_credits;
55	int (*get_clusters)(struct ocfs2_cow_context *context,
56	u32 v_cluster, u32 *p_cluster,
57	u32 *num_clusters,
58	unsigned int *extent_flags);
59	int (*cow_duplicate_clusters)(handle_t *handle,
60	struct inode *inode,
61	u32 cpos, u32 old_cluster,
62	u32 new_cluster, u32 new_len);
63	};
64
65	static inline struct ocfs2_refcount_tree *
66	cache_info_to_refcount(struct ocfs2_caching_info *ci)
67	{
68	return container_of(ci, struct ocfs2_refcount_tree, rf_ci);
69	}
70
71	static int ocfs2_validate_refcount_block(struct super_block *sb,
72	struct buffer_head *bh)
73	{
74	int rc;
75	struct ocfs2_refcount_block *rb =
76	(struct ocfs2_refcount_block *)bh->b_data;
77
78	trace_ocfs2_validate_refcount_block(num: (unsigned long long)bh->b_blocknr);
79
80	BUG_ON(!buffer_uptodate(bh));
81
82	/*
83	* If the ecc fails, we return the error but otherwise
84	* leave the filesystem running. We know any error is
85	* local to this block.
86	*/
87	rc = ocfs2_validate_meta_ecc(sb, data: bh->b_data, bc: &rb->rf_check);
88	if (rc) {
89	mlog(ML_ERROR, "Checksum failed for refcount block %llu\n",
90	(unsigned long long)bh->b_blocknr);
91	return rc;
92	}
93
94
95	if (!OCFS2_IS_VALID_REFCOUNT_BLOCK(rb)) {
96	rc = ocfs2_error(sb,
97	"Refcount block #%llu has bad signature %.*s\n",
98	(unsigned long long)bh->b_blocknr, 7,
99	rb->rf_signature);
100	goto out;
101	}
102
103	if (le64_to_cpu(rb->rf_blkno) != bh->b_blocknr) {
104	rc = ocfs2_error(sb,
105	"Refcount block #%llu has an invalid rf_blkno of %llu\n",
106	(unsigned long long)bh->b_blocknr,
107	(unsigned long long)le64_to_cpu(rb->rf_blkno));
108	goto out;
109	}
110
111	if (le32_to_cpu(rb->rf_fs_generation) != OCFS2_SB(sb)->fs_generation) {
112	rc = ocfs2_error(sb,
113	"Refcount block #%llu has an invalid rf_fs_generation of #%u\n",
114	(unsigned long long)bh->b_blocknr,
115	le32_to_cpu(rb->rf_fs_generation));
116	goto out;
117	}
118	out:
119	return rc;
120	}
121
122	static int ocfs2_read_refcount_block(struct ocfs2_caching_info *ci,
123	u64 rb_blkno,
124	struct buffer_head **bh)
125	{
126	int rc;
127	struct buffer_head *tmp = *bh;
128
129	rc = ocfs2_read_block(ci, off: rb_blkno, bh: &tmp,
130	validate: ocfs2_validate_refcount_block);
131
132	/* If ocfs2_read_block() got us a new bh, pass it up. */
133	if (!rc && !*bh)
134	*bh = tmp;
135
136	return rc;
137	}
138
139	static u64 ocfs2_refcount_cache_owner(struct ocfs2_caching_info *ci)
140	{
141	struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
142
143	return rf->rf_blkno;
144	}
145
146	static struct super_block *
147	ocfs2_refcount_cache_get_super(struct ocfs2_caching_info *ci)
148	{
149	struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
150
151	return rf->rf_sb;
152	}
153
154	static void ocfs2_refcount_cache_lock(struct ocfs2_caching_info *ci)
155	__acquires(&rf->rf_lock)
156	{
157	struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
158
159	spin_lock(lock: &rf->rf_lock);
160	}
161
162	static void ocfs2_refcount_cache_unlock(struct ocfs2_caching_info *ci)
163	__releases(&rf->rf_lock)
164	{
165	struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
166
167	spin_unlock(lock: &rf->rf_lock);
168	}
169
170	static void ocfs2_refcount_cache_io_lock(struct ocfs2_caching_info *ci)
171	{
172	struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
173
174	mutex_lock(&rf->rf_io_mutex);
175	}
176
177	static void ocfs2_refcount_cache_io_unlock(struct ocfs2_caching_info *ci)
178	{
179	struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci);
180
181	mutex_unlock(lock: &rf->rf_io_mutex);
182	}
183
184	static const struct ocfs2_caching_operations ocfs2_refcount_caching_ops = {
185	.co_owner = ocfs2_refcount_cache_owner,
186	.co_get_super = ocfs2_refcount_cache_get_super,
187	.co_cache_lock = ocfs2_refcount_cache_lock,
188	.co_cache_unlock = ocfs2_refcount_cache_unlock,
189	.co_io_lock = ocfs2_refcount_cache_io_lock,
190	.co_io_unlock = ocfs2_refcount_cache_io_unlock,
191	};
192
193	static struct ocfs2_refcount_tree *
194	ocfs2_find_refcount_tree(struct ocfs2_super *osb, u64 blkno)
195	{
196	struct rb_node *n = osb->osb_rf_lock_tree.rb_node;
197	struct ocfs2_refcount_tree *tree = NULL;
198
199	while (n) {
200	tree = rb_entry(n, struct ocfs2_refcount_tree, rf_node);
201
202	if (blkno < tree->rf_blkno)
203	n = n->rb_left;
204	else if (blkno > tree->rf_blkno)
205	n = n->rb_right;
206	else
207	return tree;
208	}
209
210	return NULL;
211	}
212
213	/* osb_lock is already locked. */
214	static void ocfs2_insert_refcount_tree(struct ocfs2_super *osb,
215	struct ocfs2_refcount_tree *new)
216	{
217	u64 rf_blkno = new->rf_blkno;
218	struct rb_node *parent = NULL;
219	struct rb_node **p = &osb->osb_rf_lock_tree.rb_node;
220	struct ocfs2_refcount_tree *tmp;
221
222	while (*p) {
223	parent = *p;
224
225	tmp = rb_entry(parent, struct ocfs2_refcount_tree,
226	rf_node);
227
228	if (rf_blkno < tmp->rf_blkno)
229	p = &(*p)->rb_left;
230	else if (rf_blkno > tmp->rf_blkno)
231	p = &(*p)->rb_right;
232	else {
233	/* This should never happen! */
234	mlog(ML_ERROR, "Duplicate refcount block %llu found!\n",
235	(unsigned long long)rf_blkno);
236	BUG();
237	}
238	}
239
240	rb_link_node(node: &new->rf_node, parent, rb_link: p);
241	rb_insert_color(&new->rf_node, &osb->osb_rf_lock_tree);
242	}
243
244	static void ocfs2_free_refcount_tree(struct ocfs2_refcount_tree *tree)
245	{
246	ocfs2_metadata_cache_exit(ci: &tree->rf_ci);
247	ocfs2_simple_drop_lockres(OCFS2_SB(tree->rf_sb), lockres: &tree->rf_lockres);
248	ocfs2_lock_res_free(res: &tree->rf_lockres);
249	kfree(objp: tree);
250	}
251
252	static inline void
253	ocfs2_erase_refcount_tree_from_list_no_lock(struct ocfs2_super *osb,
254	struct ocfs2_refcount_tree *tree)
255	{
256	rb_erase(&tree->rf_node, &osb->osb_rf_lock_tree);
257	if (osb->osb_ref_tree_lru && osb->osb_ref_tree_lru == tree)
258	osb->osb_ref_tree_lru = NULL;
259	}
260
261	static void ocfs2_erase_refcount_tree_from_list(struct ocfs2_super *osb,
262	struct ocfs2_refcount_tree *tree)
263	{
264	spin_lock(lock: &osb->osb_lock);
265	ocfs2_erase_refcount_tree_from_list_no_lock(osb, tree);
266	spin_unlock(lock: &osb->osb_lock);
267	}
268
269	static void ocfs2_kref_remove_refcount_tree(struct kref *kref)
270	{
271	struct ocfs2_refcount_tree *tree =
272	container_of(kref, struct ocfs2_refcount_tree, rf_getcnt);
273
274	ocfs2_free_refcount_tree(tree);
275	}
276
277	static inline void
278	ocfs2_refcount_tree_get(struct ocfs2_refcount_tree *tree)
279	{
280	kref_get(kref: &tree->rf_getcnt);
281	}
282
283	static inline void
284	ocfs2_refcount_tree_put(struct ocfs2_refcount_tree *tree)
285	{
286	kref_put(kref: &tree->rf_getcnt, release: ocfs2_kref_remove_refcount_tree);
287	}
288
289	static inline void ocfs2_init_refcount_tree_ci(struct ocfs2_refcount_tree *new,
290	struct super_block *sb)
291	{
292	ocfs2_metadata_cache_init(ci: &new->rf_ci, ops: &ocfs2_refcount_caching_ops);
293	mutex_init(&new->rf_io_mutex);
294	new->rf_sb = sb;
295	spin_lock_init(&new->rf_lock);
296	}
297
298	static inline void ocfs2_init_refcount_tree_lock(struct ocfs2_super *osb,
299	struct ocfs2_refcount_tree *new,
300	u64 rf_blkno, u32 generation)
301	{
302	init_rwsem(&new->rf_sem);
303	ocfs2_refcount_lock_res_init(lockres: &new->rf_lockres, osb,
304	ref_blkno: rf_blkno, generation);
305	}
306
307	static struct ocfs2_refcount_tree*
308	ocfs2_allocate_refcount_tree(struct ocfs2_super *osb, u64 rf_blkno)
309	{
310	struct ocfs2_refcount_tree *new;
311
312	new = kzalloc(size: sizeof(struct ocfs2_refcount_tree), GFP_NOFS);
313	if (!new)
314	return NULL;
315
316	new->rf_blkno = rf_blkno;
317	kref_init(kref: &new->rf_getcnt);
318	ocfs2_init_refcount_tree_ci(new, sb: osb->sb);
319
320	return new;
321	}
322
323	static int ocfs2_get_refcount_tree(struct ocfs2_super *osb, u64 rf_blkno,
324	struct ocfs2_refcount_tree **ret_tree)
325	{
326	int ret = 0;
327	struct ocfs2_refcount_tree *tree, *new = NULL;
328	struct buffer_head *ref_root_bh = NULL;
329	struct ocfs2_refcount_block *ref_rb;
330
331	spin_lock(lock: &osb->osb_lock);
332	if (osb->osb_ref_tree_lru &&
333	osb->osb_ref_tree_lru->rf_blkno == rf_blkno)
334	tree = osb->osb_ref_tree_lru;
335	else
336	tree = ocfs2_find_refcount_tree(osb, blkno: rf_blkno);
337	if (tree)
338	goto out;
339
340	spin_unlock(lock: &osb->osb_lock);
341
342	new = ocfs2_allocate_refcount_tree(osb, rf_blkno);
343	if (!new) {
344	ret = -ENOMEM;
345	mlog_errno(ret);
346	return ret;
347	}
348	/*
349	* We need the generation to create the refcount tree lock and since
350	* it isn't changed during the tree modification, we are safe here to
351	* read without protection.
352	* We also have to purge the cache after we create the lock since the
353	* refcount block may have the stale data. It can only be trusted when
354	* we hold the refcount lock.
355	*/
356	ret = ocfs2_read_refcount_block(ci: &new->rf_ci, rb_blkno: rf_blkno, bh: &ref_root_bh);
357	if (ret) {
358	mlog_errno(ret);
359	ocfs2_metadata_cache_exit(ci: &new->rf_ci);
360	kfree(objp: new);
361	return ret;
362	}
363
364	ref_rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
365	new->rf_generation = le32_to_cpu(ref_rb->rf_generation);
366	ocfs2_init_refcount_tree_lock(osb, new, rf_blkno,
367	generation: new->rf_generation);
368	ocfs2_metadata_cache_purge(ci: &new->rf_ci);
369
370	spin_lock(lock: &osb->osb_lock);
371	tree = ocfs2_find_refcount_tree(osb, blkno: rf_blkno);
372	if (tree)
373	goto out;
374
375	ocfs2_insert_refcount_tree(osb, new);
376
377	tree = new;
378	new = NULL;
379
380	out:
381	*ret_tree = tree;
382
383	osb->osb_ref_tree_lru = tree;
384
385	spin_unlock(lock: &osb->osb_lock);
386
387	if (new)
388	ocfs2_free_refcount_tree(tree: new);
389
390	brelse(bh: ref_root_bh);
391	return ret;
392	}
393
394	static int ocfs2_get_refcount_block(struct inode *inode, u64 *ref_blkno)
395	{
396	int ret;
397	struct buffer_head *di_bh = NULL;
398	struct ocfs2_dinode *di;
399
400	ret = ocfs2_read_inode_block(inode, bh: &di_bh);
401	if (ret) {
402	mlog_errno(ret);
403	goto out;
404	}
405
406	BUG_ON(!ocfs2_is_refcount_inode(inode));
407
408	di = (struct ocfs2_dinode *)di_bh->b_data;
409	*ref_blkno = le64_to_cpu(di->i_refcount_loc);
410	brelse(bh: di_bh);
411	out:
412	return ret;
413	}
414
415	static int __ocfs2_lock_refcount_tree(struct ocfs2_super *osb,
416	struct ocfs2_refcount_tree *tree, int rw)
417	{
418	int ret;
419
420	ret = ocfs2_refcount_lock(ref_tree: tree, ex: rw);
421	if (ret) {
422	mlog_errno(ret);
423	goto out;
424	}
425
426	if (rw)
427	down_write(sem: &tree->rf_sem);
428	else
429	down_read(sem: &tree->rf_sem);
430
431	out:
432	return ret;
433	}
434
435	/*
436	* Lock the refcount tree pointed by ref_blkno and return the tree.
437	* In most case, we lock the tree and read the refcount block.
438	* So read it here if the caller really needs it.
439	*
440	* If the tree has been re-created by other node, it will free the
441	* old one and re-create it.
442	*/
443	int ocfs2_lock_refcount_tree(struct ocfs2_super *osb,
444	u64 ref_blkno, int rw,
445	struct ocfs2_refcount_tree **ret_tree,
446	struct buffer_head **ref_bh)
447	{
448	int ret, delete_tree = 0;
449	struct ocfs2_refcount_tree *tree = NULL;
450	struct buffer_head *ref_root_bh = NULL;
451	struct ocfs2_refcount_block *rb;
452
453	again:
454	ret = ocfs2_get_refcount_tree(osb, rf_blkno: ref_blkno, ret_tree: &tree);
455	if (ret) {
456	mlog_errno(ret);
457	return ret;
458	}
459
460	ocfs2_refcount_tree_get(tree);
461
462	ret = __ocfs2_lock_refcount_tree(osb, tree, rw);
463	if (ret) {
464	mlog_errno(ret);
465	ocfs2_refcount_tree_put(tree);
466	goto out;
467	}
468
469	ret = ocfs2_read_refcount_block(ci: &tree->rf_ci, rb_blkno: tree->rf_blkno,
470	bh: &ref_root_bh);
471	if (ret) {
472	mlog_errno(ret);
473	ocfs2_unlock_refcount_tree(osb, tree, rw);
474	goto out;
475	}
476
477	rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
478	/*
479	* If the refcount block has been freed and re-created, we may need
480	* to recreate the refcount tree also.
481	*
482	* Here we just remove the tree from the rb-tree, and the last
483	* kref holder will unlock and delete this refcount_tree.
484	* Then we goto "again" and ocfs2_get_refcount_tree will create
485	* the new refcount tree for us.
486	*/
487	if (tree->rf_generation != le32_to_cpu(rb->rf_generation)) {
488	if (!tree->rf_removed) {
489	ocfs2_erase_refcount_tree_from_list(osb, tree);
490	tree->rf_removed = 1;
491	delete_tree = 1;
492	}
493
494	ocfs2_unlock_refcount_tree(osb, tree, rw);
495	/*
496	* We get an extra reference when we create the refcount
497	* tree, so another put will destroy it.
498	*/
499	if (delete_tree)
500	ocfs2_refcount_tree_put(tree);
501	brelse(bh: ref_root_bh);
502	ref_root_bh = NULL;
503	goto again;
504	}
505
506	*ret_tree = tree;
507	if (ref_bh) {
508	*ref_bh = ref_root_bh;
509	ref_root_bh = NULL;
510	}
511	out:
512	brelse(bh: ref_root_bh);
513	return ret;
514	}
515
516	void ocfs2_unlock_refcount_tree(struct ocfs2_super *osb,
517	struct ocfs2_refcount_tree *tree, int rw)
518	{
519	if (rw)
520	up_write(sem: &tree->rf_sem);
521	else
522	up_read(sem: &tree->rf_sem);
523
524	ocfs2_refcount_unlock(ref_tree: tree, ex: rw);
525	ocfs2_refcount_tree_put(tree);
526	}
527
528	void ocfs2_purge_refcount_trees(struct ocfs2_super *osb)
529	{
530	struct rb_node *node;
531	struct ocfs2_refcount_tree *tree;
532	struct rb_root *root = &osb->osb_rf_lock_tree;
533
534	while ((node = rb_last(root)) != NULL) {
535	tree = rb_entry(node, struct ocfs2_refcount_tree, rf_node);
536
537	trace_ocfs2_purge_refcount_trees(
538	num: (unsigned long long) tree->rf_blkno);
539
540	rb_erase(&tree->rf_node, root);
541	ocfs2_free_refcount_tree(tree);
542	}
543	}
544
545	/*
546	* Create a refcount tree for an inode.
547	* We take for granted that the inode is already locked.
548	*/
549	static int ocfs2_create_refcount_tree(struct inode *inode,
550	struct buffer_head *di_bh)
551	{
552	int ret;
553	handle_t *handle = NULL;
554	struct ocfs2_alloc_context *meta_ac = NULL;
555	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
556	struct ocfs2_inode_info *oi = OCFS2_I(inode);
557	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
558	struct buffer_head *new_bh = NULL;
559	struct ocfs2_refcount_block *rb;
560	struct ocfs2_refcount_tree *new_tree = NULL, *tree = NULL;
561	u16 suballoc_bit_start;
562	u32 num_got;
563	u64 suballoc_loc, first_blkno;
564
565	BUG_ON(ocfs2_is_refcount_inode(inode));
566
567	trace_ocfs2_create_refcount_tree(
568	num: (unsigned long long)oi->ip_blkno);
569
570	ret = ocfs2_reserve_new_metadata_blocks(osb, blocks: 1, ac: &meta_ac);
571	if (ret) {
572	mlog_errno(ret);
573	goto out;
574	}
575
576	handle = ocfs2_start_trans(osb, OCFS2_REFCOUNT_TREE_CREATE_CREDITS);
577	if (IS_ERR(ptr: handle)) {
578	ret = PTR_ERR(ptr: handle);
579	mlog_errno(ret);
580	goto out;
581	}
582
583	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode), bh: di_bh,
584	OCFS2_JOURNAL_ACCESS_WRITE);
585	if (ret) {
586	mlog_errno(ret);
587	goto out_commit;
588	}
589
590	ret = ocfs2_claim_metadata(handle, ac: meta_ac, bits_wanted: 1, suballoc_loc: &suballoc_loc,
591	suballoc_bit_start: &suballoc_bit_start, num_bits: &num_got,
592	blkno_start: &first_blkno);
593	if (ret) {
594	mlog_errno(ret);
595	goto out_commit;
596	}
597
598	new_tree = ocfs2_allocate_refcount_tree(osb, rf_blkno: first_blkno);
599	if (!new_tree) {
600	ret = -ENOMEM;
601	mlog_errno(ret);
602	goto out_commit;
603	}
604
605	new_bh = sb_getblk(sb: inode->i_sb, block: first_blkno);
606	if (!new_bh) {
607	ret = -ENOMEM;
608	mlog_errno(ret);
609	goto out_commit;
610	}
611	ocfs2_set_new_buffer_uptodate(ci: &new_tree->rf_ci, bh: new_bh);
612
613	ret = ocfs2_journal_access_rb(handle, ci: &new_tree->rf_ci, bh: new_bh,
614	OCFS2_JOURNAL_ACCESS_CREATE);
615	if (ret) {
616	mlog_errno(ret);
617	goto out_commit;
618	}
619
620	/* Initialize ocfs2_refcount_block. */
621	rb = (struct ocfs2_refcount_block *)new_bh->b_data;
622	memset(rb, 0, inode->i_sb->s_blocksize);
623	strcpy(p: (void *)rb, OCFS2_REFCOUNT_BLOCK_SIGNATURE);
624	rb->rf_suballoc_slot = cpu_to_le16(meta_ac->ac_alloc_slot);
625	rb->rf_suballoc_loc = cpu_to_le64(suballoc_loc);
626	rb->rf_suballoc_bit = cpu_to_le16(suballoc_bit_start);
627	rb->rf_fs_generation = cpu_to_le32(osb->fs_generation);
628	rb->rf_blkno = cpu_to_le64(first_blkno);
629	rb->rf_count = cpu_to_le32(1);
630	rb->rf_records.rl_count =
631	cpu_to_le16(ocfs2_refcount_recs_per_rb(osb->sb));
632	spin_lock(lock: &osb->osb_lock);
633	rb->rf_generation = osb->s_next_generation++;
634	spin_unlock(lock: &osb->osb_lock);
635
636	ocfs2_journal_dirty(handle, bh: new_bh);
637
638	spin_lock(lock: &oi->ip_lock);
639	oi->ip_dyn_features |= OCFS2_HAS_REFCOUNT_FL;
640	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
641	di->i_refcount_loc = cpu_to_le64(first_blkno);
642	spin_unlock(lock: &oi->ip_lock);
643
644	trace_ocfs2_create_refcount_tree_blkno(num: (unsigned long long)first_blkno);
645
646	ocfs2_journal_dirty(handle, bh: di_bh);
647
648	/*
649	* We have to init the tree lock here since it will use
650	* the generation number to create it.
651	*/
652	new_tree->rf_generation = le32_to_cpu(rb->rf_generation);
653	ocfs2_init_refcount_tree_lock(osb, new: new_tree, rf_blkno: first_blkno,
654	generation: new_tree->rf_generation);
655
656	spin_lock(lock: &osb->osb_lock);
657	tree = ocfs2_find_refcount_tree(osb, blkno: first_blkno);
658
659	/*
660	* We've just created a new refcount tree in this block. If
661	* we found a refcount tree on the ocfs2_super, it must be
662	* one we just deleted. We free the old tree before
663	* inserting the new tree.
664	*/
665	BUG_ON(tree && tree->rf_generation == new_tree->rf_generation);
666	if (tree)
667	ocfs2_erase_refcount_tree_from_list_no_lock(osb, tree);
668	ocfs2_insert_refcount_tree(osb, new: new_tree);
669	spin_unlock(lock: &osb->osb_lock);
670	new_tree = NULL;
671	if (tree)
672	ocfs2_refcount_tree_put(tree);
673
674	out_commit:
675	ocfs2_commit_trans(osb, handle);
676
677	out:
678	if (new_tree) {
679	ocfs2_metadata_cache_exit(ci: &new_tree->rf_ci);
680	kfree(objp: new_tree);
681	}
682
683	brelse(bh: new_bh);
684	if (meta_ac)
685	ocfs2_free_alloc_context(ac: meta_ac);
686
687	return ret;
688	}
689
690	static int ocfs2_set_refcount_tree(struct inode *inode,
691	struct buffer_head *di_bh,
692	u64 refcount_loc)
693	{
694	int ret;
695	handle_t *handle = NULL;
696	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
697	struct ocfs2_inode_info *oi = OCFS2_I(inode);
698	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
699	struct buffer_head *ref_root_bh = NULL;
700	struct ocfs2_refcount_block *rb;
701	struct ocfs2_refcount_tree *ref_tree;
702
703	BUG_ON(ocfs2_is_refcount_inode(inode));
704
705	ret = ocfs2_lock_refcount_tree(osb, ref_blkno: refcount_loc, rw: 1,
706	ret_tree: &ref_tree, ref_bh: &ref_root_bh);
707	if (ret) {
708	mlog_errno(ret);
709	return ret;
710	}
711
712	handle = ocfs2_start_trans(osb, OCFS2_REFCOUNT_TREE_SET_CREDITS);
713	if (IS_ERR(ptr: handle)) {
714	ret = PTR_ERR(ptr: handle);
715	mlog_errno(ret);
716	goto out;
717	}
718
719	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode), bh: di_bh,
720	OCFS2_JOURNAL_ACCESS_WRITE);
721	if (ret) {
722	mlog_errno(ret);
723	goto out_commit;
724	}
725
726	ret = ocfs2_journal_access_rb(handle, ci: &ref_tree->rf_ci, bh: ref_root_bh,
727	OCFS2_JOURNAL_ACCESS_WRITE);
728	if (ret) {
729	mlog_errno(ret);
730	goto out_commit;
731	}
732
733	rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
734	le32_add_cpu(var: &rb->rf_count, val: 1);
735
736	ocfs2_journal_dirty(handle, bh: ref_root_bh);
737
738	spin_lock(lock: &oi->ip_lock);
739	oi->ip_dyn_features |= OCFS2_HAS_REFCOUNT_FL;
740	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
741	di->i_refcount_loc = cpu_to_le64(refcount_loc);
742	spin_unlock(lock: &oi->ip_lock);
743	ocfs2_journal_dirty(handle, bh: di_bh);
744
745	out_commit:
746	ocfs2_commit_trans(osb, handle);
747	out:
748	ocfs2_unlock_refcount_tree(osb, tree: ref_tree, rw: 1);
749	brelse(bh: ref_root_bh);
750
751	return ret;
752	}
753
754	int ocfs2_remove_refcount_tree(struct inode *inode, struct buffer_head *di_bh)
755	{
756	int ret, delete_tree = 0;
757	handle_t *handle = NULL;
758	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
759	struct ocfs2_inode_info *oi = OCFS2_I(inode);
760	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
761	struct ocfs2_refcount_block *rb;
762	struct inode *alloc_inode = NULL;
763	struct buffer_head *alloc_bh = NULL;
764	struct buffer_head *blk_bh = NULL;
765	struct ocfs2_refcount_tree *ref_tree;
766	int credits = OCFS2_REFCOUNT_TREE_REMOVE_CREDITS;
767	u64 blk = 0, bg_blkno = 0, ref_blkno = le64_to_cpu(di->i_refcount_loc);
768	u16 bit = 0;
769
770	if (!ocfs2_is_refcount_inode(inode))
771	return 0;
772
773	BUG_ON(!ref_blkno);
774	ret = ocfs2_lock_refcount_tree(osb, ref_blkno, rw: 1, ret_tree: &ref_tree, ref_bh: &blk_bh);
775	if (ret) {
776	mlog_errno(ret);
777	return ret;
778	}
779
780	rb = (struct ocfs2_refcount_block *)blk_bh->b_data;
781
782	/*
783	* If we are the last user, we need to free the block.
784	* So lock the allocator ahead.
785	*/
786	if (le32_to_cpu(rb->rf_count) == 1) {
787	blk = le64_to_cpu(rb->rf_blkno);
788	bit = le16_to_cpu(rb->rf_suballoc_bit);
789	if (rb->rf_suballoc_loc)
790	bg_blkno = le64_to_cpu(rb->rf_suballoc_loc);
791	else
792	bg_blkno = ocfs2_which_suballoc_group(block: blk, bit);
793
794	alloc_inode = ocfs2_get_system_file_inode(osb,
795	type: EXTENT_ALLOC_SYSTEM_INODE,
796	le16_to_cpu(rb->rf_suballoc_slot));
797	if (!alloc_inode) {
798	ret = -ENOMEM;
799	mlog_errno(ret);
800	goto out;
801	}
802	inode_lock(inode: alloc_inode);
803
804	ret = ocfs2_inode_lock(alloc_inode, &alloc_bh, 1);
805	if (ret) {
806	mlog_errno(ret);
807	goto out_mutex;
808	}
809
810	credits += OCFS2_SUBALLOC_FREE;
811	}
812
813	handle = ocfs2_start_trans(osb, max_buffs: credits);
814	if (IS_ERR(ptr: handle)) {
815	ret = PTR_ERR(ptr: handle);
816	mlog_errno(ret);
817	goto out_unlock;
818	}
819
820	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode), bh: di_bh,
821	OCFS2_JOURNAL_ACCESS_WRITE);
822	if (ret) {
823	mlog_errno(ret);
824	goto out_commit;
825	}
826
827	ret = ocfs2_journal_access_rb(handle, ci: &ref_tree->rf_ci, bh: blk_bh,
828	OCFS2_JOURNAL_ACCESS_WRITE);
829	if (ret) {
830	mlog_errno(ret);
831	goto out_commit;
832	}
833
834	spin_lock(lock: &oi->ip_lock);
835	oi->ip_dyn_features &= ~OCFS2_HAS_REFCOUNT_FL;
836	di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
837	di->i_refcount_loc = 0;
838	spin_unlock(lock: &oi->ip_lock);
839	ocfs2_journal_dirty(handle, bh: di_bh);
840
841	le32_add_cpu(var: &rb->rf_count , val: -1);
842	ocfs2_journal_dirty(handle, bh: blk_bh);
843
844	if (!rb->rf_count) {
845	delete_tree = 1;
846	ocfs2_erase_refcount_tree_from_list(osb, tree: ref_tree);
847	ret = ocfs2_free_suballoc_bits(handle, alloc_inode,
848	alloc_bh, start_bit: bit, bg_blkno, count: 1);
849	if (ret)
850	mlog_errno(ret);
851	}
852
853	out_commit:
854	ocfs2_commit_trans(osb, handle);
855	out_unlock:
856	if (alloc_inode) {
857	ocfs2_inode_unlock(inode: alloc_inode, ex: 1);
858	brelse(bh: alloc_bh);
859	}
860	out_mutex:
861	if (alloc_inode) {
862	inode_unlock(inode: alloc_inode);
863	iput(alloc_inode);
864	}
865	out:
866	ocfs2_unlock_refcount_tree(osb, tree: ref_tree, rw: 1);
867	if (delete_tree)
868	ocfs2_refcount_tree_put(tree: ref_tree);
869	brelse(bh: blk_bh);
870
871	return ret;
872	}
873
874	static void ocfs2_find_refcount_rec_in_rl(struct ocfs2_caching_info *ci,
875	struct buffer_head *ref_leaf_bh,
876	u64 cpos, unsigned int len,
877	struct ocfs2_refcount_rec *ret_rec,
878	int *index)
879	{
880	int i = 0;
881	struct ocfs2_refcount_block *rb =
882	(struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
883	struct ocfs2_refcount_rec *rec = NULL;
884
885	for (; i < le16_to_cpu(rb->rf_records.rl_used); i++) {
886	rec = &rb->rf_records.rl_recs[i];
887
888	if (le64_to_cpu(rec->r_cpos) +
889	le32_to_cpu(rec->r_clusters) <= cpos)
890	continue;
891	else if (le64_to_cpu(rec->r_cpos) > cpos)
892	break;
893
894	/* ok, cpos fail in this rec. Just return. */
895	if (ret_rec)
896	*ret_rec = *rec;
897	goto out;
898	}
899
900	if (ret_rec) {
901	/* We meet with a hole here, so fake the rec. */
902	ret_rec->r_cpos = cpu_to_le64(cpos);
903	ret_rec->r_refcount = 0;
904	if (i < le16_to_cpu(rb->rf_records.rl_used) &&
905	le64_to_cpu(rec->r_cpos) < cpos + len)
906	ret_rec->r_clusters =
907	cpu_to_le32(le64_to_cpu(rec->r_cpos) - cpos);
908	else
909	ret_rec->r_clusters = cpu_to_le32(len);
910	}
911
912	out:
913	*index = i;
914	}
915
916	/*
917	* Try to remove refcount tree. The mechanism is:
918	* 1) Check whether i_clusters == 0, if no, exit.
919	* 2) check whether we have i_xattr_loc in dinode. if yes, exit.
920	* 3) Check whether we have inline xattr stored outside, if yes, exit.
921	* 4) Remove the tree.
922	*/
923	int ocfs2_try_remove_refcount_tree(struct inode *inode,
924	struct buffer_head *di_bh)
925	{
926	int ret;
927	struct ocfs2_inode_info *oi = OCFS2_I(inode);
928	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
929
930	down_write(sem: &oi->ip_xattr_sem);
931	down_write(sem: &oi->ip_alloc_sem);
932
933	if (oi->ip_clusters)
934	goto out;
935
936	if ((oi->ip_dyn_features & OCFS2_HAS_XATTR_FL) && di->i_xattr_loc)
937	goto out;
938
939	if (oi->ip_dyn_features & OCFS2_INLINE_XATTR_FL &&
940	ocfs2_has_inline_xattr_value_outside(inode, di))
941	goto out;
942
943	ret = ocfs2_remove_refcount_tree(inode, di_bh);
944	if (ret)
945	mlog_errno(ret);
946	out:
947	up_write(sem: &oi->ip_alloc_sem);
948	up_write(sem: &oi->ip_xattr_sem);
949	return 0;
950	}
951
952	/*
953	* Find the end range for a leaf refcount block indicated by
954	* el->l_recs[index].e_blkno.
955	*/
956	static int ocfs2_get_refcount_cpos_end(struct ocfs2_caching_info *ci,
957	struct buffer_head *ref_root_bh,
958	struct ocfs2_extent_block *eb,
959	struct ocfs2_extent_list *el,
960	int index, u32 *cpos_end)
961	{
962	int ret, i, subtree_root;
963	u32 cpos;
964	u64 blkno;
965	struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
966	struct ocfs2_path *left_path = NULL, *right_path = NULL;
967	struct ocfs2_extent_tree et;
968	struct ocfs2_extent_list *tmp_el;
969
970	if (index < le16_to_cpu(el->l_next_free_rec) - 1) {
971	/*
972	* We have a extent rec after index, so just use the e_cpos
973	* of the next extent rec.
974	*/
975	*cpos_end = le32_to_cpu(el->l_recs[index+1].e_cpos);
976	return 0;
977	}
978
979	if (!eb || !eb->h_next_leaf_blk) {
980	/*
981	* We are the last extent rec, so any high cpos should
982	* be stored in this leaf refcount block.
983	*/
984	*cpos_end = UINT_MAX;
985	return 0;
986	}
987
988	/*
989	* If the extent block isn't the last one, we have to find
990	* the subtree root between this extent block and the next
991	* leaf extent block and get the corresponding e_cpos from
992	* the subroot. Otherwise we may corrupt the b-tree.
993	*/
994	ocfs2_init_refcount_extent_tree(et: &et, ci, bh: ref_root_bh);
995
996	left_path = ocfs2_new_path_from_et(et: &et);
997	if (!left_path) {
998	ret = -ENOMEM;
999	mlog_errno(ret);
1000	goto out;
1001	}
1002
1003	cpos = le32_to_cpu(eb->h_list.l_recs[index].e_cpos);
1004	ret = ocfs2_find_path(ci, path: left_path, cpos);
1005	if (ret) {
1006	mlog_errno(ret);
1007	goto out;
1008	}
1009
1010	right_path = ocfs2_new_path_from_path(path: left_path);
1011	if (!right_path) {
1012	ret = -ENOMEM;
1013	mlog_errno(ret);
1014	goto out;
1015	}
1016
1017	ret = ocfs2_find_cpos_for_right_leaf(sb, path: left_path, cpos: &cpos);
1018	if (ret) {
1019	mlog_errno(ret);
1020	goto out;
1021	}
1022
1023	ret = ocfs2_find_path(ci, path: right_path, cpos);
1024	if (ret) {
1025	mlog_errno(ret);
1026	goto out;
1027	}
1028
1029	subtree_root = ocfs2_find_subtree_root(et: &et, left: left_path,
1030	right: right_path);
1031
1032	tmp_el = left_path->p_node[subtree_root].el;
1033	blkno = left_path->p_node[subtree_root+1].bh->b_blocknr;
1034	for (i = 0; i < le16_to_cpu(tmp_el->l_next_free_rec); i++) {
1035	if (le64_to_cpu(tmp_el->l_recs[i].e_blkno) == blkno) {
1036	*cpos_end = le32_to_cpu(tmp_el->l_recs[i+1].e_cpos);
1037	break;
1038	}
1039	}
1040
1041	BUG_ON(i == le16_to_cpu(tmp_el->l_next_free_rec));
1042
1043	out:
1044	ocfs2_free_path(path: left_path);
1045	ocfs2_free_path(path: right_path);
1046	return ret;
1047	}
1048
1049	/*
1050	* Given a cpos and len, try to find the refcount record which contains cpos.
1051	* 1. If cpos can be found in one refcount record, return the record.
1052	* 2. If cpos can't be found, return a fake record which start from cpos
1053	* and end at a small value between cpos+len and start of the next record.
1054	* This fake record has r_refcount = 0.
1055	*/
1056	static int ocfs2_get_refcount_rec(struct ocfs2_caching_info *ci,
1057	struct buffer_head *ref_root_bh,
1058	u64 cpos, unsigned int len,
1059	struct ocfs2_refcount_rec *ret_rec,
1060	int *index,
1061	struct buffer_head **ret_bh)
1062	{
1063	int ret = 0, i, found;
1064	u32 low_cpos, cpos_end;
1065	struct ocfs2_extent_list *el;
1066	struct ocfs2_extent_rec *rec = NULL;
1067	struct ocfs2_extent_block *eb = NULL;
1068	struct buffer_head *eb_bh = NULL, *ref_leaf_bh = NULL;
1069	struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
1070	struct ocfs2_refcount_block *rb =
1071	(struct ocfs2_refcount_block *)ref_root_bh->b_data;
1072
1073	if (!(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)) {
1074	ocfs2_find_refcount_rec_in_rl(ci, ref_leaf_bh: ref_root_bh, cpos, len,
1075	ret_rec, index);
1076	*ret_bh = ref_root_bh;
1077	get_bh(bh: ref_root_bh);
1078	return 0;
1079	}
1080
1081	el = &rb->rf_list;
1082	low_cpos = cpos & OCFS2_32BIT_POS_MASK;
1083
1084	if (el->l_tree_depth) {
1085	ret = ocfs2_find_leaf(ci, root_el: el, cpos: low_cpos, leaf_bh: &eb_bh);
1086	if (ret) {
1087	mlog_errno(ret);
1088	goto out;
1089	}
1090
1091	eb = (struct ocfs2_extent_block *) eb_bh->b_data;
1092	el = &eb->h_list;
1093
1094	if (el->l_tree_depth) {
1095	ret = ocfs2_error(sb,
1096	"refcount tree %llu has non zero tree depth in leaf btree tree block %llu\n",
1097	(unsigned long long)ocfs2_metadata_cache_owner(ci),
1098	(unsigned long long)eb_bh->b_blocknr);
1099	goto out;
1100	}
1101	}
1102
1103	found = 0;
1104	for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
1105	rec = &el->l_recs[i];
1106
1107	if (le32_to_cpu(rec->e_cpos) <= low_cpos) {
1108	found = 1;
1109	break;
1110	}
1111	}
1112
1113	if (found) {
1114	ret = ocfs2_get_refcount_cpos_end(ci, ref_root_bh,
1115	eb, el, index: i, cpos_end: &cpos_end);
1116	if (ret) {
1117	mlog_errno(ret);
1118	goto out;
1119	}
1120
1121	if (cpos_end < low_cpos + len)
1122	len = cpos_end - low_cpos;
1123	}
1124
1125	ret = ocfs2_read_refcount_block(ci, le64_to_cpu(rec->e_blkno),
1126	bh: &ref_leaf_bh);
1127	if (ret) {
1128	mlog_errno(ret);
1129	goto out;
1130	}
1131
1132	ocfs2_find_refcount_rec_in_rl(ci, ref_leaf_bh, cpos, len,
1133	ret_rec, index);
1134	*ret_bh = ref_leaf_bh;
1135	out:
1136	brelse(bh: eb_bh);
1137	return ret;
1138	}
1139
1140	enum ocfs2_ref_rec_contig {
1141	REF_CONTIG_NONE = 0,
1142	REF_CONTIG_LEFT,
1143	REF_CONTIG_RIGHT,
1144	REF_CONTIG_LEFTRIGHT,
1145	};
1146
1147	static enum ocfs2_ref_rec_contig
1148	ocfs2_refcount_rec_adjacent(struct ocfs2_refcount_block *rb,
1149	int index)
1150	{
1151	if ((rb->rf_records.rl_recs[index].r_refcount ==
1152	rb->rf_records.rl_recs[index + 1].r_refcount) &&
1153	(le64_to_cpu(rb->rf_records.rl_recs[index].r_cpos) +
1154	le32_to_cpu(rb->rf_records.rl_recs[index].r_clusters) ==
1155	le64_to_cpu(rb->rf_records.rl_recs[index + 1].r_cpos)))
1156	return REF_CONTIG_RIGHT;
1157
1158	return REF_CONTIG_NONE;
1159	}
1160
1161	static enum ocfs2_ref_rec_contig
1162	ocfs2_refcount_rec_contig(struct ocfs2_refcount_block *rb,
1163	int index)
1164	{
1165	enum ocfs2_ref_rec_contig ret = REF_CONTIG_NONE;
1166
1167	if (index < le16_to_cpu(rb->rf_records.rl_used) - 1)
1168	ret = ocfs2_refcount_rec_adjacent(rb, index);
1169
1170	if (index > 0) {
1171	enum ocfs2_ref_rec_contig tmp;
1172
1173	tmp = ocfs2_refcount_rec_adjacent(rb, index: index - 1);
1174
1175	if (tmp == REF_CONTIG_RIGHT) {
1176	if (ret == REF_CONTIG_RIGHT)
1177	ret = REF_CONTIG_LEFTRIGHT;
1178	else
1179	ret = REF_CONTIG_LEFT;
1180	}
1181	}
1182
1183	return ret;
1184	}
1185
1186	static void ocfs2_rotate_refcount_rec_left(struct ocfs2_refcount_block *rb,
1187	int index)
1188	{
1189	BUG_ON(rb->rf_records.rl_recs[index].r_refcount !=
1190	rb->rf_records.rl_recs[index+1].r_refcount);
1191
1192	le32_add_cpu(var: &rb->rf_records.rl_recs[index].r_clusters,
1193	le32_to_cpu(rb->rf_records.rl_recs[index+1].r_clusters));
1194
1195	if (index < le16_to_cpu(rb->rf_records.rl_used) - 2)
1196	memmove(&rb->rf_records.rl_recs[index + 1],
1197	&rb->rf_records.rl_recs[index + 2],
1198	sizeof(struct ocfs2_refcount_rec) *
1199	(le16_to_cpu(rb->rf_records.rl_used) - index - 2));
1200
1201	memset(&rb->rf_records.rl_recs[le16_to_cpu(rb->rf_records.rl_used) - 1],
1202	0, sizeof(struct ocfs2_refcount_rec));
1203	le16_add_cpu(var: &rb->rf_records.rl_used, val: -1);
1204	}
1205
1206	/*
1207	* Merge the refcount rec if we are contiguous with the adjacent recs.
1208	*/
1209	static void ocfs2_refcount_rec_merge(struct ocfs2_refcount_block *rb,
1210	int index)
1211	{
1212	enum ocfs2_ref_rec_contig contig =
1213	ocfs2_refcount_rec_contig(rb, index);
1214
1215	if (contig == REF_CONTIG_NONE)
1216	return;
1217
1218	if (contig == REF_CONTIG_LEFT || contig == REF_CONTIG_LEFTRIGHT) {
1219	BUG_ON(index == 0);
1220	index--;
1221	}
1222
1223	ocfs2_rotate_refcount_rec_left(rb, index);
1224
1225	if (contig == REF_CONTIG_LEFTRIGHT)
1226	ocfs2_rotate_refcount_rec_left(rb, index);
1227	}
1228
1229	/*
1230	* Change the refcount indexed by "index" in ref_bh.
1231	* If refcount reaches 0, remove it.
1232	*/
1233	static int ocfs2_change_refcount_rec(handle_t *handle,
1234	struct ocfs2_caching_info *ci,
1235	struct buffer_head *ref_leaf_bh,
1236	int index, int merge, int change)
1237	{
1238	int ret;
1239	struct ocfs2_refcount_block *rb =
1240	(struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1241	struct ocfs2_refcount_list *rl = &rb->rf_records;
1242	struct ocfs2_refcount_rec *rec = &rl->rl_recs[index];
1243
1244	ret = ocfs2_journal_access_rb(handle, ci, bh: ref_leaf_bh,
1245	OCFS2_JOURNAL_ACCESS_WRITE);
1246	if (ret) {
1247	mlog_errno(ret);
1248	goto out;
1249	}
1250
1251	trace_ocfs2_change_refcount_rec(
1252	ull: (unsigned long long)ocfs2_metadata_cache_owner(ci),
1253	value1: index, le32_to_cpu(rec->r_refcount), value3: change);
1254	le32_add_cpu(var: &rec->r_refcount, val: change);
1255
1256	if (!rec->r_refcount) {
1257	if (index != le16_to_cpu(rl->rl_used) - 1) {
1258	memmove(rec, rec + 1,
1259	(le16_to_cpu(rl->rl_used) - index - 1) *
1260	sizeof(struct ocfs2_refcount_rec));
1261	memset(&rl->rl_recs[le16_to_cpu(rl->rl_used) - 1],
1262	0, sizeof(struct ocfs2_refcount_rec));
1263	}
1264
1265	le16_add_cpu(var: &rl->rl_used, val: -1);
1266	} else if (merge)
1267	ocfs2_refcount_rec_merge(rb, index);
1268
1269	ocfs2_journal_dirty(handle, bh: ref_leaf_bh);
1270	out:
1271	return ret;
1272	}
1273
1274	static int ocfs2_expand_inline_ref_root(handle_t *handle,
1275	struct ocfs2_caching_info *ci,
1276	struct buffer_head *ref_root_bh,
1277	struct buffer_head **ref_leaf_bh,
1278	struct ocfs2_alloc_context *meta_ac)
1279	{
1280	int ret;
1281	u16 suballoc_bit_start;
1282	u32 num_got;
1283	u64 suballoc_loc, blkno;
1284	struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
1285	struct buffer_head *new_bh = NULL;
1286	struct ocfs2_refcount_block *new_rb;
1287	struct ocfs2_refcount_block *root_rb =
1288	(struct ocfs2_refcount_block *)ref_root_bh->b_data;
1289
1290	ret = ocfs2_journal_access_rb(handle, ci, bh: ref_root_bh,
1291	OCFS2_JOURNAL_ACCESS_WRITE);
1292	if (ret) {
1293	mlog_errno(ret);
1294	goto out;
1295	}
1296
1297	ret = ocfs2_claim_metadata(handle, ac: meta_ac, bits_wanted: 1, suballoc_loc: &suballoc_loc,
1298	suballoc_bit_start: &suballoc_bit_start, num_bits: &num_got,
1299	blkno_start: &blkno);
1300	if (ret) {
1301	mlog_errno(ret);
1302	goto out;
1303	}
1304
1305	new_bh = sb_getblk(sb, block: blkno);
1306	if (new_bh == NULL) {
1307	ret = -ENOMEM;
1308	mlog_errno(ret);
1309	goto out;
1310	}
1311	ocfs2_set_new_buffer_uptodate(ci, bh: new_bh);
1312
1313	ret = ocfs2_journal_access_rb(handle, ci, bh: new_bh,
1314	OCFS2_JOURNAL_ACCESS_CREATE);
1315	if (ret) {
1316	mlog_errno(ret);
1317	goto out;
1318	}
1319
1320	/*
1321	* Initialize ocfs2_refcount_block.
1322	* It should contain the same information as the old root.
1323	* so just memcpy it and change the corresponding field.
1324	*/
1325	memcpy(new_bh->b_data, ref_root_bh->b_data, sb->s_blocksize);
1326
1327	new_rb = (struct ocfs2_refcount_block *)new_bh->b_data;
1328	new_rb->rf_suballoc_slot = cpu_to_le16(meta_ac->ac_alloc_slot);
1329	new_rb->rf_suballoc_loc = cpu_to_le64(suballoc_loc);
1330	new_rb->rf_suballoc_bit = cpu_to_le16(suballoc_bit_start);
1331	new_rb->rf_blkno = cpu_to_le64(blkno);
1332	new_rb->rf_cpos = cpu_to_le32(0);
1333	new_rb->rf_parent = cpu_to_le64(ref_root_bh->b_blocknr);
1334	new_rb->rf_flags = cpu_to_le32(OCFS2_REFCOUNT_LEAF_FL);
1335	ocfs2_journal_dirty(handle, bh: new_bh);
1336
1337	/* Now change the root. */
1338	memset(&root_rb->rf_list, 0, sb->s_blocksize -
1339	offsetof(struct ocfs2_refcount_block, rf_list));
1340	root_rb->rf_list.l_count = cpu_to_le16(ocfs2_extent_recs_per_rb(sb));
1341	root_rb->rf_clusters = cpu_to_le32(1);
1342	root_rb->rf_list.l_next_free_rec = cpu_to_le16(1);
1343	root_rb->rf_list.l_recs[0].e_blkno = cpu_to_le64(blkno);
1344	root_rb->rf_list.l_recs[0].e_leaf_clusters = cpu_to_le16(1);
1345	root_rb->rf_flags = cpu_to_le32(OCFS2_REFCOUNT_TREE_FL);
1346
1347	ocfs2_journal_dirty(handle, bh: ref_root_bh);
1348
1349	trace_ocfs2_expand_inline_ref_root(val1: (unsigned long long)blkno,
1350	le16_to_cpu(new_rb->rf_records.rl_used));
1351
1352	*ref_leaf_bh = new_bh;
1353	new_bh = NULL;
1354	out:
1355	brelse(bh: new_bh);
1356	return ret;
1357	}
1358
1359	static int ocfs2_refcount_rec_no_intersect(struct ocfs2_refcount_rec *prev,
1360	struct ocfs2_refcount_rec *next)
1361	{
1362	if (ocfs2_get_ref_rec_low_cpos(rec: prev) + le32_to_cpu(prev->r_clusters) <=
1363	ocfs2_get_ref_rec_low_cpos(rec: next))
1364	return 1;
1365
1366	return 0;
1367	}
1368
1369	static int cmp_refcount_rec_by_low_cpos(const void *a, const void *b)
1370	{
1371	const struct ocfs2_refcount_rec *l = a, *r = b;
1372	u32 l_cpos = ocfs2_get_ref_rec_low_cpos(rec: l);
1373	u32 r_cpos = ocfs2_get_ref_rec_low_cpos(rec: r);
1374
1375	if (l_cpos > r_cpos)
1376	return 1;
1377	if (l_cpos < r_cpos)
1378	return -1;
1379	return 0;
1380	}
1381
1382	static int cmp_refcount_rec_by_cpos(const void *a, const void *b)
1383	{
1384	const struct ocfs2_refcount_rec *l = a, *r = b;
1385	u64 l_cpos = le64_to_cpu(l->r_cpos);
1386	u64 r_cpos = le64_to_cpu(r->r_cpos);
1387
1388	if (l_cpos > r_cpos)
1389	return 1;
1390	if (l_cpos < r_cpos)
1391	return -1;
1392	return 0;
1393	}
1394
1395	static void swap_refcount_rec(void *a, void *b, int size)
1396	{
1397	struct ocfs2_refcount_rec *l = a, *r = b;
1398
1399	swap(*l, *r);
1400	}
1401
1402	/*
1403	* The refcount cpos are ordered by their 64bit cpos,
1404	* But we will use the low 32 bit to be the e_cpos in the b-tree.
1405	* So we need to make sure that this pos isn't intersected with others.
1406	*
1407	* Note: The refcount block is already sorted by their low 32 bit cpos,
1408	* So just try the middle pos first, and we will exit when we find
1409	* the good position.
1410	*/
1411	static int ocfs2_find_refcount_split_pos(struct ocfs2_refcount_list *rl,
1412	u32 *split_pos, int *split_index)
1413	{
1414	int num_used = le16_to_cpu(rl->rl_used);
1415	int delta, middle = num_used / 2;
1416
1417	for (delta = 0; delta < middle; delta++) {
1418	/* Let's check delta earlier than middle */
1419	if (ocfs2_refcount_rec_no_intersect(
1420	prev: &rl->rl_recs[middle - delta - 1],
1421	next: &rl->rl_recs[middle - delta])) {
1422	*split_index = middle - delta;
1423	break;
1424	}
1425
1426	/* For even counts, don't walk off the end */
1427	if ((middle + delta + 1) == num_used)
1428	continue;
1429
1430	/* Now try delta past middle */
1431	if (ocfs2_refcount_rec_no_intersect(
1432	prev: &rl->rl_recs[middle + delta],
1433	next: &rl->rl_recs[middle + delta + 1])) {
1434	*split_index = middle + delta + 1;
1435	break;
1436	}
1437	}
1438
1439	if (delta >= middle)
1440	return -ENOSPC;
1441
1442	*split_pos = ocfs2_get_ref_rec_low_cpos(rec: &rl->rl_recs[*split_index]);
1443	return 0;
1444	}
1445
1446	static int ocfs2_divide_leaf_refcount_block(struct buffer_head *ref_leaf_bh,
1447	struct buffer_head *new_bh,
1448	u32 *split_cpos)
1449	{
1450	int split_index = 0, num_moved, ret;
1451	u32 cpos = 0;
1452	struct ocfs2_refcount_block *rb =
1453	(struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1454	struct ocfs2_refcount_list *rl = &rb->rf_records;
1455	struct ocfs2_refcount_block *new_rb =
1456	(struct ocfs2_refcount_block *)new_bh->b_data;
1457	struct ocfs2_refcount_list *new_rl = &new_rb->rf_records;
1458
1459	trace_ocfs2_divide_leaf_refcount_block(
1460	val1: (unsigned long long)ref_leaf_bh->b_blocknr,
1461	le16_to_cpu(rl->rl_count), le16_to_cpu(rl->rl_used));
1462
1463	/*
1464	* XXX: Improvement later.
1465	* If we know all the high 32 bit cpos is the same, no need to sort.
1466	*
1467	* In order to make the whole process safe, we do:
1468	* 1. sort the entries by their low 32 bit cpos first so that we can
1469	* find the split cpos easily.
1470	* 2. call ocfs2_insert_extent to insert the new refcount block.
1471	* 3. move the refcount rec to the new block.
1472	* 4. sort the entries by their 64 bit cpos.
1473	* 5. dirty the new_rb and rb.
1474	*/
1475	sort(base: &rl->rl_recs, le16_to_cpu(rl->rl_used),
1476	size: sizeof(struct ocfs2_refcount_rec),
1477	cmp_func: cmp_refcount_rec_by_low_cpos, swap_func: swap_refcount_rec);
1478
1479	ret = ocfs2_find_refcount_split_pos(rl, split_pos: &cpos, split_index: &split_index);
1480	if (ret) {
1481	mlog_errno(ret);
1482	return ret;
1483	}
1484
1485	new_rb->rf_cpos = cpu_to_le32(cpos);
1486
1487	/* move refcount records starting from split_index to the new block. */
1488	num_moved = le16_to_cpu(rl->rl_used) - split_index;
1489	memcpy(new_rl->rl_recs, &rl->rl_recs[split_index],
1490	num_moved * sizeof(struct ocfs2_refcount_rec));
1491
1492	/*ok, remove the entries we just moved over to the other block. */
1493	memset(&rl->rl_recs[split_index], 0,
1494	num_moved * sizeof(struct ocfs2_refcount_rec));
1495
1496	/* change old and new rl_used accordingly. */
1497	le16_add_cpu(var: &rl->rl_used, val: -num_moved);
1498	new_rl->rl_used = cpu_to_le16(num_moved);
1499
1500	sort(base: &rl->rl_recs, le16_to_cpu(rl->rl_used),
1501	size: sizeof(struct ocfs2_refcount_rec),
1502	cmp_func: cmp_refcount_rec_by_cpos, swap_func: swap_refcount_rec);
1503
1504	sort(base: &new_rl->rl_recs, le16_to_cpu(new_rl->rl_used),
1505	size: sizeof(struct ocfs2_refcount_rec),
1506	cmp_func: cmp_refcount_rec_by_cpos, swap_func: swap_refcount_rec);
1507
1508	*split_cpos = cpos;
1509	return 0;
1510	}
1511
1512	static int ocfs2_new_leaf_refcount_block(handle_t *handle,
1513	struct ocfs2_caching_info *ci,
1514	struct buffer_head *ref_root_bh,
1515	struct buffer_head *ref_leaf_bh,
1516	struct ocfs2_alloc_context *meta_ac)
1517	{
1518	int ret;
1519	u16 suballoc_bit_start;
1520	u32 num_got, new_cpos;
1521	u64 suballoc_loc, blkno;
1522	struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
1523	struct ocfs2_refcount_block *root_rb =
1524	(struct ocfs2_refcount_block *)ref_root_bh->b_data;
1525	struct buffer_head *new_bh = NULL;
1526	struct ocfs2_refcount_block *new_rb;
1527	struct ocfs2_extent_tree ref_et;
1528
1529	BUG_ON(!(le32_to_cpu(root_rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL));
1530
1531	ret = ocfs2_journal_access_rb(handle, ci, bh: ref_root_bh,
1532	OCFS2_JOURNAL_ACCESS_WRITE);
1533	if (ret) {
1534	mlog_errno(ret);
1535	goto out;
1536	}
1537
1538	ret = ocfs2_journal_access_rb(handle, ci, bh: ref_leaf_bh,
1539	OCFS2_JOURNAL_ACCESS_WRITE);
1540	if (ret) {
1541	mlog_errno(ret);
1542	goto out;
1543	}
1544
1545	ret = ocfs2_claim_metadata(handle, ac: meta_ac, bits_wanted: 1, suballoc_loc: &suballoc_loc,
1546	suballoc_bit_start: &suballoc_bit_start, num_bits: &num_got,
1547	blkno_start: &blkno);
1548	if (ret) {
1549	mlog_errno(ret);
1550	goto out;
1551	}
1552
1553	new_bh = sb_getblk(sb, block: blkno);
1554	if (new_bh == NULL) {
1555	ret = -ENOMEM;
1556	mlog_errno(ret);
1557	goto out;
1558	}
1559	ocfs2_set_new_buffer_uptodate(ci, bh: new_bh);
1560
1561	ret = ocfs2_journal_access_rb(handle, ci, bh: new_bh,
1562	OCFS2_JOURNAL_ACCESS_CREATE);
1563	if (ret) {
1564	mlog_errno(ret);
1565	goto out;
1566	}
1567
1568	/* Initialize ocfs2_refcount_block. */
1569	new_rb = (struct ocfs2_refcount_block *)new_bh->b_data;
1570	memset(new_rb, 0, sb->s_blocksize);
1571	strcpy(p: (void *)new_rb, OCFS2_REFCOUNT_BLOCK_SIGNATURE);
1572	new_rb->rf_suballoc_slot = cpu_to_le16(meta_ac->ac_alloc_slot);
1573	new_rb->rf_suballoc_loc = cpu_to_le64(suballoc_loc);
1574	new_rb->rf_suballoc_bit = cpu_to_le16(suballoc_bit_start);
1575	new_rb->rf_fs_generation = cpu_to_le32(OCFS2_SB(sb)->fs_generation);
1576	new_rb->rf_blkno = cpu_to_le64(blkno);
1577	new_rb->rf_parent = cpu_to_le64(ref_root_bh->b_blocknr);
1578	new_rb->rf_flags = cpu_to_le32(OCFS2_REFCOUNT_LEAF_FL);
1579	new_rb->rf_records.rl_count =
1580	cpu_to_le16(ocfs2_refcount_recs_per_rb(sb));
1581	new_rb->rf_generation = root_rb->rf_generation;
1582
1583	ret = ocfs2_divide_leaf_refcount_block(ref_leaf_bh, new_bh, split_cpos: &new_cpos);
1584	if (ret) {
1585	mlog_errno(ret);
1586	goto out;
1587	}
1588
1589	ocfs2_journal_dirty(handle, bh: ref_leaf_bh);
1590	ocfs2_journal_dirty(handle, bh: new_bh);
1591
1592	ocfs2_init_refcount_extent_tree(et: &ref_et, ci, bh: ref_root_bh);
1593
1594	trace_ocfs2_new_leaf_refcount_block(
1595	val1: (unsigned long long)new_bh->b_blocknr, val2: new_cpos);
1596
1597	/* Insert the new leaf block with the specific offset cpos. */
1598	ret = ocfs2_insert_extent(handle, et: &ref_et, cpos: new_cpos, start_blk: new_bh->b_blocknr,
1599	new_clusters: 1, flags: 0, meta_ac);
1600	if (ret)
1601	mlog_errno(ret);
1602
1603	out:
1604	brelse(bh: new_bh);
1605	return ret;
1606	}
1607
1608	static int ocfs2_expand_refcount_tree(handle_t *handle,
1609	struct ocfs2_caching_info *ci,
1610	struct buffer_head *ref_root_bh,
1611	struct buffer_head *ref_leaf_bh,
1612	struct ocfs2_alloc_context *meta_ac)
1613	{
1614	int ret;
1615	struct buffer_head *expand_bh = NULL;
1616
1617	if (ref_root_bh == ref_leaf_bh) {
1618	/*
1619	* the old root bh hasn't been expanded to a b-tree,
1620	* so expand it first.
1621	*/
1622	ret = ocfs2_expand_inline_ref_root(handle, ci, ref_root_bh,
1623	ref_leaf_bh: &expand_bh, meta_ac);
1624	if (ret) {
1625	mlog_errno(ret);
1626	goto out;
1627	}
1628	} else {
1629	expand_bh = ref_leaf_bh;
1630	get_bh(bh: expand_bh);
1631	}
1632
1633
1634	/* Now add a new refcount block into the tree.*/
1635	ret = ocfs2_new_leaf_refcount_block(handle, ci, ref_root_bh,
1636	ref_leaf_bh: expand_bh, meta_ac);
1637	if (ret)
1638	mlog_errno(ret);
1639	out:
1640	brelse(bh: expand_bh);
1641	return ret;
1642	}
1643
1644	/*
1645	* Adjust the extent rec in b-tree representing ref_leaf_bh.
1646	*
1647	* Only called when we have inserted a new refcount rec at index 0
1648	* which means ocfs2_extent_rec.e_cpos may need some change.
1649	*/
1650	static int ocfs2_adjust_refcount_rec(handle_t *handle,
1651	struct ocfs2_caching_info *ci,
1652	struct buffer_head *ref_root_bh,
1653	struct buffer_head *ref_leaf_bh,
1654	struct ocfs2_refcount_rec *rec)
1655	{
1656	int ret = 0, i;
1657	u32 new_cpos, old_cpos;
1658	struct ocfs2_path *path = NULL;
1659	struct ocfs2_extent_tree et;
1660	struct ocfs2_refcount_block *rb =
1661	(struct ocfs2_refcount_block *)ref_root_bh->b_data;
1662	struct ocfs2_extent_list *el;
1663
1664	if (!(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL))
1665	goto out;
1666
1667	rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1668	old_cpos = le32_to_cpu(rb->rf_cpos);
1669	new_cpos = le64_to_cpu(rec->r_cpos) & OCFS2_32BIT_POS_MASK;
1670	if (old_cpos <= new_cpos)
1671	goto out;
1672
1673	ocfs2_init_refcount_extent_tree(et: &et, ci, bh: ref_root_bh);
1674
1675	path = ocfs2_new_path_from_et(et: &et);
1676	if (!path) {
1677	ret = -ENOMEM;
1678	mlog_errno(ret);
1679	goto out;
1680	}
1681
1682	ret = ocfs2_find_path(ci, path, cpos: old_cpos);
1683	if (ret) {
1684	mlog_errno(ret);
1685	goto out;
1686	}
1687
1688	/*
1689	* 2 more credits, one for the leaf refcount block, one for
1690	* the extent block contains the extent rec.
1691	*/
1692	ret = ocfs2_extend_trans(handle, nblocks: 2);
1693	if (ret < 0) {
1694	mlog_errno(ret);
1695	goto out;
1696	}
1697
1698	ret = ocfs2_journal_access_rb(handle, ci, bh: ref_leaf_bh,
1699	OCFS2_JOURNAL_ACCESS_WRITE);
1700	if (ret < 0) {
1701	mlog_errno(ret);
1702	goto out;
1703	}
1704
1705	ret = ocfs2_journal_access_eb(handle, ci, path_leaf_bh(path),
1706	OCFS2_JOURNAL_ACCESS_WRITE);
1707	if (ret < 0) {
1708	mlog_errno(ret);
1709	goto out;
1710	}
1711
1712	/* change the leaf extent block first. */
1713	el = path_leaf_el(path);
1714
1715	for (i = 0; i < le16_to_cpu(el->l_next_free_rec); i++)
1716	if (le32_to_cpu(el->l_recs[i].e_cpos) == old_cpos)
1717	break;
1718
1719	BUG_ON(i == le16_to_cpu(el->l_next_free_rec));
1720
1721	el->l_recs[i].e_cpos = cpu_to_le32(new_cpos);
1722
1723	/* change the r_cpos in the leaf block. */
1724	rb->rf_cpos = cpu_to_le32(new_cpos);
1725
1726	ocfs2_journal_dirty(handle, path_leaf_bh(path));
1727	ocfs2_journal_dirty(handle, bh: ref_leaf_bh);
1728
1729	out:
1730	ocfs2_free_path(path);
1731	return ret;
1732	}
1733
1734	static int ocfs2_insert_refcount_rec(handle_t *handle,
1735	struct ocfs2_caching_info *ci,
1736	struct buffer_head *ref_root_bh,
1737	struct buffer_head *ref_leaf_bh,
1738	struct ocfs2_refcount_rec *rec,
1739	int index, int merge,
1740	struct ocfs2_alloc_context *meta_ac)
1741	{
1742	int ret;
1743	struct ocfs2_refcount_block *rb =
1744	(struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1745	struct ocfs2_refcount_list *rf_list = &rb->rf_records;
1746	struct buffer_head *new_bh = NULL;
1747
1748	BUG_ON(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL);
1749
1750	if (rf_list->rl_used == rf_list->rl_count) {
1751	u64 cpos = le64_to_cpu(rec->r_cpos);
1752	u32 len = le32_to_cpu(rec->r_clusters);
1753
1754	ret = ocfs2_expand_refcount_tree(handle, ci, ref_root_bh,
1755	ref_leaf_bh, meta_ac);
1756	if (ret) {
1757	mlog_errno(ret);
1758	goto out;
1759	}
1760
1761	ret = ocfs2_get_refcount_rec(ci, ref_root_bh,
1762	cpos, len, NULL, index: &index,
1763	ret_bh: &new_bh);
1764	if (ret) {
1765	mlog_errno(ret);
1766	goto out;
1767	}
1768
1769	ref_leaf_bh = new_bh;
1770	rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1771	rf_list = &rb->rf_records;
1772	}
1773
1774	ret = ocfs2_journal_access_rb(handle, ci, bh: ref_leaf_bh,
1775	OCFS2_JOURNAL_ACCESS_WRITE);
1776	if (ret) {
1777	mlog_errno(ret);
1778	goto out;
1779	}
1780
1781	if (index < le16_to_cpu(rf_list->rl_used))
1782	memmove(&rf_list->rl_recs[index + 1],
1783	&rf_list->rl_recs[index],
1784	(le16_to_cpu(rf_list->rl_used) - index) *
1785	sizeof(struct ocfs2_refcount_rec));
1786
1787	trace_ocfs2_insert_refcount_rec(
1788	blkno: (unsigned long long)ref_leaf_bh->b_blocknr, index,
1789	cpos: (unsigned long long)le64_to_cpu(rec->r_cpos),
1790	le32_to_cpu(rec->r_clusters), le32_to_cpu(rec->r_refcount));
1791
1792	rf_list->rl_recs[index] = *rec;
1793
1794	le16_add_cpu(var: &rf_list->rl_used, val: 1);
1795
1796	if (merge)
1797	ocfs2_refcount_rec_merge(rb, index);
1798
1799	ocfs2_journal_dirty(handle, bh: ref_leaf_bh);
1800
1801	if (index == 0) {
1802	ret = ocfs2_adjust_refcount_rec(handle, ci,
1803	ref_root_bh,
1804	ref_leaf_bh, rec);
1805	if (ret)
1806	mlog_errno(ret);
1807	}
1808	out:
1809	brelse(bh: new_bh);
1810	return ret;
1811	}
1812
1813	/*
1814	* Split the refcount_rec indexed by "index" in ref_leaf_bh.
1815	* This is much simple than our b-tree code.
1816	* split_rec is the new refcount rec we want to insert.
1817	* If split_rec->r_refcount > 0, we are changing the refcount(in case we
1818	* increase refcount or decrease a refcount to non-zero).
1819	* If split_rec->r_refcount == 0, we are punching a hole in current refcount
1820	* rec( in case we decrease a refcount to zero).
1821	*/
1822	static int ocfs2_split_refcount_rec(handle_t *handle,
1823	struct ocfs2_caching_info *ci,
1824	struct buffer_head *ref_root_bh,
1825	struct buffer_head *ref_leaf_bh,
1826	struct ocfs2_refcount_rec *split_rec,
1827	int index, int merge,
1828	struct ocfs2_alloc_context *meta_ac,
1829	struct ocfs2_cached_dealloc_ctxt *dealloc)
1830	{
1831	int ret, recs_need;
1832	u32 len;
1833	struct ocfs2_refcount_block *rb =
1834	(struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1835	struct ocfs2_refcount_list *rf_list = &rb->rf_records;
1836	struct ocfs2_refcount_rec *orig_rec = &rf_list->rl_recs[index];
1837	struct ocfs2_refcount_rec *tail_rec = NULL;
1838	struct buffer_head *new_bh = NULL;
1839
1840	BUG_ON(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL);
1841
1842	trace_ocfs2_split_refcount_rec(le64_to_cpu(orig_rec->r_cpos),
1843	le32_to_cpu(orig_rec->r_clusters),
1844	le32_to_cpu(orig_rec->r_refcount),
1845	le64_to_cpu(split_rec->r_cpos),
1846	le32_to_cpu(split_rec->r_clusters),
1847	le32_to_cpu(split_rec->r_refcount));
1848
1849	/*
1850	* If we just need to split the header or tail clusters,
1851	* no more recs are needed, just split is OK.
1852	* Otherwise we at least need one new recs.
1853	*/
1854	if (!split_rec->r_refcount &&
1855	(split_rec->r_cpos == orig_rec->r_cpos ||
1856	le64_to_cpu(split_rec->r_cpos) +
1857	le32_to_cpu(split_rec->r_clusters) ==
1858	le64_to_cpu(orig_rec->r_cpos) + le32_to_cpu(orig_rec->r_clusters)))
1859	recs_need = 0;
1860	else
1861	recs_need = 1;
1862
1863	/*
1864	* We need one more rec if we split in the middle and the new rec have
1865	* some refcount in it.
1866	*/
1867	if (split_rec->r_refcount &&
1868	(split_rec->r_cpos != orig_rec->r_cpos &&
1869	le64_to_cpu(split_rec->r_cpos) +
1870	le32_to_cpu(split_rec->r_clusters) !=
1871	le64_to_cpu(orig_rec->r_cpos) + le32_to_cpu(orig_rec->r_clusters)))
1872	recs_need++;
1873
1874	/* If the leaf block don't have enough record, expand it. */
1875	if (le16_to_cpu(rf_list->rl_used) + recs_need >
1876	le16_to_cpu(rf_list->rl_count)) {
1877	struct ocfs2_refcount_rec tmp_rec;
1878	u64 cpos = le64_to_cpu(orig_rec->r_cpos);
1879	len = le32_to_cpu(orig_rec->r_clusters);
1880	ret = ocfs2_expand_refcount_tree(handle, ci, ref_root_bh,
1881	ref_leaf_bh, meta_ac);
1882	if (ret) {
1883	mlog_errno(ret);
1884	goto out;
1885	}
1886
1887	/*
1888	* We have to re-get it since now cpos may be moved to
1889	* another leaf block.
1890	*/
1891	ret = ocfs2_get_refcount_rec(ci, ref_root_bh,
1892	cpos, len, ret_rec: &tmp_rec, index: &index,
1893	ret_bh: &new_bh);
1894	if (ret) {
1895	mlog_errno(ret);
1896	goto out;
1897	}
1898
1899	ref_leaf_bh = new_bh;
1900	rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
1901	rf_list = &rb->rf_records;
1902	orig_rec = &rf_list->rl_recs[index];
1903	}
1904
1905	ret = ocfs2_journal_access_rb(handle, ci, bh: ref_leaf_bh,
1906	OCFS2_JOURNAL_ACCESS_WRITE);
1907	if (ret) {
1908	mlog_errno(ret);
1909	goto out;
1910	}
1911
1912	/*
1913	* We have calculated out how many new records we need and store
1914	* in recs_need, so spare enough space first by moving the records
1915	* after "index" to the end.
1916	*/
1917	if (index != le16_to_cpu(rf_list->rl_used) - 1)
1918	memmove(&rf_list->rl_recs[index + 1 + recs_need],
1919	&rf_list->rl_recs[index + 1],
1920	(le16_to_cpu(rf_list->rl_used) - index - 1) *
1921	sizeof(struct ocfs2_refcount_rec));
1922
1923	len = (le64_to_cpu(orig_rec->r_cpos) +
1924	le32_to_cpu(orig_rec->r_clusters)) -
1925	(le64_to_cpu(split_rec->r_cpos) +
1926	le32_to_cpu(split_rec->r_clusters));
1927
1928	/*
1929	* If we have "len", the we will split in the tail and move it
1930	* to the end of the space we have just spared.
1931	*/
1932	if (len) {
1933	tail_rec = &rf_list->rl_recs[index + recs_need];
1934
1935	memcpy(tail_rec, orig_rec, sizeof(struct ocfs2_refcount_rec));
1936	le64_add_cpu(var: &tail_rec->r_cpos,
1937	le32_to_cpu(tail_rec->r_clusters) - len);
1938	tail_rec->r_clusters = cpu_to_le32(len);
1939	}
1940
1941	/*
1942	* If the split pos isn't the same as the original one, we need to
1943	* split in the head.
1944	*
1945	* Note: We have the chance that split_rec.r_refcount = 0,
1946	* recs_need = 0 and len > 0, which means we just cut the head from
1947	* the orig_rec and in that case we have done some modification in
1948	* orig_rec above, so the check for r_cpos is faked.
1949	*/
1950	if (split_rec->r_cpos != orig_rec->r_cpos && tail_rec != orig_rec) {
1951	len = le64_to_cpu(split_rec->r_cpos) -
1952	le64_to_cpu(orig_rec->r_cpos);
1953	orig_rec->r_clusters = cpu_to_le32(len);
1954	index++;
1955	}
1956
1957	le16_add_cpu(var: &rf_list->rl_used, val: recs_need);
1958
1959	if (split_rec->r_refcount) {
1960	rf_list->rl_recs[index] = *split_rec;
1961	trace_ocfs2_split_refcount_rec_insert(
1962	blkno: (unsigned long long)ref_leaf_bh->b_blocknr, index,
1963	cpos: (unsigned long long)le64_to_cpu(split_rec->r_cpos),
1964	le32_to_cpu(split_rec->r_clusters),
1965	le32_to_cpu(split_rec->r_refcount));
1966
1967	if (merge)
1968	ocfs2_refcount_rec_merge(rb, index);
1969	}
1970
1971	ocfs2_journal_dirty(handle, bh: ref_leaf_bh);
1972
1973	out:
1974	brelse(bh: new_bh);
1975	return ret;
1976	}
1977
1978	static int __ocfs2_increase_refcount(handle_t *handle,
1979	struct ocfs2_caching_info *ci,
1980	struct buffer_head *ref_root_bh,
1981	u64 cpos, u32 len, int merge,
1982	struct ocfs2_alloc_context *meta_ac,
1983	struct ocfs2_cached_dealloc_ctxt *dealloc)
1984	{
1985	int ret = 0, index;
1986	struct buffer_head *ref_leaf_bh = NULL;
1987	struct ocfs2_refcount_rec rec;
1988	unsigned int set_len = 0;
1989
1990	trace_ocfs2_increase_refcount_begin(
1991	val1: (unsigned long long)ocfs2_metadata_cache_owner(ci),
1992	val2: (unsigned long long)cpos, val3: len);
1993
1994	while (len) {
1995	ret = ocfs2_get_refcount_rec(ci, ref_root_bh,
1996	cpos, len, ret_rec: &rec, index: &index,
1997	ret_bh: &ref_leaf_bh);
1998	if (ret) {
1999	mlog_errno(ret);
2000	goto out;
2001	}
2002
2003	set_len = le32_to_cpu(rec.r_clusters);
2004
2005	/*
2006	* Here we may meet with 3 situations:
2007	*
2008	* 1. If we find an already existing record, and the length
2009	* is the same, cool, we just need to increase the r_refcount
2010	* and it is OK.
2011	* 2. If we find a hole, just insert it with r_refcount = 1.
2012	* 3. If we are in the middle of one extent record, split
2013	* it.
2014	*/
2015	if (rec.r_refcount && le64_to_cpu(rec.r_cpos) == cpos &&
2016	set_len <= len) {
2017	trace_ocfs2_increase_refcount_change(
2018	val1: (unsigned long long)cpos, val2: set_len,
2019	le32_to_cpu(rec.r_refcount));
2020	ret = ocfs2_change_refcount_rec(handle, ci,
2021	ref_leaf_bh, index,
2022	merge, change: 1);
2023	if (ret) {
2024	mlog_errno(ret);
2025	goto out;
2026	}
2027	} else if (!rec.r_refcount) {
2028	rec.r_refcount = cpu_to_le32(1);
2029
2030	trace_ocfs2_increase_refcount_insert(
2031	val1: (unsigned long long)le64_to_cpu(rec.r_cpos),
2032	val2: set_len);
2033	ret = ocfs2_insert_refcount_rec(handle, ci, ref_root_bh,
2034	ref_leaf_bh,
2035	rec: &rec, index,
2036	merge, meta_ac);
2037	if (ret) {
2038	mlog_errno(ret);
2039	goto out;
2040	}
2041	} else {
2042	set_len = min((u64)(cpos + len),
2043	le64_to_cpu(rec.r_cpos) + set_len) - cpos;
2044	rec.r_cpos = cpu_to_le64(cpos);
2045	rec.r_clusters = cpu_to_le32(set_len);
2046	le32_add_cpu(var: &rec.r_refcount, val: 1);
2047
2048	trace_ocfs2_increase_refcount_split(
2049	val1: (unsigned long long)le64_to_cpu(rec.r_cpos),
2050	val2: set_len, le32_to_cpu(rec.r_refcount));
2051	ret = ocfs2_split_refcount_rec(handle, ci,
2052	ref_root_bh, ref_leaf_bh,
2053	split_rec: &rec, index, merge,
2054	meta_ac, dealloc);
2055	if (ret) {
2056	mlog_errno(ret);
2057	goto out;
2058	}
2059	}
2060
2061	cpos += set_len;
2062	len -= set_len;
2063	brelse(bh: ref_leaf_bh);
2064	ref_leaf_bh = NULL;
2065	}
2066
2067	out:
2068	brelse(bh: ref_leaf_bh);
2069	return ret;
2070	}
2071
2072	static int ocfs2_remove_refcount_extent(handle_t *handle,
2073	struct ocfs2_caching_info *ci,
2074	struct buffer_head *ref_root_bh,
2075	struct buffer_head *ref_leaf_bh,
2076	struct ocfs2_alloc_context *meta_ac,
2077	struct ocfs2_cached_dealloc_ctxt *dealloc)
2078	{
2079	int ret;
2080	struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
2081	struct ocfs2_refcount_block *rb =
2082	(struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
2083	struct ocfs2_extent_tree et;
2084
2085	BUG_ON(rb->rf_records.rl_used);
2086
2087	trace_ocfs2_remove_refcount_extent(
2088	val1: (unsigned long long)ocfs2_metadata_cache_owner(ci),
2089	val2: (unsigned long long)ref_leaf_bh->b_blocknr,
2090	le32_to_cpu(rb->rf_cpos));
2091
2092	ocfs2_init_refcount_extent_tree(et: &et, ci, bh: ref_root_bh);
2093	ret = ocfs2_remove_extent(handle, et: &et, le32_to_cpu(rb->rf_cpos),
2094	len: 1, meta_ac, dealloc);
2095	if (ret) {
2096	mlog_errno(ret);
2097	goto out;
2098	}
2099
2100	ocfs2_remove_from_cache(ci, bh: ref_leaf_bh);
2101
2102	/*
2103	* add the freed block to the dealloc so that it will be freed
2104	* when we run dealloc.
2105	*/
2106	ret = ocfs2_cache_block_dealloc(ctxt: dealloc, type: EXTENT_ALLOC_SYSTEM_INODE,
2107	le16_to_cpu(rb->rf_suballoc_slot),
2108	le64_to_cpu(rb->rf_suballoc_loc),
2109	le64_to_cpu(rb->rf_blkno),
2110	le16_to_cpu(rb->rf_suballoc_bit));
2111	if (ret) {
2112	mlog_errno(ret);
2113	goto out;
2114	}
2115
2116	ret = ocfs2_journal_access_rb(handle, ci, bh: ref_root_bh,
2117	OCFS2_JOURNAL_ACCESS_WRITE);
2118	if (ret) {
2119	mlog_errno(ret);
2120	goto out;
2121	}
2122
2123	rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
2124
2125	le32_add_cpu(var: &rb->rf_clusters, val: -1);
2126
2127	/*
2128	* check whether we need to restore the root refcount block if
2129	* there is no leaf extent block at atll.
2130	*/
2131	if (!rb->rf_list.l_next_free_rec) {
2132	BUG_ON(rb->rf_clusters);
2133
2134	trace_ocfs2_restore_refcount_block(
2135	num: (unsigned long long)ref_root_bh->b_blocknr);
2136
2137	rb->rf_flags = 0;
2138	rb->rf_parent = 0;
2139	rb->rf_cpos = 0;
2140	memset(&rb->rf_records, 0, sb->s_blocksize -
2141	offsetof(struct ocfs2_refcount_block, rf_records));
2142	rb->rf_records.rl_count =
2143	cpu_to_le16(ocfs2_refcount_recs_per_rb(sb));
2144	}
2145
2146	ocfs2_journal_dirty(handle, bh: ref_root_bh);
2147
2148	out:
2149	return ret;
2150	}
2151
2152	int ocfs2_increase_refcount(handle_t *handle,
2153	struct ocfs2_caching_info *ci,
2154	struct buffer_head *ref_root_bh,
2155	u64 cpos, u32 len,
2156	struct ocfs2_alloc_context *meta_ac,
2157	struct ocfs2_cached_dealloc_ctxt *dealloc)
2158	{
2159	return __ocfs2_increase_refcount(handle, ci, ref_root_bh,
2160	cpos, len, merge: 1,
2161	meta_ac, dealloc);
2162	}
2163
2164	static int ocfs2_decrease_refcount_rec(handle_t *handle,
2165	struct ocfs2_caching_info *ci,
2166	struct buffer_head *ref_root_bh,
2167	struct buffer_head *ref_leaf_bh,
2168	int index, u64 cpos, unsigned int len,
2169	struct ocfs2_alloc_context *meta_ac,
2170	struct ocfs2_cached_dealloc_ctxt *dealloc)
2171	{
2172	int ret;
2173	struct ocfs2_refcount_block *rb =
2174	(struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
2175	struct ocfs2_refcount_rec *rec = &rb->rf_records.rl_recs[index];
2176
2177	BUG_ON(cpos < le64_to_cpu(rec->r_cpos));
2178	BUG_ON(cpos + len >
2179	le64_to_cpu(rec->r_cpos) + le32_to_cpu(rec->r_clusters));
2180
2181	trace_ocfs2_decrease_refcount_rec(
2182	val1: (unsigned long long)ocfs2_metadata_cache_owner(ci),
2183	val2: (unsigned long long)cpos, val3: len);
2184
2185	if (cpos == le64_to_cpu(rec->r_cpos) &&
2186	len == le32_to_cpu(rec->r_clusters))
2187	ret = ocfs2_change_refcount_rec(handle, ci,
2188	ref_leaf_bh, index, merge: 1, change: -1);
2189	else {
2190	struct ocfs2_refcount_rec split = *rec;
2191	split.r_cpos = cpu_to_le64(cpos);
2192	split.r_clusters = cpu_to_le32(len);
2193
2194	le32_add_cpu(var: &split.r_refcount, val: -1);
2195
2196	ret = ocfs2_split_refcount_rec(handle, ci,
2197	ref_root_bh, ref_leaf_bh,
2198	split_rec: &split, index, merge: 1,
2199	meta_ac, dealloc);
2200	}
2201
2202	if (ret) {
2203	mlog_errno(ret);
2204	goto out;
2205	}
2206
2207	/* Remove the leaf refcount block if it contains no refcount record. */
2208	if (!rb->rf_records.rl_used && ref_leaf_bh != ref_root_bh) {
2209	ret = ocfs2_remove_refcount_extent(handle, ci, ref_root_bh,
2210	ref_leaf_bh, meta_ac,
2211	dealloc);
2212	if (ret)
2213	mlog_errno(ret);
2214	}
2215
2216	out:
2217	return ret;
2218	}
2219
2220	static int __ocfs2_decrease_refcount(handle_t *handle,
2221	struct ocfs2_caching_info *ci,
2222	struct buffer_head *ref_root_bh,
2223	u64 cpos, u32 len,
2224	struct ocfs2_alloc_context *meta_ac,
2225	struct ocfs2_cached_dealloc_ctxt *dealloc,
2226	int delete)
2227	{
2228	int ret = 0, index = 0;
2229	struct ocfs2_refcount_rec rec;
2230	unsigned int r_count = 0, r_len;
2231	struct super_block *sb = ocfs2_metadata_cache_get_super(ci);
2232	struct buffer_head *ref_leaf_bh = NULL;
2233
2234	trace_ocfs2_decrease_refcount(
2235	owner: (unsigned long long)ocfs2_metadata_cache_owner(ci),
2236	cpos: (unsigned long long)cpos, len, delete);
2237
2238	while (len) {
2239	ret = ocfs2_get_refcount_rec(ci, ref_root_bh,
2240	cpos, len, ret_rec: &rec, index: &index,
2241	ret_bh: &ref_leaf_bh);
2242	if (ret) {
2243	mlog_errno(ret);
2244	goto out;
2245	}
2246
2247	r_count = le32_to_cpu(rec.r_refcount);
2248	BUG_ON(r_count == 0);
2249	if (!delete)
2250	BUG_ON(r_count > 1);
2251
2252	r_len = min((u64)(cpos + len), le64_to_cpu(rec.r_cpos) +
2253	le32_to_cpu(rec.r_clusters)) - cpos;
2254
2255	ret = ocfs2_decrease_refcount_rec(handle, ci, ref_root_bh,
2256	ref_leaf_bh, index,
2257	cpos, len: r_len,
2258	meta_ac, dealloc);
2259	if (ret) {
2260	mlog_errno(ret);
2261	goto out;
2262	}
2263
2264	if (le32_to_cpu(rec.r_refcount) == 1 && delete) {
2265	ret = ocfs2_cache_cluster_dealloc(ctxt: dealloc,
2266	blkno: ocfs2_clusters_to_blocks(sb, clusters: cpos),
2267	bit: r_len);
2268	if (ret) {
2269	mlog_errno(ret);
2270	goto out;
2271	}
2272	}
2273
2274	cpos += r_len;
2275	len -= r_len;
2276	brelse(bh: ref_leaf_bh);
2277	ref_leaf_bh = NULL;
2278	}
2279
2280	out:
2281	brelse(bh: ref_leaf_bh);
2282	return ret;
2283	}
2284
2285	/* Caller must hold refcount tree lock. */
2286	int ocfs2_decrease_refcount(struct inode *inode,
2287	handle_t *handle, u32 cpos, u32 len,
2288	struct ocfs2_alloc_context *meta_ac,
2289	struct ocfs2_cached_dealloc_ctxt *dealloc,
2290	int delete)
2291	{
2292	int ret;
2293	u64 ref_blkno;
2294	struct buffer_head *ref_root_bh = NULL;
2295	struct ocfs2_refcount_tree *tree;
2296
2297	BUG_ON(!ocfs2_is_refcount_inode(inode));
2298
2299	ret = ocfs2_get_refcount_block(inode, ref_blkno: &ref_blkno);
2300	if (ret) {
2301	mlog_errno(ret);
2302	goto out;
2303	}
2304
2305	ret = ocfs2_get_refcount_tree(OCFS2_SB(inode->i_sb), rf_blkno: ref_blkno, ret_tree: &tree);
2306	if (ret) {
2307	mlog_errno(ret);
2308	goto out;
2309	}
2310
2311	ret = ocfs2_read_refcount_block(ci: &tree->rf_ci, rb_blkno: tree->rf_blkno,
2312	bh: &ref_root_bh);
2313	if (ret) {
2314	mlog_errno(ret);
2315	goto out;
2316	}
2317
2318	ret = __ocfs2_decrease_refcount(handle, ci: &tree->rf_ci, ref_root_bh,
2319	cpos, len, meta_ac, dealloc, delete);
2320	if (ret)
2321	mlog_errno(ret);
2322	out:
2323	brelse(bh: ref_root_bh);
2324	return ret;
2325	}
2326
2327	/*
2328	* Mark the already-existing extent at cpos as refcounted for len clusters.
2329	* This adds the refcount extent flag.
2330	*
2331	* If the existing extent is larger than the request, initiate a
2332	* split. An attempt will be made at merging with adjacent extents.
2333	*
2334	* The caller is responsible for passing down meta_ac if we'll need it.
2335	*/
2336	static int ocfs2_mark_extent_refcounted(struct inode *inode,
2337	struct ocfs2_extent_tree *et,
2338	handle_t *handle, u32 cpos,
2339	u32 len, u32 phys,
2340	struct ocfs2_alloc_context *meta_ac,
2341	struct ocfs2_cached_dealloc_ctxt *dealloc)
2342	{
2343	int ret;
2344
2345	trace_ocfs2_mark_extent_refcounted(ull: OCFS2_I(inode)->ip_blkno,
2346	value1: cpos, value2: len, value3: phys);
2347
2348	if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) {
2349	ret = ocfs2_error(inode->i_sb, "Inode %lu want to use refcount tree, but the feature bit is not set in the super block\n",
2350	inode->i_ino);
2351	goto out;
2352	}
2353
2354	ret = ocfs2_change_extent_flag(handle, et, cpos,
2355	len, phys, meta_ac, dealloc,
2356	OCFS2_EXT_REFCOUNTED, clear_flags: 0);
2357	if (ret)
2358	mlog_errno(ret);
2359
2360	out:
2361	return ret;
2362	}
2363
2364	/*
2365	* Given some contiguous physical clusters, calculate what we need
2366	* for modifying their refcount.
2367	*/
2368	static int ocfs2_calc_refcount_meta_credits(struct super_block *sb,
2369	struct ocfs2_caching_info *ci,
2370	struct buffer_head *ref_root_bh,
2371	u64 start_cpos,
2372	u32 clusters,
2373	int *meta_add,
2374	int *credits)
2375	{
2376	int ret = 0, index, ref_blocks = 0, recs_add = 0;
2377	u64 cpos = start_cpos;
2378	struct ocfs2_refcount_block *rb;
2379	struct ocfs2_refcount_rec rec;
2380	struct buffer_head *ref_leaf_bh = NULL, *prev_bh = NULL;
2381	u32 len;
2382
2383	while (clusters) {
2384	ret = ocfs2_get_refcount_rec(ci, ref_root_bh,
2385	cpos, len: clusters, ret_rec: &rec,
2386	index: &index, ret_bh: &ref_leaf_bh);
2387	if (ret) {
2388	mlog_errno(ret);
2389	goto out;
2390	}
2391
2392	if (ref_leaf_bh != prev_bh) {
2393	/*
2394	* Now we encounter a new leaf block, so calculate
2395	* whether we need to extend the old leaf.
2396	*/
2397	if (prev_bh) {
2398	rb = (struct ocfs2_refcount_block *)
2399	prev_bh->b_data;
2400
2401	if (le16_to_cpu(rb->rf_records.rl_used) +
2402	recs_add >
2403	le16_to_cpu(rb->rf_records.rl_count))
2404	ref_blocks++;
2405	}
2406
2407	recs_add = 0;
2408	*credits += 1;
2409	brelse(bh: prev_bh);
2410	prev_bh = ref_leaf_bh;
2411	get_bh(bh: prev_bh);
2412	}
2413
2414	trace_ocfs2_calc_refcount_meta_credits_iterate(
2415	recs_add, cpos: (unsigned long long)cpos, clusters,
2416	r_cpos: (unsigned long long)le64_to_cpu(rec.r_cpos),
2417	le32_to_cpu(rec.r_clusters),
2418	le32_to_cpu(rec.r_refcount), index);
2419
2420	len = min((u64)cpos + clusters, le64_to_cpu(rec.r_cpos) +
2421	le32_to_cpu(rec.r_clusters)) - cpos;
2422	/*
2423	* We record all the records which will be inserted to the
2424	* same refcount block, so that we can tell exactly whether
2425	* we need a new refcount block or not.
2426	*
2427	* If we will insert a new one, this is easy and only happens
2428	* during adding refcounted flag to the extent, so we don't
2429	* have a chance of spliting. We just need one record.
2430	*
2431	* If the refcount rec already exists, that would be a little
2432	* complicated. we may have to:
2433	* 1) split at the beginning if the start pos isn't aligned.
2434	* we need 1 more record in this case.
2435	* 2) split int the end if the end pos isn't aligned.
2436	* we need 1 more record in this case.
2437	* 3) split in the middle because of file system fragmentation.
2438	* we need 2 more records in this case(we can't detect this
2439	* beforehand, so always think of the worst case).
2440	*/
2441	if (rec.r_refcount) {
2442	recs_add += 2;
2443	/* Check whether we need a split at the beginning. */
2444	if (cpos == start_cpos &&
2445	cpos != le64_to_cpu(rec.r_cpos))
2446	recs_add++;
2447
2448	/* Check whether we need a split in the end. */
2449	if (cpos + clusters < le64_to_cpu(rec.r_cpos) +
2450	le32_to_cpu(rec.r_clusters))
2451	recs_add++;
2452	} else
2453	recs_add++;
2454
2455	brelse(bh: ref_leaf_bh);
2456	ref_leaf_bh = NULL;
2457	clusters -= len;
2458	cpos += len;
2459	}
2460
2461	if (prev_bh) {
2462	rb = (struct ocfs2_refcount_block *)prev_bh->b_data;
2463
2464	if (le16_to_cpu(rb->rf_records.rl_used) + recs_add >
2465	le16_to_cpu(rb->rf_records.rl_count))
2466	ref_blocks++;
2467
2468	*credits += 1;
2469	}
2470
2471	if (!ref_blocks)
2472	goto out;
2473
2474	*meta_add += ref_blocks;
2475	*credits += ref_blocks;
2476
2477	/*
2478	* So we may need ref_blocks to insert into the tree.
2479	* That also means we need to change the b-tree and add that number
2480	* of records since we never merge them.
2481	* We need one more block for expansion since the new created leaf
2482	* block is also full and needs split.
2483	*/
2484	rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
2485	if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL) {
2486	struct ocfs2_extent_tree et;
2487
2488	ocfs2_init_refcount_extent_tree(et: &et, ci, bh: ref_root_bh);
2489	*meta_add += ocfs2_extend_meta_needed(root_el: et.et_root_el);
2490	*credits += ocfs2_calc_extend_credits(sb,
2491	root_el: et.et_root_el);
2492	} else {
2493	*credits += OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
2494	*meta_add += 1;
2495	}
2496
2497	out:
2498
2499	trace_ocfs2_calc_refcount_meta_credits(
2500	ull: (unsigned long long)start_cpos, value1: clusters,
2501	value2: *meta_add, value3: *credits);
2502	brelse(bh: ref_leaf_bh);
2503	brelse(bh: prev_bh);
2504	return ret;
2505	}
2506
2507	/*
2508	* For refcount tree, we will decrease some contiguous clusters
2509	* refcount count, so just go through it to see how many blocks
2510	* we gonna touch and whether we need to create new blocks.
2511	*
2512	* Normally the refcount blocks store these refcount should be
2513	* contiguous also, so that we can get the number easily.
2514	* We will at most add split 2 refcount records and 2 more
2515	* refcount blocks, so just check it in a rough way.
2516	*
2517	* Caller must hold refcount tree lock.
2518	*/
2519	int ocfs2_prepare_refcount_change_for_del(struct inode *inode,
2520	u64 refcount_loc,
2521	u64 phys_blkno,
2522	u32 clusters,
2523	int *credits,
2524	int *ref_blocks)
2525	{
2526	int ret;
2527	struct buffer_head *ref_root_bh = NULL;
2528	struct ocfs2_refcount_tree *tree;
2529	u64 start_cpos = ocfs2_blocks_to_clusters(sb: inode->i_sb, blocks: phys_blkno);
2530
2531	if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) {
2532	ret = ocfs2_error(inode->i_sb, "Inode %lu want to use refcount tree, but the feature bit is not set in the super block\n",
2533	inode->i_ino);
2534	goto out;
2535	}
2536
2537	BUG_ON(!ocfs2_is_refcount_inode(inode));
2538
2539	ret = ocfs2_get_refcount_tree(OCFS2_SB(inode->i_sb),
2540	rf_blkno: refcount_loc, ret_tree: &tree);
2541	if (ret) {
2542	mlog_errno(ret);
2543	goto out;
2544	}
2545
2546	ret = ocfs2_read_refcount_block(ci: &tree->rf_ci, rb_blkno: refcount_loc,
2547	bh: &ref_root_bh);
2548	if (ret) {
2549	mlog_errno(ret);
2550	goto out;
2551	}
2552
2553	ret = ocfs2_calc_refcount_meta_credits(sb: inode->i_sb,
2554	ci: &tree->rf_ci,
2555	ref_root_bh,
2556	start_cpos, clusters,
2557	meta_add: ref_blocks, credits);
2558	if (ret) {
2559	mlog_errno(ret);
2560	goto out;
2561	}
2562
2563	trace_ocfs2_prepare_refcount_change_for_del(val1: *ref_blocks, val2: *credits);
2564
2565	out:
2566	brelse(bh: ref_root_bh);
2567	return ret;
2568	}
2569
2570	#define MAX_CONTIG_BYTES 1048576
2571
2572	static inline unsigned int ocfs2_cow_contig_clusters(struct super_block *sb)
2573	{
2574	return ocfs2_clusters_for_bytes(sb, MAX_CONTIG_BYTES);
2575	}
2576
2577	static inline unsigned int ocfs2_cow_contig_mask(struct super_block *sb)
2578	{
2579	return ~(ocfs2_cow_contig_clusters(sb) - 1);
2580	}
2581
2582	/*
2583	* Given an extent that starts at 'start' and an I/O that starts at 'cpos',
2584	* find an offset (start + (n * contig_clusters)) that is closest to cpos
2585	* while still being less than or equal to it.
2586	*
2587	* The goal is to break the extent at a multiple of contig_clusters.
2588	*/
2589	static inline unsigned int ocfs2_cow_align_start(struct super_block *sb,
2590	unsigned int start,
2591	unsigned int cpos)
2592	{
2593	BUG_ON(start > cpos);
2594
2595	return start + ((cpos - start) & ocfs2_cow_contig_mask(sb));
2596	}
2597
2598	/*
2599	* Given a cluster count of len, pad it out so that it is a multiple
2600	* of contig_clusters.
2601	*/
2602	static inline unsigned int ocfs2_cow_align_length(struct super_block *sb,
2603	unsigned int len)
2604	{
2605	unsigned int padded =
2606	(len + (ocfs2_cow_contig_clusters(sb) - 1)) &
2607	ocfs2_cow_contig_mask(sb);
2608
2609	/* Did we wrap? */
2610	if (padded < len)
2611	padded = UINT_MAX;
2612
2613	return padded;
2614	}
2615
2616	/*
2617	* Calculate out the start and number of virtual clusters we need to CoW.
2618	*
2619	* cpos is vitual start cluster position we want to do CoW in a
2620	* file and write_len is the cluster length.
2621	* max_cpos is the place where we want to stop CoW intentionally.
2622	*
2623	* Normal we will start CoW from the beginning of extent record cotaining cpos.
2624	* We try to break up extents on boundaries of MAX_CONTIG_BYTES so that we
2625	* get good I/O from the resulting extent tree.
2626	*/
2627	static int ocfs2_refcount_cal_cow_clusters(struct inode *inode,
2628	struct ocfs2_extent_list *el,
2629	u32 cpos,
2630	u32 write_len,
2631	u32 max_cpos,
2632	u32 *cow_start,
2633	u32 *cow_len)
2634	{
2635	int ret = 0;
2636	int tree_height = le16_to_cpu(el->l_tree_depth), i;
2637	struct buffer_head *eb_bh = NULL;
2638	struct ocfs2_extent_block *eb = NULL;
2639	struct ocfs2_extent_rec *rec;
2640	unsigned int want_clusters, rec_end = 0;
2641	int contig_clusters = ocfs2_cow_contig_clusters(sb: inode->i_sb);
2642	int leaf_clusters;
2643
2644	BUG_ON(cpos + write_len > max_cpos);
2645
2646	if (tree_height > 0) {
2647	ret = ocfs2_find_leaf(ci: INODE_CACHE(inode), root_el: el, cpos, leaf_bh: &eb_bh);
2648	if (ret) {
2649	mlog_errno(ret);
2650	goto out;
2651	}
2652
2653	eb = (struct ocfs2_extent_block *) eb_bh->b_data;
2654	el = &eb->h_list;
2655
2656	if (el->l_tree_depth) {
2657	ret = ocfs2_error(inode->i_sb,
2658	"Inode %lu has non zero tree depth in leaf block %llu\n",
2659	inode->i_ino,
2660	(unsigned long long)eb_bh->b_blocknr);
2661	goto out;
2662	}
2663	}
2664
2665	*cow_len = 0;
2666	for (i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
2667	rec = &el->l_recs[i];
2668
2669	if (ocfs2_is_empty_extent(rec)) {
2670	mlog_bug_on_msg(i != 0, "Inode %lu has empty record in "
2671	"index %d\n", inode->i_ino, i);
2672	continue;
2673	}
2674
2675	if (le32_to_cpu(rec->e_cpos) +
2676	le16_to_cpu(rec->e_leaf_clusters) <= cpos)
2677	continue;
2678
2679	if (*cow_len == 0) {
2680	/*
2681	* We should find a refcounted record in the
2682	* first pass.
2683	*/
2684	BUG_ON(!(rec->e_flags & OCFS2_EXT_REFCOUNTED));
2685	*cow_start = le32_to_cpu(rec->e_cpos);
2686	}
2687
2688	/*
2689	* If we encounter a hole, a non-refcounted record or
2690	* pass the max_cpos, stop the search.
2691	*/
2692	if ((!(rec->e_flags & OCFS2_EXT_REFCOUNTED)) ||
2693	(*cow_len && rec_end != le32_to_cpu(rec->e_cpos)) ||
2694	(max_cpos <= le32_to_cpu(rec->e_cpos)))
2695	break;
2696
2697	leaf_clusters = le16_to_cpu(rec->e_leaf_clusters);
2698	rec_end = le32_to_cpu(rec->e_cpos) + leaf_clusters;
2699	if (rec_end > max_cpos) {
2700	rec_end = max_cpos;
2701	leaf_clusters = rec_end - le32_to_cpu(rec->e_cpos);
2702	}
2703
2704	/*
2705	* How many clusters do we actually need from
2706	* this extent? First we see how many we actually
2707	* need to complete the write. If that's smaller
2708	* than contig_clusters, we try for contig_clusters.
2709	*/
2710	if (!*cow_len)
2711	want_clusters = write_len;
2712	else
2713	want_clusters = (cpos + write_len) -
2714	(*cow_start + *cow_len);
2715	if (want_clusters < contig_clusters)
2716	want_clusters = contig_clusters;
2717
2718	/*
2719	* If the write does not cover the whole extent, we
2720	* need to calculate how we're going to split the extent.
2721	* We try to do it on contig_clusters boundaries.
2722	*
2723	* Any extent smaller than contig_clusters will be
2724	* CoWed in its entirety.
2725	*/
2726	if (leaf_clusters <= contig_clusters)
2727	*cow_len += leaf_clusters;
2728	else if (*cow_len || (*cow_start == cpos)) {
2729	/*
2730	* This extent needs to be CoW'd from its
2731	* beginning, so all we have to do is compute
2732	* how many clusters to grab. We align
2733	* want_clusters to the edge of contig_clusters
2734	* to get better I/O.
2735	*/
2736	want_clusters = ocfs2_cow_align_length(sb: inode->i_sb,
2737	len: want_clusters);
2738
2739	if (leaf_clusters < want_clusters)
2740	*cow_len += leaf_clusters;
2741	else
2742	*cow_len += want_clusters;
2743	} else if ((*cow_start + contig_clusters) >=
2744	(cpos + write_len)) {
2745	/*
2746	* Breaking off contig_clusters at the front
2747	* of the extent will cover our write. That's
2748	* easy.
2749	*/
2750	*cow_len = contig_clusters;
2751	} else if ((rec_end - cpos) <= contig_clusters) {
2752	/*
2753	* Breaking off contig_clusters at the tail of
2754	* this extent will cover cpos.
2755	*/
2756	*cow_start = rec_end - contig_clusters;
2757	*cow_len = contig_clusters;
2758	} else if ((rec_end - cpos) <= want_clusters) {
2759	/*
2760	* While we can't fit the entire write in this
2761	* extent, we know that the write goes from cpos
2762	* to the end of the extent. Break that off.
2763	* We try to break it at some multiple of
2764	* contig_clusters from the front of the extent.
2765	* Failing that (ie, cpos is within
2766	* contig_clusters of the front), we'll CoW the
2767	* entire extent.
2768	*/
2769	*cow_start = ocfs2_cow_align_start(sb: inode->i_sb,
2770	start: *cow_start, cpos);
2771	*cow_len = rec_end - *cow_start;
2772	} else {
2773	/*
2774	* Ok, the entire write lives in the middle of
2775	* this extent. Let's try to slice the extent up
2776	* nicely. Optimally, our CoW region starts at
2777	* m*contig_clusters from the beginning of the
2778	* extent and goes for n*contig_clusters,
2779	* covering the entire write.
2780	*/
2781	*cow_start = ocfs2_cow_align_start(sb: inode->i_sb,
2782	start: *cow_start, cpos);
2783
2784	want_clusters = (cpos + write_len) - *cow_start;
2785	want_clusters = ocfs2_cow_align_length(sb: inode->i_sb,
2786	len: want_clusters);
2787	if (*cow_start + want_clusters <= rec_end)
2788	*cow_len = want_clusters;
2789	else
2790	*cow_len = rec_end - *cow_start;
2791	}
2792
2793	/* Have we covered our entire write yet? */
2794	if ((*cow_start + *cow_len) >= (cpos + write_len))
2795	break;
2796
2797	/*
2798	* If we reach the end of the extent block and don't get enough
2799	* clusters, continue with the next extent block if possible.
2800	*/
2801	if (i + 1 == le16_to_cpu(el->l_next_free_rec) &&
2802	eb && eb->h_next_leaf_blk) {
2803	brelse(bh: eb_bh);
2804	eb_bh = NULL;
2805
2806	ret = ocfs2_read_extent_block(ci: INODE_CACHE(inode),
2807	le64_to_cpu(eb->h_next_leaf_blk),
2808	bh: &eb_bh);
2809	if (ret) {
2810	mlog_errno(ret);
2811	goto out;
2812	}
2813
2814	eb = (struct ocfs2_extent_block *) eb_bh->b_data;
2815	el = &eb->h_list;
2816	i = -1;
2817	}
2818	}
2819
2820	out:
2821	brelse(bh: eb_bh);
2822	return ret;
2823	}
2824
2825	/*
2826	* Prepare meta_ac, data_ac and calculate credits when we want to add some
2827	* num_clusters in data_tree "et" and change the refcount for the old
2828	* clusters(starting form p_cluster) in the refcount tree.
2829	*
2830	* Note:
2831	* 1. since we may split the old tree, so we at most will need num_clusters + 2
2832	* more new leaf records.
2833	* 2. In some case, we may not need to reserve new clusters(e.g, reflink), so
2834	* just give data_ac = NULL.
2835	*/
2836	static int ocfs2_lock_refcount_allocators(struct super_block *sb,
2837	u32 p_cluster, u32 num_clusters,
2838	struct ocfs2_extent_tree *et,
2839	struct ocfs2_caching_info *ref_ci,
2840	struct buffer_head *ref_root_bh,
2841	struct ocfs2_alloc_context **meta_ac,
2842	struct ocfs2_alloc_context **data_ac,
2843	int *credits)
2844	{
2845	int ret = 0, meta_add = 0;
2846	int num_free_extents = ocfs2_num_free_extents(et);
2847
2848	if (num_free_extents < 0) {
2849	ret = num_free_extents;
2850	mlog_errno(ret);
2851	goto out;
2852	}
2853
2854	if (num_free_extents < num_clusters + 2)
2855	meta_add =
2856	ocfs2_extend_meta_needed(root_el: et->et_root_el);
2857
2858	*credits += ocfs2_calc_extend_credits(sb, root_el: et->et_root_el);
2859
2860	ret = ocfs2_calc_refcount_meta_credits(sb, ci: ref_ci, ref_root_bh,
2861	start_cpos: p_cluster, clusters: num_clusters,
2862	meta_add: &meta_add, credits);
2863	if (ret) {
2864	mlog_errno(ret);
2865	goto out;
2866	}
2867
2868	trace_ocfs2_lock_refcount_allocators(val1: meta_add, val2: *credits);
2869	ret = ocfs2_reserve_new_metadata_blocks(OCFS2_SB(sb), blocks: meta_add,
2870	ac: meta_ac);
2871	if (ret) {
2872	mlog_errno(ret);
2873	goto out;
2874	}
2875
2876	if (data_ac) {
2877	ret = ocfs2_reserve_clusters(OCFS2_SB(sb), bits_wanted: num_clusters,
2878	ac: data_ac);
2879	if (ret)
2880	mlog_errno(ret);
2881	}
2882
2883	out:
2884	if (ret) {
2885	if (*meta_ac) {
2886	ocfs2_free_alloc_context(ac: *meta_ac);
2887	*meta_ac = NULL;
2888	}
2889	}
2890
2891	return ret;
2892	}
2893
2894	static int ocfs2_clear_cow_buffer(handle_t *handle, struct buffer_head *bh)
2895	{
2896	BUG_ON(buffer_dirty(bh));
2897
2898	clear_buffer_mapped(bh);
2899
2900	return 0;
2901	}
2902
2903	int ocfs2_duplicate_clusters_by_page(handle_t *handle,
2904	struct inode *inode,
2905	u32 cpos, u32 old_cluster,
2906	u32 new_cluster, u32 new_len)
2907	{
2908	int ret = 0, partial;
2909	struct super_block *sb = inode->i_sb;
2910	u64 new_block = ocfs2_clusters_to_blocks(sb, clusters: new_cluster);
2911	struct page *page;
2912	pgoff_t page_index;
2913	unsigned int from, to;
2914	loff_t offset, end, map_end;
2915	struct address_space *mapping = inode->i_mapping;
2916
2917	trace_ocfs2_duplicate_clusters_by_page(ull: cpos, value1: old_cluster,
2918	value2: new_cluster, value3: new_len);
2919
2920	offset = ((loff_t)cpos) << OCFS2_SB(sb)->s_clustersize_bits;
2921	end = offset + (new_len << OCFS2_SB(sb)->s_clustersize_bits);
2922	/*
2923	* We only duplicate pages until we reach the page contains i_size - 1.
2924	* So trim 'end' to i_size.
2925	*/
2926	if (end > i_size_read(inode))
2927	end = i_size_read(inode);
2928
2929	while (offset < end) {
2930	page_index = offset >> PAGE_SHIFT;
2931	map_end = ((loff_t)page_index + 1) << PAGE_SHIFT;
2932	if (map_end > end)
2933	map_end = end;
2934
2935	/* from, to is the offset within the page. */
2936	from = offset & (PAGE_SIZE - 1);
2937	to = PAGE_SIZE;
2938	if (map_end & (PAGE_SIZE - 1))
2939	to = map_end & (PAGE_SIZE - 1);
2940
2941	retry:
2942	page = find_or_create_page(mapping, index: page_index, GFP_NOFS);
2943	if (!page) {
2944	ret = -ENOMEM;
2945	mlog_errno(ret);
2946	break;
2947	}
2948
2949	/*
2950	* In case PAGE_SIZE <= CLUSTER_SIZE, we do not expect a dirty
2951	* page, so write it back.
2952	*/
2953	if (PAGE_SIZE <= OCFS2_SB(sb)->s_clustersize) {
2954	if (PageDirty(page)) {
2955	unlock_page(page);
2956	put_page(page);
2957
2958	ret = filemap_write_and_wait_range(mapping,
2959	lstart: offset, lend: map_end - 1);
2960	goto retry;
2961	}
2962	}
2963
2964	if (!PageUptodate(page)) {
2965	struct folio *folio = page_folio(page);
2966
2967	ret = block_read_full_folio(folio, ocfs2_get_block);
2968	if (ret) {
2969	mlog_errno(ret);
2970	goto unlock;
2971	}
2972	folio_lock(folio);
2973	}
2974
2975	if (page_has_buffers(page)) {
2976	ret = walk_page_buffers(handle, page_buffers(page),
2977	from, to, partial: &partial,
2978	fn: ocfs2_clear_cow_buffer);
2979	if (ret) {
2980	mlog_errno(ret);
2981	goto unlock;
2982	}
2983	}
2984
2985	ocfs2_map_and_dirty_page(inode,
2986	handle, from, to,
2987	page, zero: 0, phys: &new_block);
2988	mark_page_accessed(page);
2989	unlock:
2990	unlock_page(page);
2991	put_page(page);
2992	page = NULL;
2993	offset = map_end;
2994	if (ret)
2995	break;
2996	}
2997
2998	return ret;
2999	}
3000
3001	int ocfs2_duplicate_clusters_by_jbd(handle_t *handle,
3002	struct inode *inode,
3003	u32 cpos, u32 old_cluster,
3004	u32 new_cluster, u32 new_len)
3005	{
3006	int ret = 0;
3007	struct super_block *sb = inode->i_sb;
3008	struct ocfs2_caching_info *ci = INODE_CACHE(inode);
3009	int i, blocks = ocfs2_clusters_to_blocks(sb, clusters: new_len);
3010	u64 old_block = ocfs2_clusters_to_blocks(sb, clusters: old_cluster);
3011	u64 new_block = ocfs2_clusters_to_blocks(sb, clusters: new_cluster);
3012	struct ocfs2_super *osb = OCFS2_SB(sb);
3013	struct buffer_head *old_bh = NULL;
3014	struct buffer_head *new_bh = NULL;
3015
3016	trace_ocfs2_duplicate_clusters_by_page(ull: cpos, value1: old_cluster,
3017	value2: new_cluster, value3: new_len);
3018
3019	for (i = 0; i < blocks; i++, old_block++, new_block++) {
3020	new_bh = sb_getblk(sb: osb->sb, block: new_block);
3021	if (new_bh == NULL) {
3022	ret = -ENOMEM;
3023	mlog_errno(ret);
3024	break;
3025	}
3026
3027	ocfs2_set_new_buffer_uptodate(ci, bh: new_bh);
3028
3029	ret = ocfs2_read_block(ci, off: old_block, bh: &old_bh, NULL);
3030	if (ret) {
3031	mlog_errno(ret);
3032	break;
3033	}
3034
3035	ret = ocfs2_journal_access(handle, ci, bh: new_bh,
3036	OCFS2_JOURNAL_ACCESS_CREATE);
3037	if (ret) {
3038	mlog_errno(ret);
3039	break;
3040	}
3041
3042	memcpy(new_bh->b_data, old_bh->b_data, sb->s_blocksize);
3043	ocfs2_journal_dirty(handle, bh: new_bh);
3044
3045	brelse(bh: new_bh);
3046	brelse(bh: old_bh);
3047	new_bh = NULL;
3048	old_bh = NULL;
3049	}
3050
3051	brelse(bh: new_bh);
3052	brelse(bh: old_bh);
3053	return ret;
3054	}
3055
3056	static int ocfs2_clear_ext_refcount(handle_t *handle,
3057	struct ocfs2_extent_tree *et,
3058	u32 cpos, u32 p_cluster, u32 len,
3059	unsigned int ext_flags,
3060	struct ocfs2_alloc_context *meta_ac,
3061	struct ocfs2_cached_dealloc_ctxt *dealloc)
3062	{
3063	int ret, index;
3064	struct ocfs2_extent_rec replace_rec;
3065	struct ocfs2_path *path = NULL;
3066	struct ocfs2_extent_list *el;
3067	struct super_block *sb = ocfs2_metadata_cache_get_super(ci: et->et_ci);
3068	u64 ino = ocfs2_metadata_cache_owner(ci: et->et_ci);
3069
3070	trace_ocfs2_clear_ext_refcount(ino: (unsigned long long)ino,
3071	cpos, len, p_cluster, ext_flags);
3072
3073	memset(&replace_rec, 0, sizeof(replace_rec));
3074	replace_rec.e_cpos = cpu_to_le32(cpos);
3075	replace_rec.e_leaf_clusters = cpu_to_le16(len);
3076	replace_rec.e_blkno = cpu_to_le64(ocfs2_clusters_to_blocks(sb,
3077	p_cluster));
3078	replace_rec.e_flags = ext_flags;
3079	replace_rec.e_flags &= ~OCFS2_EXT_REFCOUNTED;
3080
3081	path = ocfs2_new_path_from_et(et);
3082	if (!path) {
3083	ret = -ENOMEM;
3084	mlog_errno(ret);
3085	goto out;
3086	}
3087
3088	ret = ocfs2_find_path(ci: et->et_ci, path, cpos);
3089	if (ret) {
3090	mlog_errno(ret);
3091	goto out;
3092	}
3093
3094	el = path_leaf_el(path);
3095
3096	index = ocfs2_search_extent_list(el, v_cluster: cpos);
3097	if (index == -1) {
3098	ret = ocfs2_error(sb,
3099	"Inode %llu has an extent at cpos %u which can no longer be found\n",
3100	(unsigned long long)ino, cpos);
3101	goto out;
3102	}
3103
3104	ret = ocfs2_split_extent(handle, et, path, split_index: index,
3105	split_rec: &replace_rec, meta_ac, dealloc);
3106	if (ret)
3107	mlog_errno(ret);
3108
3109	out:
3110	ocfs2_free_path(path);
3111	return ret;
3112	}
3113
3114	static int ocfs2_replace_clusters(handle_t *handle,
3115	struct ocfs2_cow_context *context,
3116	u32 cpos, u32 old,
3117	u32 new, u32 len,
3118	unsigned int ext_flags)
3119	{
3120	int ret;
3121	struct ocfs2_caching_info *ci = context->data_et.et_ci;
3122	u64 ino = ocfs2_metadata_cache_owner(ci);
3123
3124	trace_ocfs2_replace_clusters(ino: (unsigned long long)ino,
3125	cpos, old, new, len, ext_flags);
3126
3127	/*If the old clusters is unwritten, no need to duplicate. */
3128	if (!(ext_flags & OCFS2_EXT_UNWRITTEN)) {
3129	ret = context->cow_duplicate_clusters(handle, context->inode,
3130	cpos, old, new, len);
3131	if (ret) {
3132	mlog_errno(ret);
3133	goto out;
3134	}
3135	}
3136
3137	ret = ocfs2_clear_ext_refcount(handle, et: &context->data_et,
3138	cpos, p_cluster: new, len, ext_flags,
3139	meta_ac: context->meta_ac, dealloc: &context->dealloc);
3140	if (ret)
3141	mlog_errno(ret);
3142	out:
3143	return ret;
3144	}
3145
3146	int ocfs2_cow_sync_writeback(struct super_block *sb,
3147	struct inode *inode,
3148	u32 cpos, u32 num_clusters)
3149	{
3150	int ret;
3151	loff_t start, end;
3152
3153	if (ocfs2_should_order_data(inode))
3154	return 0;
3155
3156	start = ((loff_t)cpos) << OCFS2_SB(sb)->s_clustersize_bits;
3157	end = start + (num_clusters << OCFS2_SB(sb)->s_clustersize_bits) - 1;
3158
3159	ret = filemap_write_and_wait_range(mapping: inode->i_mapping, lstart: start, lend: end);
3160	if (ret < 0)
3161	mlog_errno(ret);
3162
3163	return ret;
3164	}
3165
3166	static int ocfs2_di_get_clusters(struct ocfs2_cow_context *context,
3167	u32 v_cluster, u32 *p_cluster,
3168	u32 *num_clusters,
3169	unsigned int *extent_flags)
3170	{
3171	return ocfs2_get_clusters(inode: context->inode, v_cluster, p_cluster,
3172	num_clusters, extent_flags);
3173	}
3174
3175	static int ocfs2_make_clusters_writable(struct super_block *sb,
3176	struct ocfs2_cow_context *context,
3177	u32 cpos, u32 p_cluster,
3178	u32 num_clusters, unsigned int e_flags)
3179	{
3180	int ret, delete, index, credits = 0;
3181	u32 new_bit, new_len, orig_num_clusters;
3182	unsigned int set_len;
3183	struct ocfs2_super *osb = OCFS2_SB(sb);
3184	handle_t *handle;
3185	struct buffer_head *ref_leaf_bh = NULL;
3186	struct ocfs2_caching_info *ref_ci = &context->ref_tree->rf_ci;
3187	struct ocfs2_refcount_rec rec;
3188
3189	trace_ocfs2_make_clusters_writable(ull: cpos, value1: p_cluster,
3190	value2: num_clusters, value3: e_flags);
3191
3192	ret = ocfs2_lock_refcount_allocators(sb, p_cluster, num_clusters,
3193	et: &context->data_et,
3194	ref_ci,
3195	ref_root_bh: context->ref_root_bh,
3196	meta_ac: &context->meta_ac,
3197	data_ac: &context->data_ac, credits: &credits);
3198	if (ret) {
3199	mlog_errno(ret);
3200	return ret;
3201	}
3202
3203	if (context->post_refcount)
3204	credits += context->post_refcount->credits;
3205
3206	credits += context->extra_credits;
3207	handle = ocfs2_start_trans(osb, max_buffs: credits);
3208	if (IS_ERR(ptr: handle)) {
3209	ret = PTR_ERR(ptr: handle);
3210	mlog_errno(ret);
3211	goto out;
3212	}
3213
3214	orig_num_clusters = num_clusters;
3215
3216	while (num_clusters) {
3217	ret = ocfs2_get_refcount_rec(ci: ref_ci, ref_root_bh: context->ref_root_bh,
3218	cpos: p_cluster, len: num_clusters,
3219	ret_rec: &rec, index: &index, ret_bh: &ref_leaf_bh);
3220	if (ret) {
3221	mlog_errno(ret);
3222	goto out_commit;
3223	}
3224
3225	BUG_ON(!rec.r_refcount);
3226	set_len = min((u64)p_cluster + num_clusters,
3227	le64_to_cpu(rec.r_cpos) +
3228	le32_to_cpu(rec.r_clusters)) - p_cluster;
3229
3230	/*
3231	* There are many different situation here.
3232	* 1. If refcount == 1, remove the flag and don't COW.
3233	* 2. If refcount > 1, allocate clusters.
3234	* Here we may not allocate r_len once at a time, so continue
3235	* until we reach num_clusters.
3236	*/
3237	if (le32_to_cpu(rec.r_refcount) == 1) {
3238	delete = 0;
3239	ret = ocfs2_clear_ext_refcount(handle,
3240	et: &context->data_et,
3241	cpos, p_cluster,
3242	len: set_len, ext_flags: e_flags,
3243	meta_ac: context->meta_ac,
3244	dealloc: &context->dealloc);
3245	if (ret) {
3246	mlog_errno(ret);
3247	goto out_commit;
3248	}
3249	} else {
3250	delete = 1;
3251
3252	ret = __ocfs2_claim_clusters(handle,
3253	ac: context->data_ac,
3254	min_clusters: 1, max_clusters: set_len,
3255	cluster_start: &new_bit, num_clusters: &new_len);
3256	if (ret) {
3257	mlog_errno(ret);
3258	goto out_commit;
3259	}
3260
3261	ret = ocfs2_replace_clusters(handle, context,
3262	cpos, old: p_cluster, new: new_bit,
3263	len: new_len, ext_flags: e_flags);
3264	if (ret) {
3265	mlog_errno(ret);
3266	goto out_commit;
3267	}
3268	set_len = new_len;
3269	}
3270
3271	ret = __ocfs2_decrease_refcount(handle, ci: ref_ci,
3272	ref_root_bh: context->ref_root_bh,
3273	cpos: p_cluster, len: set_len,
3274	meta_ac: context->meta_ac,
3275	dealloc: &context->dealloc, delete);
3276	if (ret) {
3277	mlog_errno(ret);
3278	goto out_commit;
3279	}
3280
3281	cpos += set_len;
3282	p_cluster += set_len;
3283	num_clusters -= set_len;
3284	brelse(bh: ref_leaf_bh);
3285	ref_leaf_bh = NULL;
3286	}
3287
3288	/* handle any post_cow action. */
3289	if (context->post_refcount && context->post_refcount->func) {
3290	ret = context->post_refcount->func(context->inode, handle,
3291	context->post_refcount->para);
3292	if (ret) {
3293	mlog_errno(ret);
3294	goto out_commit;
3295	}
3296	}
3297
3298	/*
3299	* Here we should write the new page out first if we are
3300	* in write-back mode.
3301	*/
3302	if (context->get_clusters == ocfs2_di_get_clusters) {
3303	ret = ocfs2_cow_sync_writeback(sb, inode: context->inode, cpos,
3304	num_clusters: orig_num_clusters);
3305	if (ret)
3306	mlog_errno(ret);
3307	}
3308
3309	out_commit:
3310	ocfs2_commit_trans(osb, handle);
3311
3312	out:
3313	if (context->data_ac) {
3314	ocfs2_free_alloc_context(ac: context->data_ac);
3315	context->data_ac = NULL;
3316	}
3317	if (context->meta_ac) {
3318	ocfs2_free_alloc_context(ac: context->meta_ac);
3319	context->meta_ac = NULL;
3320	}
3321	brelse(bh: ref_leaf_bh);
3322
3323	return ret;
3324	}
3325
3326	static int ocfs2_replace_cow(struct ocfs2_cow_context *context)
3327	{
3328	int ret = 0;
3329	struct inode *inode = context->inode;
3330	u32 cow_start = context->cow_start, cow_len = context->cow_len;
3331	u32 p_cluster, num_clusters;
3332	unsigned int ext_flags;
3333	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3334
3335	if (!ocfs2_refcount_tree(osb)) {
3336	return ocfs2_error(inode->i_sb, "Inode %lu want to use refcount tree, but the feature bit is not set in the super block\n",
3337	inode->i_ino);
3338	}
3339
3340	ocfs2_init_dealloc_ctxt(c: &context->dealloc);
3341
3342	while (cow_len) {
3343	ret = context->get_clusters(context, cow_start, &p_cluster,
3344	&num_clusters, &ext_flags);
3345	if (ret) {
3346	mlog_errno(ret);
3347	break;
3348	}
3349
3350	BUG_ON(!(ext_flags & OCFS2_EXT_REFCOUNTED));
3351
3352	if (cow_len < num_clusters)
3353	num_clusters = cow_len;
3354
3355	ret = ocfs2_make_clusters_writable(sb: inode->i_sb, context,
3356	cpos: cow_start, p_cluster,
3357	num_clusters, e_flags: ext_flags);
3358	if (ret) {
3359	mlog_errno(ret);
3360	break;
3361	}
3362
3363	cow_len -= num_clusters;
3364	cow_start += num_clusters;
3365	}
3366
3367	if (ocfs2_dealloc_has_cluster(c: &context->dealloc)) {
3368	ocfs2_schedule_truncate_log_flush(osb, cancel: 1);
3369	ocfs2_run_deallocs(osb, ctxt: &context->dealloc);
3370	}
3371
3372	return ret;
3373	}
3374
3375	/*
3376	* Starting at cpos, try to CoW write_len clusters. Don't CoW
3377	* past max_cpos. This will stop when it runs into a hole or an
3378	* unrefcounted extent.
3379	*/
3380	static int ocfs2_refcount_cow_hunk(struct inode *inode,
3381	struct buffer_head *di_bh,
3382	u32 cpos, u32 write_len, u32 max_cpos)
3383	{
3384	int ret;
3385	u32 cow_start = 0, cow_len = 0;
3386	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3387	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
3388	struct buffer_head *ref_root_bh = NULL;
3389	struct ocfs2_refcount_tree *ref_tree;
3390	struct ocfs2_cow_context *context = NULL;
3391
3392	BUG_ON(!ocfs2_is_refcount_inode(inode));
3393
3394	ret = ocfs2_refcount_cal_cow_clusters(inode, el: &di->id2.i_list,
3395	cpos, write_len, max_cpos,
3396	cow_start: &cow_start, cow_len: &cow_len);
3397	if (ret) {
3398	mlog_errno(ret);
3399	goto out;
3400	}
3401
3402	trace_ocfs2_refcount_cow_hunk(ino: OCFS2_I(inode)->ip_blkno,
3403	cpos, write_len, max_cpos,
3404	cow_start, cow_len);
3405
3406	BUG_ON(cow_len == 0);
3407
3408	context = kzalloc(size: sizeof(struct ocfs2_cow_context), GFP_NOFS);
3409	if (!context) {
3410	ret = -ENOMEM;
3411	mlog_errno(ret);
3412	goto out;
3413	}
3414
3415	ret = ocfs2_lock_refcount_tree(osb, le64_to_cpu(di->i_refcount_loc),
3416	rw: 1, ret_tree: &ref_tree, ref_bh: &ref_root_bh);
3417	if (ret) {
3418	mlog_errno(ret);
3419	goto out;
3420	}
3421
3422	context->inode = inode;
3423	context->cow_start = cow_start;
3424	context->cow_len = cow_len;
3425	context->ref_tree = ref_tree;
3426	context->ref_root_bh = ref_root_bh;
3427	context->cow_duplicate_clusters = ocfs2_duplicate_clusters_by_page;
3428	context->get_clusters = ocfs2_di_get_clusters;
3429
3430	ocfs2_init_dinode_extent_tree(et: &context->data_et,
3431	ci: INODE_CACHE(inode), bh: di_bh);
3432
3433	ret = ocfs2_replace_cow(context);
3434	if (ret)
3435	mlog_errno(ret);
3436
3437	/*
3438	* truncate the extent map here since no matter whether we meet with
3439	* any error during the action, we shouldn't trust cached extent map
3440	* any more.
3441	*/
3442	ocfs2_extent_map_trunc(inode, cluster: cow_start);
3443
3444	ocfs2_unlock_refcount_tree(osb, tree: ref_tree, rw: 1);
3445	brelse(bh: ref_root_bh);
3446	out:
3447	kfree(objp: context);
3448	return ret;
3449	}
3450
3451	/*
3452	* CoW any and all clusters between cpos and cpos+write_len.
3453	* Don't CoW past max_cpos. If this returns successfully, all
3454	* clusters between cpos and cpos+write_len are safe to modify.
3455	*/
3456	int ocfs2_refcount_cow(struct inode *inode,
3457	struct buffer_head *di_bh,
3458	u32 cpos, u32 write_len, u32 max_cpos)
3459	{
3460	int ret = 0;
3461	u32 p_cluster, num_clusters;
3462	unsigned int ext_flags;
3463
3464	while (write_len) {
3465	ret = ocfs2_get_clusters(inode, v_cluster: cpos, p_cluster: &p_cluster,
3466	num_clusters: &num_clusters, extent_flags: &ext_flags);
3467	if (ret) {
3468	mlog_errno(ret);
3469	break;
3470	}
3471
3472	if (write_len < num_clusters)
3473	num_clusters = write_len;
3474
3475	if (ext_flags & OCFS2_EXT_REFCOUNTED) {
3476	ret = ocfs2_refcount_cow_hunk(inode, di_bh, cpos,
3477	write_len: num_clusters, max_cpos);
3478	if (ret) {
3479	mlog_errno(ret);
3480	break;
3481	}
3482	}
3483
3484	write_len -= num_clusters;
3485	cpos += num_clusters;
3486	}
3487
3488	return ret;
3489	}
3490
3491	static int ocfs2_xattr_value_get_clusters(struct ocfs2_cow_context *context,
3492	u32 v_cluster, u32 *p_cluster,
3493	u32 *num_clusters,
3494	unsigned int *extent_flags)
3495	{
3496	struct inode *inode = context->inode;
3497	struct ocfs2_xattr_value_root *xv = context->cow_object;
3498
3499	return ocfs2_xattr_get_clusters(inode, v_cluster, p_cluster,
3500	num_clusters, el: &xv->xr_list,
3501	extent_flags);
3502	}
3503
3504	/*
3505	* Given a xattr value root, calculate the most meta/credits we need for
3506	* refcount tree change if we truncate it to 0.
3507	*/
3508	int ocfs2_refcounted_xattr_delete_need(struct inode *inode,
3509	struct ocfs2_caching_info *ref_ci,
3510	struct buffer_head *ref_root_bh,
3511	struct ocfs2_xattr_value_root *xv,
3512	int *meta_add, int *credits)
3513	{
3514	int ret = 0, index, ref_blocks = 0;
3515	u32 p_cluster, num_clusters;
3516	u32 cpos = 0, clusters = le32_to_cpu(xv->xr_clusters);
3517	struct ocfs2_refcount_block *rb;
3518	struct ocfs2_refcount_rec rec;
3519	struct buffer_head *ref_leaf_bh = NULL;
3520
3521	while (cpos < clusters) {
3522	ret = ocfs2_xattr_get_clusters(inode, v_cluster: cpos, p_cluster: &p_cluster,
3523	num_clusters: &num_clusters, el: &xv->xr_list,
3524	NULL);
3525	if (ret) {
3526	mlog_errno(ret);
3527	goto out;
3528	}
3529
3530	cpos += num_clusters;
3531
3532	while (num_clusters) {
3533	ret = ocfs2_get_refcount_rec(ci: ref_ci, ref_root_bh,
3534	cpos: p_cluster, len: num_clusters,
3535	ret_rec: &rec, index: &index,
3536	ret_bh: &ref_leaf_bh);
3537	if (ret) {
3538	mlog_errno(ret);
3539	goto out;
3540	}
3541
3542	BUG_ON(!rec.r_refcount);
3543
3544	rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data;
3545
3546	/*
3547	* We really don't know whether the other clusters is in
3548	* this refcount block or not, so just take the worst
3549	* case that all the clusters are in this block and each
3550	* one will split a refcount rec, so totally we need
3551	* clusters * 2 new refcount rec.
3552	*/
3553	if (le16_to_cpu(rb->rf_records.rl_used) + clusters * 2 >
3554	le16_to_cpu(rb->rf_records.rl_count))
3555	ref_blocks++;
3556
3557	*credits += 1;
3558	brelse(bh: ref_leaf_bh);
3559	ref_leaf_bh = NULL;
3560
3561	if (num_clusters <= le32_to_cpu(rec.r_clusters))
3562	break;
3563	else
3564	num_clusters -= le32_to_cpu(rec.r_clusters);
3565	p_cluster += num_clusters;
3566	}
3567	}
3568
3569	*meta_add += ref_blocks;
3570	if (!ref_blocks)
3571	goto out;
3572
3573	rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data;
3574	if (le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)
3575	*credits += OCFS2_EXPAND_REFCOUNT_TREE_CREDITS;
3576	else {
3577	struct ocfs2_extent_tree et;
3578
3579	ocfs2_init_refcount_extent_tree(et: &et, ci: ref_ci, bh: ref_root_bh);
3580	*credits += ocfs2_calc_extend_credits(sb: inode->i_sb,
3581	root_el: et.et_root_el);
3582	}
3583
3584	out:
3585	brelse(bh: ref_leaf_bh);
3586	return ret;
3587	}
3588
3589	/*
3590	* Do CoW for xattr.
3591	*/
3592	int ocfs2_refcount_cow_xattr(struct inode *inode,
3593	struct ocfs2_dinode *di,
3594	struct ocfs2_xattr_value_buf *vb,
3595	struct ocfs2_refcount_tree *ref_tree,
3596	struct buffer_head *ref_root_bh,
3597	u32 cpos, u32 write_len,
3598	struct ocfs2_post_refcount *post)
3599	{
3600	int ret;
3601	struct ocfs2_xattr_value_root *xv = vb->vb_xv;
3602	struct ocfs2_cow_context *context = NULL;
3603	u32 cow_start, cow_len;
3604
3605	BUG_ON(!ocfs2_is_refcount_inode(inode));
3606
3607	ret = ocfs2_refcount_cal_cow_clusters(inode, el: &xv->xr_list,
3608	cpos, write_len, UINT_MAX,
3609	cow_start: &cow_start, cow_len: &cow_len);
3610	if (ret) {
3611	mlog_errno(ret);
3612	goto out;
3613	}
3614
3615	BUG_ON(cow_len == 0);
3616
3617	context = kzalloc(size: sizeof(struct ocfs2_cow_context), GFP_NOFS);
3618	if (!context) {
3619	ret = -ENOMEM;
3620	mlog_errno(ret);
3621	goto out;
3622	}
3623
3624	context->inode = inode;
3625	context->cow_start = cow_start;
3626	context->cow_len = cow_len;
3627	context->ref_tree = ref_tree;
3628	context->ref_root_bh = ref_root_bh;
3629	context->cow_object = xv;
3630
3631	context->cow_duplicate_clusters = ocfs2_duplicate_clusters_by_jbd;
3632	/* We need the extra credits for duplicate_clusters by jbd. */
3633	context->extra_credits =
3634	ocfs2_clusters_to_blocks(sb: inode->i_sb, clusters: 1) * cow_len;
3635	context->get_clusters = ocfs2_xattr_value_get_clusters;
3636	context->post_refcount = post;
3637
3638	ocfs2_init_xattr_value_extent_tree(et: &context->data_et,
3639	ci: INODE_CACHE(inode), vb);
3640
3641	ret = ocfs2_replace_cow(context);
3642	if (ret)
3643	mlog_errno(ret);
3644
3645	out:
3646	kfree(objp: context);
3647	return ret;
3648	}
3649
3650	/*
3651	* Insert a new extent into refcount tree and mark a extent rec
3652	* as refcounted in the dinode tree.
3653	*/
3654	int ocfs2_add_refcount_flag(struct inode *inode,
3655	struct ocfs2_extent_tree *data_et,
3656	struct ocfs2_caching_info *ref_ci,
3657	struct buffer_head *ref_root_bh,
3658	u32 cpos, u32 p_cluster, u32 num_clusters,
3659	struct ocfs2_cached_dealloc_ctxt *dealloc,
3660	struct ocfs2_post_refcount *post)
3661	{
3662	int ret;
3663	handle_t *handle;
3664	int credits = 1, ref_blocks = 0;
3665	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3666	struct ocfs2_alloc_context *meta_ac = NULL;
3667
3668	/* We need to be able to handle at least an extent tree split. */
3669	ref_blocks = ocfs2_extend_meta_needed(root_el: data_et->et_root_el);
3670
3671	ret = ocfs2_calc_refcount_meta_credits(sb: inode->i_sb,
3672	ci: ref_ci, ref_root_bh,
3673	start_cpos: p_cluster, clusters: num_clusters,
3674	meta_add: &ref_blocks, credits: &credits);
3675	if (ret) {
3676	mlog_errno(ret);
3677	goto out;
3678	}
3679
3680	trace_ocfs2_add_refcount_flag(val1: ref_blocks, val2: credits);
3681
3682	if (ref_blocks) {
3683	ret = ocfs2_reserve_new_metadata_blocks(osb,
3684	blocks: ref_blocks, ac: &meta_ac);
3685	if (ret) {
3686	mlog_errno(ret);
3687	goto out;
3688	}
3689	}
3690
3691	if (post)
3692	credits += post->credits;
3693
3694	handle = ocfs2_start_trans(osb, max_buffs: credits);
3695	if (IS_ERR(ptr: handle)) {
3696	ret = PTR_ERR(ptr: handle);
3697	mlog_errno(ret);
3698	goto out;
3699	}
3700
3701	ret = ocfs2_mark_extent_refcounted(inode, et: data_et, handle,
3702	cpos, len: num_clusters, phys: p_cluster,
3703	meta_ac, dealloc);
3704	if (ret) {
3705	mlog_errno(ret);
3706	goto out_commit;
3707	}
3708
3709	ret = __ocfs2_increase_refcount(handle, ci: ref_ci, ref_root_bh,
3710	cpos: p_cluster, len: num_clusters, merge: 0,
3711	meta_ac, dealloc);
3712	if (ret) {
3713	mlog_errno(ret);
3714	goto out_commit;
3715	}
3716
3717	if (post && post->func) {
3718	ret = post->func(inode, handle, post->para);
3719	if (ret)
3720	mlog_errno(ret);
3721	}
3722
3723	out_commit:
3724	ocfs2_commit_trans(osb, handle);
3725	out:
3726	if (meta_ac)
3727	ocfs2_free_alloc_context(ac: meta_ac);
3728	return ret;
3729	}
3730
3731	static int ocfs2_change_ctime(struct inode *inode,
3732	struct buffer_head *di_bh)
3733	{
3734	int ret;
3735	handle_t *handle;
3736	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
3737
3738	handle = ocfs2_start_trans(OCFS2_SB(inode->i_sb),
3739	OCFS2_INODE_UPDATE_CREDITS);
3740	if (IS_ERR(ptr: handle)) {
3741	ret = PTR_ERR(ptr: handle);
3742	mlog_errno(ret);
3743	goto out;
3744	}
3745
3746	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode), bh: di_bh,
3747	OCFS2_JOURNAL_ACCESS_WRITE);
3748	if (ret) {
3749	mlog_errno(ret);
3750	goto out_commit;
3751	}
3752
3753	inode_set_ctime_current(inode);
3754	di->i_ctime = cpu_to_le64(inode_get_ctime_sec(inode));
3755	di->i_ctime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
3756
3757	ocfs2_journal_dirty(handle, bh: di_bh);
3758
3759	out_commit:
3760	ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
3761	out:
3762	return ret;
3763	}
3764
3765	static int ocfs2_attach_refcount_tree(struct inode *inode,
3766	struct buffer_head *di_bh)
3767	{
3768	int ret, data_changed = 0;
3769	struct buffer_head *ref_root_bh = NULL;
3770	struct ocfs2_inode_info *oi = OCFS2_I(inode);
3771	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
3772	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3773	struct ocfs2_refcount_tree *ref_tree;
3774	unsigned int ext_flags;
3775	loff_t size;
3776	u32 cpos, num_clusters, clusters, p_cluster;
3777	struct ocfs2_cached_dealloc_ctxt dealloc;
3778	struct ocfs2_extent_tree di_et;
3779
3780	ocfs2_init_dealloc_ctxt(c: &dealloc);
3781
3782	if (!ocfs2_is_refcount_inode(inode)) {
3783	ret = ocfs2_create_refcount_tree(inode, di_bh);
3784	if (ret) {
3785	mlog_errno(ret);
3786	goto out;
3787	}
3788	}
3789
3790	BUG_ON(!di->i_refcount_loc);
3791	ret = ocfs2_lock_refcount_tree(osb,
3792	le64_to_cpu(di->i_refcount_loc), rw: 1,
3793	ret_tree: &ref_tree, ref_bh: &ref_root_bh);
3794	if (ret) {
3795	mlog_errno(ret);
3796	goto out;
3797	}
3798
3799	if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
3800	goto attach_xattr;
3801
3802	ocfs2_init_dinode_extent_tree(et: &di_et, ci: INODE_CACHE(inode), bh: di_bh);
3803
3804	size = i_size_read(inode);
3805	clusters = ocfs2_clusters_for_bytes(sb: inode->i_sb, bytes: size);
3806
3807	cpos = 0;
3808	while (cpos < clusters) {
3809	ret = ocfs2_get_clusters(inode, v_cluster: cpos, p_cluster: &p_cluster,
3810	num_clusters: &num_clusters, extent_flags: &ext_flags);
3811	if (ret) {
3812	mlog_errno(ret);
3813	goto unlock;
3814	}
3815	if (p_cluster && !(ext_flags & OCFS2_EXT_REFCOUNTED)) {
3816	ret = ocfs2_add_refcount_flag(inode, data_et: &di_et,
3817	ref_ci: &ref_tree->rf_ci,
3818	ref_root_bh, cpos,
3819	p_cluster, num_clusters,
3820	dealloc: &dealloc, NULL);
3821	if (ret) {
3822	mlog_errno(ret);
3823	goto unlock;
3824	}
3825
3826	data_changed = 1;
3827	}
3828	cpos += num_clusters;
3829	}
3830
3831	attach_xattr:
3832	if (oi->ip_dyn_features & OCFS2_HAS_XATTR_FL) {
3833	ret = ocfs2_xattr_attach_refcount_tree(inode, fe_bh: di_bh,
3834	ref_ci: &ref_tree->rf_ci,
3835	ref_root_bh,
3836	dealloc: &dealloc);
3837	if (ret) {
3838	mlog_errno(ret);
3839	goto unlock;
3840	}
3841	}
3842
3843	if (data_changed) {
3844	ret = ocfs2_change_ctime(inode, di_bh);
3845	if (ret)
3846	mlog_errno(ret);
3847	}
3848
3849	unlock:
3850	ocfs2_unlock_refcount_tree(osb, tree: ref_tree, rw: 1);
3851	brelse(bh: ref_root_bh);
3852
3853	if (!ret && ocfs2_dealloc_has_cluster(c: &dealloc)) {
3854	ocfs2_schedule_truncate_log_flush(osb, cancel: 1);
3855	ocfs2_run_deallocs(osb, ctxt: &dealloc);
3856	}
3857	out:
3858	/*
3859	* Empty the extent map so that we may get the right extent
3860	* record from the disk.
3861	*/
3862	ocfs2_extent_map_trunc(inode, cluster: 0);
3863
3864	return ret;
3865	}
3866
3867	static int ocfs2_add_refcounted_extent(struct inode *inode,
3868	struct ocfs2_extent_tree *et,
3869	struct ocfs2_caching_info *ref_ci,
3870	struct buffer_head *ref_root_bh,
3871	u32 cpos, u32 p_cluster, u32 num_clusters,
3872	unsigned int ext_flags,
3873	struct ocfs2_cached_dealloc_ctxt *dealloc)
3874	{
3875	int ret;
3876	handle_t *handle;
3877	int credits = 0;
3878	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3879	struct ocfs2_alloc_context *meta_ac = NULL;
3880
3881	ret = ocfs2_lock_refcount_allocators(sb: inode->i_sb,
3882	p_cluster, num_clusters,
3883	et, ref_ci,
3884	ref_root_bh, meta_ac: &meta_ac,
3885	NULL, credits: &credits);
3886	if (ret) {
3887	mlog_errno(ret);
3888	goto out;
3889	}
3890
3891	handle = ocfs2_start_trans(osb, max_buffs: credits);
3892	if (IS_ERR(ptr: handle)) {
3893	ret = PTR_ERR(ptr: handle);
3894	mlog_errno(ret);
3895	goto out;
3896	}
3897
3898	ret = ocfs2_insert_extent(handle, et, cpos,
3899	start_blk: ocfs2_clusters_to_blocks(sb: inode->i_sb, clusters: p_cluster),
3900	new_clusters: num_clusters, flags: ext_flags, meta_ac);
3901	if (ret) {
3902	mlog_errno(ret);
3903	goto out_commit;
3904	}
3905
3906	ret = ocfs2_increase_refcount(handle, ci: ref_ci, ref_root_bh,
3907	cpos: p_cluster, len: num_clusters,
3908	meta_ac, dealloc);
3909	if (ret) {
3910	mlog_errno(ret);
3911	goto out_commit;
3912	}
3913
3914	ret = dquot_alloc_space_nodirty(inode,
3915	nr: ocfs2_clusters_to_bytes(sb: osb->sb, clusters: num_clusters));
3916	if (ret)
3917	mlog_errno(ret);
3918
3919	out_commit:
3920	ocfs2_commit_trans(osb, handle);
3921	out:
3922	if (meta_ac)
3923	ocfs2_free_alloc_context(ac: meta_ac);
3924	return ret;
3925	}
3926
3927	static int ocfs2_duplicate_inline_data(struct inode *s_inode,
3928	struct buffer_head *s_bh,
3929	struct inode *t_inode,
3930	struct buffer_head *t_bh)
3931	{
3932	int ret;
3933	handle_t *handle;
3934	struct ocfs2_super *osb = OCFS2_SB(s_inode->i_sb);
3935	struct ocfs2_dinode *s_di = (struct ocfs2_dinode *)s_bh->b_data;
3936	struct ocfs2_dinode *t_di = (struct ocfs2_dinode *)t_bh->b_data;
3937
3938	BUG_ON(!(OCFS2_I(s_inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL));
3939
3940	handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
3941	if (IS_ERR(ptr: handle)) {
3942	ret = PTR_ERR(ptr: handle);
3943	mlog_errno(ret);
3944	goto out;
3945	}
3946
3947	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode: t_inode), bh: t_bh,
3948	OCFS2_JOURNAL_ACCESS_WRITE);
3949	if (ret) {
3950	mlog_errno(ret);
3951	goto out_commit;
3952	}
3953
3954	t_di->id2.i_data.id_count = s_di->id2.i_data.id_count;
3955	memcpy(t_di->id2.i_data.id_data, s_di->id2.i_data.id_data,
3956	le16_to_cpu(s_di->id2.i_data.id_count));
3957	spin_lock(lock: &OCFS2_I(inode: t_inode)->ip_lock);
3958	OCFS2_I(inode: t_inode)->ip_dyn_features |= OCFS2_INLINE_DATA_FL;
3959	t_di->i_dyn_features = cpu_to_le16(OCFS2_I(t_inode)->ip_dyn_features);
3960	spin_unlock(lock: &OCFS2_I(inode: t_inode)->ip_lock);
3961
3962	ocfs2_journal_dirty(handle, bh: t_bh);
3963
3964	out_commit:
3965	ocfs2_commit_trans(osb, handle);
3966	out:
3967	return ret;
3968	}
3969
3970	static int ocfs2_duplicate_extent_list(struct inode *s_inode,
3971	struct inode *t_inode,
3972	struct buffer_head *t_bh,
3973	struct ocfs2_caching_info *ref_ci,
3974	struct buffer_head *ref_root_bh,
3975	struct ocfs2_cached_dealloc_ctxt *dealloc)
3976	{
3977	int ret = 0;
3978	u32 p_cluster, num_clusters, clusters, cpos;
3979	loff_t size;
3980	unsigned int ext_flags;
3981	struct ocfs2_extent_tree et;
3982
3983	ocfs2_init_dinode_extent_tree(et: &et, ci: INODE_CACHE(inode: t_inode), bh: t_bh);
3984
3985	size = i_size_read(inode: s_inode);
3986	clusters = ocfs2_clusters_for_bytes(sb: s_inode->i_sb, bytes: size);
3987
3988	cpos = 0;
3989	while (cpos < clusters) {
3990	ret = ocfs2_get_clusters(inode: s_inode, v_cluster: cpos, p_cluster: &p_cluster,
3991	num_clusters: &num_clusters, extent_flags: &ext_flags);
3992	if (ret) {
3993	mlog_errno(ret);
3994	goto out;
3995	}
3996	if (p_cluster) {
3997	ret = ocfs2_add_refcounted_extent(inode: t_inode, et: &et,
3998	ref_ci, ref_root_bh,
3999	cpos, p_cluster,
4000	num_clusters,
4001	ext_flags,
4002	dealloc);
4003	if (ret) {
4004	mlog_errno(ret);
4005	goto out;
4006	}
4007	}
4008
4009	cpos += num_clusters;
4010	}
4011
4012	out:
4013	return ret;
4014	}
4015
4016	/*
4017	* change the new file's attributes to the src.
4018	*
4019	* reflink creates a snapshot of a file, that means the attributes
4020	* must be identical except for three exceptions - nlink, ino, and ctime.
4021	*/
4022	static int ocfs2_complete_reflink(struct inode *s_inode,
4023	struct buffer_head *s_bh,
4024	struct inode *t_inode,
4025	struct buffer_head *t_bh,
4026	bool preserve)
4027	{
4028	int ret;
4029	handle_t *handle;
4030	struct ocfs2_dinode *s_di = (struct ocfs2_dinode *)s_bh->b_data;
4031	struct ocfs2_dinode *di = (struct ocfs2_dinode *)t_bh->b_data;
4032	loff_t size = i_size_read(inode: s_inode);
4033
4034	handle = ocfs2_start_trans(OCFS2_SB(t_inode->i_sb),
4035	OCFS2_INODE_UPDATE_CREDITS);
4036	if (IS_ERR(ptr: handle)) {
4037	ret = PTR_ERR(ptr: handle);
4038	mlog_errno(ret);
4039	return ret;
4040	}
4041
4042	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode: t_inode), bh: t_bh,
4043	OCFS2_JOURNAL_ACCESS_WRITE);
4044	if (ret) {
4045	mlog_errno(ret);
4046	goto out_commit;
4047	}
4048
4049	spin_lock(lock: &OCFS2_I(inode: t_inode)->ip_lock);
4050	OCFS2_I(inode: t_inode)->ip_clusters = OCFS2_I(inode: s_inode)->ip_clusters;
4051	OCFS2_I(inode: t_inode)->ip_attr = OCFS2_I(inode: s_inode)->ip_attr;
4052	OCFS2_I(inode: t_inode)->ip_dyn_features = OCFS2_I(inode: s_inode)->ip_dyn_features;
4053	spin_unlock(lock: &OCFS2_I(inode: t_inode)->ip_lock);
4054	i_size_write(inode: t_inode, i_size: size);
4055	t_inode->i_blocks = s_inode->i_blocks;
4056
4057	di->i_xattr_inline_size = s_di->i_xattr_inline_size;
4058	di->i_clusters = s_di->i_clusters;
4059	di->i_size = s_di->i_size;
4060	di->i_dyn_features = s_di->i_dyn_features;
4061	di->i_attr = s_di->i_attr;
4062
4063	if (preserve) {
4064	t_inode->i_uid = s_inode->i_uid;
4065	t_inode->i_gid = s_inode->i_gid;
4066	t_inode->i_mode = s_inode->i_mode;
4067	di->i_uid = s_di->i_uid;
4068	di->i_gid = s_di->i_gid;
4069	di->i_mode = s_di->i_mode;
4070
4071	/*
4072	* update time.
4073	* we want mtime to appear identical to the source and
4074	* update ctime.
4075	*/
4076	inode_set_ctime_current(inode: t_inode);
4077
4078	di->i_ctime = cpu_to_le64(inode_get_ctime_sec(t_inode));
4079	di->i_ctime_nsec = cpu_to_le32(inode_get_ctime_nsec(t_inode));
4080
4081	inode_set_mtime_to_ts(inode: t_inode, ts: inode_get_mtime(inode: s_inode));
4082	di->i_mtime = s_di->i_mtime;
4083	di->i_mtime_nsec = s_di->i_mtime_nsec;
4084	}
4085
4086	ocfs2_journal_dirty(handle, bh: t_bh);
4087
4088	out_commit:
4089	ocfs2_commit_trans(OCFS2_SB(t_inode->i_sb), handle);
4090	return ret;
4091	}
4092
4093	static int ocfs2_create_reflink_node(struct inode *s_inode,
4094	struct buffer_head *s_bh,
4095	struct inode *t_inode,
4096	struct buffer_head *t_bh,
4097	bool preserve)
4098	{
4099	int ret;
4100	struct buffer_head *ref_root_bh = NULL;
4101	struct ocfs2_cached_dealloc_ctxt dealloc;
4102	struct ocfs2_super *osb = OCFS2_SB(s_inode->i_sb);
4103	struct ocfs2_dinode *di = (struct ocfs2_dinode *)s_bh->b_data;
4104	struct ocfs2_refcount_tree *ref_tree;
4105
4106	ocfs2_init_dealloc_ctxt(c: &dealloc);
4107
4108	ret = ocfs2_set_refcount_tree(inode: t_inode, di_bh: t_bh,
4109	le64_to_cpu(di->i_refcount_loc));
4110	if (ret) {
4111	mlog_errno(ret);
4112	goto out;
4113	}
4114
4115	if (OCFS2_I(inode: s_inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
4116	ret = ocfs2_duplicate_inline_data(s_inode, s_bh,
4117	t_inode, t_bh);
4118	if (ret)
4119	mlog_errno(ret);
4120	goto out;
4121	}
4122
4123	ret = ocfs2_lock_refcount_tree(osb, le64_to_cpu(di->i_refcount_loc),
4124	rw: 1, ret_tree: &ref_tree, ref_bh: &ref_root_bh);
4125	if (ret) {
4126	mlog_errno(ret);
4127	goto out;
4128	}
4129
4130	ret = ocfs2_duplicate_extent_list(s_inode, t_inode, t_bh,
4131	ref_ci: &ref_tree->rf_ci, ref_root_bh,
4132	dealloc: &dealloc);
4133	if (ret) {
4134	mlog_errno(ret);
4135	goto out_unlock_refcount;
4136	}
4137
4138	out_unlock_refcount:
4139	ocfs2_unlock_refcount_tree(osb, tree: ref_tree, rw: 1);
4140	brelse(bh: ref_root_bh);
4141	out:
4142	if (ocfs2_dealloc_has_cluster(c: &dealloc)) {
4143	ocfs2_schedule_truncate_log_flush(osb, cancel: 1);
4144	ocfs2_run_deallocs(osb, ctxt: &dealloc);
4145	}
4146
4147	return ret;
4148	}
4149
4150	static int __ocfs2_reflink(struct dentry *old_dentry,
4151	struct buffer_head *old_bh,
4152	struct inode *new_inode,
4153	bool preserve)
4154	{
4155	int ret;
4156	struct inode *inode = d_inode(dentry: old_dentry);
4157	struct buffer_head *new_bh = NULL;
4158
4159	if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE) {
4160	ret = -EINVAL;
4161	mlog_errno(ret);
4162	goto out;
4163	}
4164
4165	ret = filemap_fdatawrite(inode->i_mapping);
4166	if (ret) {
4167	mlog_errno(ret);
4168	goto out;
4169	}
4170
4171	ret = ocfs2_attach_refcount_tree(inode, di_bh: old_bh);
4172	if (ret) {
4173	mlog_errno(ret);
4174	goto out;
4175	}
4176
4177	inode_lock_nested(inode: new_inode, subclass: I_MUTEX_CHILD);
4178	ret = ocfs2_inode_lock_nested(new_inode, &new_bh, 1,
4179	OI_LS_REFLINK_TARGET);
4180	if (ret) {
4181	mlog_errno(ret);
4182	goto out_unlock;
4183	}
4184
4185	ret = ocfs2_create_reflink_node(s_inode: inode, s_bh: old_bh,
4186	t_inode: new_inode, t_bh: new_bh, preserve);
4187	if (ret) {
4188	mlog_errno(ret);
4189	goto inode_unlock;
4190	}
4191
4192	if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_XATTR_FL) {
4193	ret = ocfs2_reflink_xattrs(old_inode: inode, old_bh,
4194	new_inode, new_bh,
4195	preserve_security: preserve);
4196	if (ret) {
4197	mlog_errno(ret);
4198	goto inode_unlock;
4199	}
4200	}
4201
4202	ret = ocfs2_complete_reflink(s_inode: inode, s_bh: old_bh,
4203	t_inode: new_inode, t_bh: new_bh, preserve);
4204	if (ret)
4205	mlog_errno(ret);
4206
4207	inode_unlock:
4208	ocfs2_inode_unlock(inode: new_inode, ex: 1);
4209	brelse(bh: new_bh);
4210	out_unlock:
4211	inode_unlock(inode: new_inode);
4212	out:
4213	if (!ret) {
4214	ret = filemap_fdatawait(mapping: inode->i_mapping);
4215	if (ret)
4216	mlog_errno(ret);
4217	}
4218	return ret;
4219	}
4220
4221	static int ocfs2_reflink(struct dentry *old_dentry, struct inode *dir,
4222	struct dentry *new_dentry, bool preserve)
4223	{
4224	int error, had_lock;
4225	struct inode *inode = d_inode(dentry: old_dentry);
4226	struct buffer_head *old_bh = NULL;
4227	struct inode *new_orphan_inode = NULL;
4228	struct ocfs2_lock_holder oh;
4229
4230	if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb)))
4231	return -EOPNOTSUPP;
4232
4233
4234	error = ocfs2_create_inode_in_orphan(dir, mode: inode->i_mode,
4235	new_inode: &new_orphan_inode);
4236	if (error) {
4237	mlog_errno(error);
4238	goto out;
4239	}
4240
4241	error = ocfs2_rw_lock(inode, write: 1);
4242	if (error) {
4243	mlog_errno(error);
4244	goto out;
4245	}
4246
4247	error = ocfs2_inode_lock(inode, &old_bh, 1);
4248	if (error) {
4249	mlog_errno(error);
4250	ocfs2_rw_unlock(inode, write: 1);
4251	goto out;
4252	}
4253
4254	down_write(sem: &OCFS2_I(inode)->ip_xattr_sem);
4255	down_write(sem: &OCFS2_I(inode)->ip_alloc_sem);
4256	error = __ocfs2_reflink(old_dentry, old_bh,
4257	new_inode: new_orphan_inode, preserve);
4258	up_write(sem: &OCFS2_I(inode)->ip_alloc_sem);
4259	up_write(sem: &OCFS2_I(inode)->ip_xattr_sem);
4260
4261	ocfs2_inode_unlock(inode, ex: 1);
4262	ocfs2_rw_unlock(inode, write: 1);
4263	brelse(bh: old_bh);
4264
4265	if (error) {
4266	mlog_errno(error);
4267	goto out;
4268	}
4269
4270	had_lock = ocfs2_inode_lock_tracker(inode: new_orphan_inode, NULL, ex: 1,
4271	oh: &oh);
4272	if (had_lock < 0) {
4273	error = had_lock;
4274	mlog_errno(error);
4275	goto out;
4276	}
4277
4278	/* If the security isn't preserved, we need to re-initialize them. */
4279	if (!preserve) {
4280	error = ocfs2_init_security_and_acl(dir, inode: new_orphan_inode,
4281	qstr: &new_dentry->d_name);
4282	if (error)
4283	mlog_errno(error);
4284	}
4285	if (!error) {
4286	error = ocfs2_mv_orphaned_inode_to_new(dir, new_inode: new_orphan_inode,
4287	new_dentry);
4288	if (error)
4289	mlog_errno(error);
4290	}
4291	ocfs2_inode_unlock_tracker(inode: new_orphan_inode, ex: 1, oh: &oh, had_lock);
4292
4293	out:
4294	if (new_orphan_inode) {
4295	/*
4296	* We need to open_unlock the inode no matter whether we
4297	* succeed or not, so that other nodes can delete it later.
4298	*/
4299	ocfs2_open_unlock(inode: new_orphan_inode);
4300	if (error)
4301	iput(new_orphan_inode);
4302	}
4303
4304	return error;
4305	}
4306
4307	/*
4308	* Below here are the bits used by OCFS2_IOC_REFLINK() to fake
4309	* sys_reflink(). This will go away when vfs_reflink() exists in
4310	* fs/namei.c.
4311	*/
4312
4313	/* copied from may_create in VFS. */
4314	static inline int ocfs2_may_create(struct inode *dir, struct dentry *child)
4315	{
4316	if (d_really_is_positive(dentry: child))
4317	return -EEXIST;
4318	if (IS_DEADDIR(dir))
4319	return -ENOENT;
4320	return inode_permission(&nop_mnt_idmap, dir, MAY_WRITE | MAY_EXEC);
4321	}
4322
4323	/**
4324	* ocfs2_vfs_reflink - Create a reference-counted link
4325	*
4326	* @old_dentry: source dentry + inode
4327	* @dir: directory to create the target
4328	* @new_dentry: target dentry
4329	* @preserve: if true, preserve all file attributes
4330	*/
4331	static int ocfs2_vfs_reflink(struct dentry *old_dentry, struct inode *dir,
4332	struct dentry *new_dentry, bool preserve)
4333	{
4334	struct inode *inode = d_inode(dentry: old_dentry);
4335	int error;
4336
4337	if (!inode)
4338	return -ENOENT;
4339
4340	error = ocfs2_may_create(dir, child: new_dentry);
4341	if (error)
4342	return error;
4343
4344	if (dir->i_sb != inode->i_sb)
4345	return -EXDEV;
4346
4347	/*
4348	* A reflink to an append-only or immutable file cannot be created.
4349	*/
4350	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
4351	return -EPERM;
4352
4353	/* Only regular files can be reflinked. */
4354	if (!S_ISREG(inode->i_mode))
4355	return -EPERM;
4356
4357	/*
4358	* If the caller wants to preserve ownership, they require the
4359	* rights to do so.
4360	*/
4361	if (preserve) {
4362	if (!uid_eq(current_fsuid(), right: inode->i_uid) && !capable(CAP_CHOWN))
4363	return -EPERM;
4364	if (!in_group_p(inode->i_gid) && !capable(CAP_CHOWN))
4365	return -EPERM;
4366	}
4367
4368	/*
4369	* If the caller is modifying any aspect of the attributes, they
4370	* are not creating a snapshot. They need read permission on the
4371	* file.
4372	*/
4373	if (!preserve) {
4374	error = inode_permission(&nop_mnt_idmap, inode, MAY_READ);
4375	if (error)
4376	return error;
4377	}
4378
4379	inode_lock(inode);
4380	error = dquot_initialize(inode: dir);
4381	if (!error)
4382	error = ocfs2_reflink(old_dentry, dir, new_dentry, preserve);
4383	inode_unlock(inode);
4384	if (!error)
4385	fsnotify_create(dir, dentry: new_dentry);
4386	return error;
4387	}
4388	/*
4389	* Most codes are copied from sys_linkat.
4390	*/
4391	int ocfs2_reflink_ioctl(struct inode *inode,
4392	const char __user *oldname,
4393	const char __user *newname,
4394	bool preserve)
4395	{
4396	struct dentry *new_dentry;
4397	struct path old_path, new_path;
4398	int error;
4399
4400	if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb)))
4401	return -EOPNOTSUPP;
4402
4403	error = user_path_at(AT_FDCWD, name: oldname, flags: 0, path: &old_path);
4404	if (error) {
4405	mlog_errno(error);
4406	return error;
4407	}
4408
4409	new_dentry = user_path_create(AT_FDCWD, newname, &new_path, 0);
4410	error = PTR_ERR(ptr: new_dentry);
4411	if (IS_ERR(ptr: new_dentry)) {
4412	mlog_errno(error);
4413	goto out;
4414	}
4415
4416	error = -EXDEV;
4417	if (old_path.mnt != new_path.mnt) {
4418	mlog_errno(error);
4419	goto out_dput;
4420	}
4421
4422	error = ocfs2_vfs_reflink(old_dentry: old_path.dentry,
4423	dir: d_inode(dentry: new_path.dentry),
4424	new_dentry, preserve);
4425	out_dput:
4426	done_path_create(&new_path, new_dentry);
4427	out:
4428	path_put(&old_path);
4429
4430	return error;
4431	}
4432
4433	/* Update destination inode size, if necessary. */
4434	int ocfs2_reflink_update_dest(struct inode *dest,
4435	struct buffer_head *d_bh,
4436	loff_t newlen)
4437	{
4438	handle_t *handle;
4439	int ret;
4440
4441	dest->i_blocks = ocfs2_inode_sector_count(inode: dest);
4442
4443	if (newlen <= i_size_read(inode: dest))
4444	return 0;
4445
4446	handle = ocfs2_start_trans(OCFS2_SB(dest->i_sb),
4447	OCFS2_INODE_UPDATE_CREDITS);
4448	if (IS_ERR(ptr: handle)) {
4449	ret = PTR_ERR(ptr: handle);
4450	mlog_errno(ret);
4451	return ret;
4452	}
4453
4454	/* Extend i_size if needed. */
4455	spin_lock(lock: &OCFS2_I(inode: dest)->ip_lock);
4456	if (newlen > i_size_read(inode: dest))
4457	i_size_write(inode: dest, i_size: newlen);
4458	spin_unlock(lock: &OCFS2_I(inode: dest)->ip_lock);
4459	inode_set_mtime_to_ts(inode: dest, ts: inode_set_ctime_current(inode: dest));
4460
4461	ret = ocfs2_mark_inode_dirty(handle, inode: dest, bh: d_bh);
4462	if (ret) {
4463	mlog_errno(ret);
4464	goto out_commit;
4465	}
4466
4467	out_commit:
4468	ocfs2_commit_trans(OCFS2_SB(dest->i_sb), handle);
4469	return ret;
4470	}
4471
4472	/* Remap the range pos_in:len in s_inode to pos_out:len in t_inode. */
4473	static loff_t ocfs2_reflink_remap_extent(struct inode *s_inode,
4474	struct buffer_head *s_bh,
4475	loff_t pos_in,
4476	struct inode *t_inode,
4477	struct buffer_head *t_bh,
4478	loff_t pos_out,
4479	loff_t len,
4480	struct ocfs2_cached_dealloc_ctxt *dealloc)
4481	{
4482	struct ocfs2_extent_tree s_et;
4483	struct ocfs2_extent_tree t_et;
4484	struct ocfs2_dinode *dis;
4485	struct buffer_head *ref_root_bh = NULL;
4486	struct ocfs2_refcount_tree *ref_tree;
4487	struct ocfs2_super *osb;
4488	loff_t remapped_bytes = 0;
4489	loff_t pstart, plen;
4490	u32 p_cluster, num_clusters, slast, spos, tpos, remapped_clus = 0;
4491	unsigned int ext_flags;
4492	int ret = 0;
4493
4494	osb = OCFS2_SB(s_inode->i_sb);
4495	dis = (struct ocfs2_dinode *)s_bh->b_data;
4496	ocfs2_init_dinode_extent_tree(et: &s_et, ci: INODE_CACHE(inode: s_inode), bh: s_bh);
4497	ocfs2_init_dinode_extent_tree(et: &t_et, ci: INODE_CACHE(inode: t_inode), bh: t_bh);
4498
4499	spos = ocfs2_bytes_to_clusters(sb: s_inode->i_sb, bytes: pos_in);
4500	tpos = ocfs2_bytes_to_clusters(sb: t_inode->i_sb, bytes: pos_out);
4501	slast = ocfs2_clusters_for_bytes(sb: s_inode->i_sb, bytes: pos_in + len);
4502
4503	while (spos < slast) {
4504	if (fatal_signal_pending(current)) {
4505	ret = -EINTR;
4506	goto out;
4507	}
4508
4509	/* Look up the extent. */
4510	ret = ocfs2_get_clusters(inode: s_inode, v_cluster: spos, p_cluster: &p_cluster,
4511	num_clusters: &num_clusters, extent_flags: &ext_flags);
4512	if (ret) {
4513	mlog_errno(ret);
4514	goto out;
4515	}
4516
4517	num_clusters = min_t(u32, num_clusters, slast - spos);
4518
4519	/* Punch out the dest range. */
4520	pstart = ocfs2_clusters_to_bytes(sb: t_inode->i_sb, clusters: tpos);
4521	plen = ocfs2_clusters_to_bytes(sb: t_inode->i_sb, clusters: num_clusters);
4522	ret = ocfs2_remove_inode_range(inode: t_inode, di_bh: t_bh, byte_start: pstart, byte_len: plen);
4523	if (ret) {
4524	mlog_errno(ret);
4525	goto out;
4526	}
4527
4528	if (p_cluster == 0)
4529	goto next_loop;
4530
4531	/* Lock the refcount btree... */
4532	ret = ocfs2_lock_refcount_tree(osb,
4533	le64_to_cpu(dis->i_refcount_loc),
4534	rw: 1, ret_tree: &ref_tree, ref_bh: &ref_root_bh);
4535	if (ret) {
4536	mlog_errno(ret);
4537	goto out;
4538	}
4539
4540	/* Mark s_inode's extent as refcounted. */
4541	if (!(ext_flags & OCFS2_EXT_REFCOUNTED)) {
4542	ret = ocfs2_add_refcount_flag(inode: s_inode, data_et: &s_et,
4543	ref_ci: &ref_tree->rf_ci,
4544	ref_root_bh, cpos: spos,
4545	p_cluster, num_clusters,
4546	dealloc, NULL);
4547	if (ret) {
4548	mlog_errno(ret);
4549	goto out_unlock_refcount;
4550	}
4551	}
4552
4553	/* Map in the new extent. */
4554	ext_flags |= OCFS2_EXT_REFCOUNTED;
4555	ret = ocfs2_add_refcounted_extent(inode: t_inode, et: &t_et,
4556	ref_ci: &ref_tree->rf_ci,
4557	ref_root_bh,
4558	cpos: tpos, p_cluster,
4559	num_clusters,
4560	ext_flags,
4561	dealloc);
4562	if (ret) {
4563	mlog_errno(ret);
4564	goto out_unlock_refcount;
4565	}
4566
4567	ocfs2_unlock_refcount_tree(osb, tree: ref_tree, rw: 1);
4568	brelse(bh: ref_root_bh);
4569	next_loop:
4570	spos += num_clusters;
4571	tpos += num_clusters;
4572	remapped_clus += num_clusters;
4573	}
4574
4575	goto out;
4576	out_unlock_refcount:
4577	ocfs2_unlock_refcount_tree(osb, tree: ref_tree, rw: 1);
4578	brelse(bh: ref_root_bh);
4579	out:
4580	remapped_bytes = ocfs2_clusters_to_bytes(sb: t_inode->i_sb, clusters: remapped_clus);
4581	remapped_bytes = min_t(loff_t, len, remapped_bytes);
4582
4583	return remapped_bytes > 0 ? remapped_bytes : ret;
4584	}
4585
4586	/* Set up refcount tree and remap s_inode to t_inode. */
4587	loff_t ocfs2_reflink_remap_blocks(struct inode *s_inode,
4588	struct buffer_head *s_bh,
4589	loff_t pos_in,
4590	struct inode *t_inode,
4591	struct buffer_head *t_bh,
4592	loff_t pos_out,
4593	loff_t len)
4594	{
4595	struct ocfs2_cached_dealloc_ctxt dealloc;
4596	struct ocfs2_super *osb;
4597	struct ocfs2_dinode *dis;
4598	struct ocfs2_dinode *dit;
4599	loff_t ret;
4600
4601	osb = OCFS2_SB(s_inode->i_sb);
4602	dis = (struct ocfs2_dinode *)s_bh->b_data;
4603	dit = (struct ocfs2_dinode *)t_bh->b_data;
4604	ocfs2_init_dealloc_ctxt(c: &dealloc);
4605
4606	/*
4607	* If we're reflinking the entire file and the source is inline
4608	* data, just copy the contents.
4609	*/
4610	if (pos_in == pos_out && pos_in == 0 && len == i_size_read(inode: s_inode) &&
4611	i_size_read(inode: t_inode) <= len &&
4612	(OCFS2_I(inode: s_inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)) {
4613	ret = ocfs2_duplicate_inline_data(s_inode, s_bh, t_inode, t_bh);
4614	if (ret)
4615	mlog_errno(ret);
4616	goto out;
4617	}
4618
4619	/*
4620	* If both inodes belong to two different refcount groups then
4621	* forget it because we don't know how (or want) to go merging
4622	* refcount trees.
4623	*/
4624	ret = -EOPNOTSUPP;
4625	if (ocfs2_is_refcount_inode(inode: s_inode) &&
4626	ocfs2_is_refcount_inode(inode: t_inode) &&
4627	le64_to_cpu(dis->i_refcount_loc) !=
4628	le64_to_cpu(dit->i_refcount_loc))
4629	goto out;
4630
4631	/* Neither inode has a refcount tree. Add one to s_inode. */
4632	if (!ocfs2_is_refcount_inode(inode: s_inode) &&
4633	!ocfs2_is_refcount_inode(inode: t_inode)) {
4634	ret = ocfs2_create_refcount_tree(inode: s_inode, di_bh: s_bh);
4635	if (ret) {
4636	mlog_errno(ret);
4637	goto out;
4638	}
4639	}
4640
4641	/* Ensure that both inodes end up with the same refcount tree. */
4642	if (!ocfs2_is_refcount_inode(inode: s_inode)) {
4643	ret = ocfs2_set_refcount_tree(inode: s_inode, di_bh: s_bh,
4644	le64_to_cpu(dit->i_refcount_loc));
4645	if (ret) {
4646	mlog_errno(ret);
4647	goto out;
4648	}
4649	}
4650	if (!ocfs2_is_refcount_inode(inode: t_inode)) {
4651	ret = ocfs2_set_refcount_tree(inode: t_inode, di_bh: t_bh,
4652	le64_to_cpu(dis->i_refcount_loc));
4653	if (ret) {
4654	mlog_errno(ret);
4655	goto out;
4656	}
4657	}
4658
4659	/* Turn off inline data in the dest file. */
4660	if (OCFS2_I(inode: t_inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
4661	ret = ocfs2_convert_inline_data_to_extents(inode: t_inode, di_bh: t_bh);
4662	if (ret) {
4663	mlog_errno(ret);
4664	goto out;
4665	}
4666	}
4667
4668	/* Actually remap extents now. */
4669	ret = ocfs2_reflink_remap_extent(s_inode, s_bh, pos_in, t_inode, t_bh,
4670	pos_out, len, dealloc: &dealloc);
4671	if (ret < 0) {
4672	mlog_errno(ret);
4673	goto out;
4674	}
4675
4676	out:
4677	if (ocfs2_dealloc_has_cluster(c: &dealloc)) {
4678	ocfs2_schedule_truncate_log_flush(osb, cancel: 1);
4679	ocfs2_run_deallocs(osb, ctxt: &dealloc);
4680	}
4681
4682	return ret;
4683	}
4684
4685	/* Lock an inode and grab a bh pointing to the inode. */
4686	int ocfs2_reflink_inodes_lock(struct inode *s_inode,
4687	struct buffer_head **bh_s,
4688	struct inode *t_inode,
4689	struct buffer_head **bh_t)
4690	{
4691	struct inode *inode1 = s_inode;
4692	struct inode *inode2 = t_inode;
4693	struct ocfs2_inode_info *oi1;
4694	struct ocfs2_inode_info *oi2;
4695	struct buffer_head *bh1 = NULL;
4696	struct buffer_head *bh2 = NULL;
4697	bool same_inode = (s_inode == t_inode);
4698	bool need_swap = (inode1->i_ino > inode2->i_ino);
4699	int status;
4700
4701	/* First grab the VFS and rw locks. */
4702	lock_two_nondirectories(s_inode, t_inode);
4703	if (need_swap)
4704	swap(inode1, inode2);
4705
4706	status = ocfs2_rw_lock(inode: inode1, write: 1);
4707	if (status) {
4708	mlog_errno(status);
4709	goto out_i1;
4710	}
4711	if (!same_inode) {
4712	status = ocfs2_rw_lock(inode: inode2, write: 1);
4713	if (status) {
4714	mlog_errno(status);
4715	goto out_i2;
4716	}
4717	}
4718
4719	/* Now go for the cluster locks */
4720	oi1 = OCFS2_I(inode: inode1);
4721	oi2 = OCFS2_I(inode: inode2);
4722
4723	trace_ocfs2_double_lock(val1: (unsigned long long)oi1->ip_blkno,
4724	val2: (unsigned long long)oi2->ip_blkno);
4725
4726	/* We always want to lock the one with the lower lockid first. */
4727	if (oi1->ip_blkno > oi2->ip_blkno)
4728	mlog_errno(-ENOLCK);
4729
4730	/* lock id1 */
4731	status = ocfs2_inode_lock_nested(inode1, &bh1, 1,
4732	OI_LS_REFLINK_TARGET);
4733	if (status < 0) {
4734	if (status != -ENOENT)
4735	mlog_errno(status);
4736	goto out_rw2;
4737	}
4738
4739	/* lock id2 */
4740	if (!same_inode) {
4741	status = ocfs2_inode_lock_nested(inode2, &bh2, 1,
4742	OI_LS_REFLINK_TARGET);
4743	if (status < 0) {
4744	if (status != -ENOENT)
4745	mlog_errno(status);
4746	goto out_cl1;
4747	}
4748	} else {
4749	bh2 = bh1;
4750	}
4751
4752	/*
4753	* If we swapped inode order above, we have to swap the buffer heads
4754	* before passing them back to the caller.
4755	*/
4756	if (need_swap)
4757	swap(bh1, bh2);
4758	*bh_s = bh1;
4759	*bh_t = bh2;
4760
4761	trace_ocfs2_double_lock_end(
4762	val1: (unsigned long long)oi1->ip_blkno,
4763	val2: (unsigned long long)oi2->ip_blkno);
4764
4765	return 0;
4766
4767	out_cl1:
4768	ocfs2_inode_unlock(inode: inode1, ex: 1);
4769	brelse(bh: bh1);
4770	out_rw2:
4771	ocfs2_rw_unlock(inode: inode2, write: 1);
4772	out_i2:
4773	ocfs2_rw_unlock(inode: inode1, write: 1);
4774	out_i1:
4775	unlock_two_nondirectories(s_inode, t_inode);
4776	return status;
4777	}
4778
4779	/* Unlock both inodes and release buffers. */
4780	void ocfs2_reflink_inodes_unlock(struct inode *s_inode,
4781	struct buffer_head *s_bh,
4782	struct inode *t_inode,
4783	struct buffer_head *t_bh)
4784	{
4785	ocfs2_inode_unlock(inode: s_inode, ex: 1);
4786	ocfs2_rw_unlock(inode: s_inode, write: 1);
4787	brelse(bh: s_bh);
4788	if (s_inode != t_inode) {
4789	ocfs2_inode_unlock(inode: t_inode, ex: 1);
4790	ocfs2_rw_unlock(inode: t_inode, write: 1);
4791	brelse(bh: t_bh);
4792	}
4793	unlock_two_nondirectories(s_inode, t_inode);
4794	}
4795