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