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