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 35 static inline struct ocfs2_refcount_tree * 36 cache_info_to_refcount(struct ocfs2_caching_info *ci) 37 { 38 return container_of(ci, struct ocfs2_refcount_tree, rf_ci); 39 } 40 41 static int ocfs2_validate_refcount_block(struct super_block *sb, 42 struct buffer_head *bh) 43 { 44 int rc; 45 struct ocfs2_refcount_block *rb = 46 (struct ocfs2_refcount_block *)bh->b_data; 47 48 mlog(0, "Validating refcount block %llu\n", 49 (unsigned long long)bh->b_blocknr); 50 51 BUG_ON(!buffer_uptodate(bh)); 52 53 /* 54 * If the ecc fails, we return the error but otherwise 55 * leave the filesystem running. We know any error is 56 * local to this block. 57 */ 58 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &rb->rf_check); 59 if (rc) { 60 mlog(ML_ERROR, "Checksum failed for refcount block %llu\n", 61 (unsigned long long)bh->b_blocknr); 62 return rc; 63 } 64 65 66 if (!OCFS2_IS_VALID_REFCOUNT_BLOCK(rb)) { 67 ocfs2_error(sb, 68 "Refcount block #%llu has bad signature %.*s", 69 (unsigned long long)bh->b_blocknr, 7, 70 rb->rf_signature); 71 return -EINVAL; 72 } 73 74 if (le64_to_cpu(rb->rf_blkno) != bh->b_blocknr) { 75 ocfs2_error(sb, 76 "Refcount block #%llu has an invalid rf_blkno " 77 "of %llu", 78 (unsigned long long)bh->b_blocknr, 79 (unsigned long long)le64_to_cpu(rb->rf_blkno)); 80 return -EINVAL; 81 } 82 83 if (le32_to_cpu(rb->rf_fs_generation) != OCFS2_SB(sb)->fs_generation) { 84 ocfs2_error(sb, 85 "Refcount block #%llu has an invalid " 86 "rf_fs_generation of #%u", 87 (unsigned long long)bh->b_blocknr, 88 le32_to_cpu(rb->rf_fs_generation)); 89 return -EINVAL; 90 } 91 92 return 0; 93 } 94 95 static int ocfs2_read_refcount_block(struct ocfs2_caching_info *ci, 96 u64 rb_blkno, 97 struct buffer_head **bh) 98 { 99 int rc; 100 struct buffer_head *tmp = *bh; 101 102 rc = ocfs2_read_block(ci, rb_blkno, &tmp, 103 ocfs2_validate_refcount_block); 104 105 /* If ocfs2_read_block() got us a new bh, pass it up. */ 106 if (!rc && !*bh) 107 *bh = tmp; 108 109 return rc; 110 } 111 112 static u64 ocfs2_refcount_cache_owner(struct ocfs2_caching_info *ci) 113 { 114 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci); 115 116 return rf->rf_blkno; 117 } 118 119 static struct super_block * 120 ocfs2_refcount_cache_get_super(struct ocfs2_caching_info *ci) 121 { 122 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci); 123 124 return rf->rf_sb; 125 } 126 127 static void ocfs2_refcount_cache_lock(struct ocfs2_caching_info *ci) 128 { 129 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci); 130 131 spin_lock(&rf->rf_lock); 132 } 133 134 static void ocfs2_refcount_cache_unlock(struct ocfs2_caching_info *ci) 135 { 136 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci); 137 138 spin_unlock(&rf->rf_lock); 139 } 140 141 static void ocfs2_refcount_cache_io_lock(struct ocfs2_caching_info *ci) 142 { 143 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci); 144 145 mutex_lock(&rf->rf_io_mutex); 146 } 147 148 static void ocfs2_refcount_cache_io_unlock(struct ocfs2_caching_info *ci) 149 { 150 struct ocfs2_refcount_tree *rf = cache_info_to_refcount(ci); 151 152 mutex_unlock(&rf->rf_io_mutex); 153 } 154 155 static const struct ocfs2_caching_operations ocfs2_refcount_caching_ops = { 156 .co_owner = ocfs2_refcount_cache_owner, 157 .co_get_super = ocfs2_refcount_cache_get_super, 158 .co_cache_lock = ocfs2_refcount_cache_lock, 159 .co_cache_unlock = ocfs2_refcount_cache_unlock, 160 .co_io_lock = ocfs2_refcount_cache_io_lock, 161 .co_io_unlock = ocfs2_refcount_cache_io_unlock, 162 }; 163 164 static struct ocfs2_refcount_tree * 165 ocfs2_find_refcount_tree(struct ocfs2_super *osb, u64 blkno) 166 { 167 struct rb_node *n = osb->osb_rf_lock_tree.rb_node; 168 struct ocfs2_refcount_tree *tree = NULL; 169 170 while (n) { 171 tree = rb_entry(n, struct ocfs2_refcount_tree, rf_node); 172 173 if (blkno < tree->rf_blkno) 174 n = n->rb_left; 175 else if (blkno > tree->rf_blkno) 176 n = n->rb_right; 177 else 178 return tree; 179 } 180 181 return NULL; 182 } 183 184 /* osb_lock is already locked. */ 185 static void ocfs2_insert_refcount_tree(struct ocfs2_super *osb, 186 struct ocfs2_refcount_tree *new) 187 { 188 u64 rf_blkno = new->rf_blkno; 189 struct rb_node *parent = NULL; 190 struct rb_node **p = &osb->osb_rf_lock_tree.rb_node; 191 struct ocfs2_refcount_tree *tmp; 192 193 while (*p) { 194 parent = *p; 195 196 tmp = rb_entry(parent, struct ocfs2_refcount_tree, 197 rf_node); 198 199 if (rf_blkno < tmp->rf_blkno) 200 p = &(*p)->rb_left; 201 else if (rf_blkno > tmp->rf_blkno) 202 p = &(*p)->rb_right; 203 else { 204 /* This should never happen! */ 205 mlog(ML_ERROR, "Duplicate refcount block %llu found!\n", 206 (unsigned long long)rf_blkno); 207 BUG(); 208 } 209 } 210 211 rb_link_node(&new->rf_node, parent, p); 212 rb_insert_color(&new->rf_node, &osb->osb_rf_lock_tree); 213 } 214 215 static void ocfs2_free_refcount_tree(struct ocfs2_refcount_tree *tree) 216 { 217 ocfs2_metadata_cache_exit(&tree->rf_ci); 218 ocfs2_simple_drop_lockres(OCFS2_SB(tree->rf_sb), &tree->rf_lockres); 219 ocfs2_lock_res_free(&tree->rf_lockres); 220 kfree(tree); 221 } 222 223 static inline void 224 ocfs2_erase_refcount_tree_from_list_no_lock(struct ocfs2_super *osb, 225 struct ocfs2_refcount_tree *tree) 226 { 227 rb_erase(&tree->rf_node, &osb->osb_rf_lock_tree); 228 if (osb->osb_ref_tree_lru && osb->osb_ref_tree_lru == tree) 229 osb->osb_ref_tree_lru = NULL; 230 } 231 232 static void ocfs2_erase_refcount_tree_from_list(struct ocfs2_super *osb, 233 struct ocfs2_refcount_tree *tree) 234 { 235 spin_lock(&osb->osb_lock); 236 ocfs2_erase_refcount_tree_from_list_no_lock(osb, tree); 237 spin_unlock(&osb->osb_lock); 238 } 239 240 void ocfs2_kref_remove_refcount_tree(struct kref *kref) 241 { 242 struct ocfs2_refcount_tree *tree = 243 container_of(kref, struct ocfs2_refcount_tree, rf_getcnt); 244 245 ocfs2_free_refcount_tree(tree); 246 } 247 248 static inline void 249 ocfs2_refcount_tree_get(struct ocfs2_refcount_tree *tree) 250 { 251 kref_get(&tree->rf_getcnt); 252 } 253 254 static inline void 255 ocfs2_refcount_tree_put(struct ocfs2_refcount_tree *tree) 256 { 257 kref_put(&tree->rf_getcnt, ocfs2_kref_remove_refcount_tree); 258 } 259 260 static inline void ocfs2_init_refcount_tree_ci(struct ocfs2_refcount_tree *new, 261 struct super_block *sb) 262 { 263 ocfs2_metadata_cache_init(&new->rf_ci, &ocfs2_refcount_caching_ops); 264 mutex_init(&new->rf_io_mutex); 265 new->rf_sb = sb; 266 spin_lock_init(&new->rf_lock); 267 } 268 269 static inline void ocfs2_init_refcount_tree_lock(struct ocfs2_super *osb, 270 struct ocfs2_refcount_tree *new, 271 u64 rf_blkno, u32 generation) 272 { 273 init_rwsem(&new->rf_sem); 274 ocfs2_refcount_lock_res_init(&new->rf_lockres, osb, 275 rf_blkno, generation); 276 } 277 278 static struct ocfs2_refcount_tree* 279 ocfs2_allocate_refcount_tree(struct ocfs2_super *osb, u64 rf_blkno) 280 { 281 struct ocfs2_refcount_tree *new; 282 283 new = kzalloc(sizeof(struct ocfs2_refcount_tree), GFP_NOFS); 284 if (!new) 285 return NULL; 286 287 new->rf_blkno = rf_blkno; 288 kref_init(&new->rf_getcnt); 289 ocfs2_init_refcount_tree_ci(new, osb->sb); 290 291 return new; 292 } 293 294 static int ocfs2_get_refcount_tree(struct ocfs2_super *osb, u64 rf_blkno, 295 struct ocfs2_refcount_tree **ret_tree) 296 { 297 int ret = 0; 298 struct ocfs2_refcount_tree *tree, *new = NULL; 299 struct buffer_head *ref_root_bh = NULL; 300 struct ocfs2_refcount_block *ref_rb; 301 302 spin_lock(&osb->osb_lock); 303 if (osb->osb_ref_tree_lru && 304 osb->osb_ref_tree_lru->rf_blkno == rf_blkno) 305 tree = osb->osb_ref_tree_lru; 306 else 307 tree = ocfs2_find_refcount_tree(osb, rf_blkno); 308 if (tree) 309 goto out; 310 311 spin_unlock(&osb->osb_lock); 312 313 new = ocfs2_allocate_refcount_tree(osb, rf_blkno); 314 if (!new) { 315 ret = -ENOMEM; 316 mlog_errno(ret); 317 return ret; 318 } 319 /* 320 * We need the generation to create the refcount tree lock and since 321 * it isn't changed during the tree modification, we are safe here to 322 * read without protection. 323 * We also have to purge the cache after we create the lock since the 324 * refcount block may have the stale data. It can only be trusted when 325 * we hold the refcount lock. 326 */ 327 ret = ocfs2_read_refcount_block(&new->rf_ci, rf_blkno, &ref_root_bh); 328 if (ret) { 329 mlog_errno(ret); 330 ocfs2_metadata_cache_exit(&new->rf_ci); 331 kfree(new); 332 return ret; 333 } 334 335 ref_rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data; 336 new->rf_generation = le32_to_cpu(ref_rb->rf_generation); 337 ocfs2_init_refcount_tree_lock(osb, new, rf_blkno, 338 new->rf_generation); 339 ocfs2_metadata_cache_purge(&new->rf_ci); 340 341 spin_lock(&osb->osb_lock); 342 tree = ocfs2_find_refcount_tree(osb, rf_blkno); 343 if (tree) 344 goto out; 345 346 ocfs2_insert_refcount_tree(osb, new); 347 348 tree = new; 349 new = NULL; 350 351 out: 352 *ret_tree = tree; 353 354 osb->osb_ref_tree_lru = tree; 355 356 spin_unlock(&osb->osb_lock); 357 358 if (new) 359 ocfs2_free_refcount_tree(new); 360 361 brelse(ref_root_bh); 362 return ret; 363 } 364 365 static int ocfs2_get_refcount_block(struct inode *inode, u64 *ref_blkno) 366 { 367 int ret; 368 struct buffer_head *di_bh = NULL; 369 struct ocfs2_dinode *di; 370 371 ret = ocfs2_read_inode_block(inode, &di_bh); 372 if (ret) { 373 mlog_errno(ret); 374 goto out; 375 } 376 377 BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL)); 378 379 di = (struct ocfs2_dinode *)di_bh->b_data; 380 *ref_blkno = le64_to_cpu(di->i_refcount_loc); 381 brelse(di_bh); 382 out: 383 return ret; 384 } 385 386 static int __ocfs2_lock_refcount_tree(struct ocfs2_super *osb, 387 struct ocfs2_refcount_tree *tree, int rw) 388 { 389 int ret; 390 391 ret = ocfs2_refcount_lock(tree, rw); 392 if (ret) { 393 mlog_errno(ret); 394 goto out; 395 } 396 397 if (rw) 398 down_write(&tree->rf_sem); 399 else 400 down_read(&tree->rf_sem); 401 402 out: 403 return ret; 404 } 405 406 /* 407 * Lock the refcount tree pointed by ref_blkno and return the tree. 408 * In most case, we lock the tree and read the refcount block. 409 * So read it here if the caller really needs it. 410 * 411 * If the tree has been re-created by other node, it will free the 412 * old one and re-create it. 413 */ 414 int ocfs2_lock_refcount_tree(struct ocfs2_super *osb, 415 u64 ref_blkno, int rw, 416 struct ocfs2_refcount_tree **ret_tree, 417 struct buffer_head **ref_bh) 418 { 419 int ret, delete_tree = 0; 420 struct ocfs2_refcount_tree *tree = NULL; 421 struct buffer_head *ref_root_bh = NULL; 422 struct ocfs2_refcount_block *rb; 423 424 again: 425 ret = ocfs2_get_refcount_tree(osb, ref_blkno, &tree); 426 if (ret) { 427 mlog_errno(ret); 428 return ret; 429 } 430 431 ocfs2_refcount_tree_get(tree); 432 433 ret = __ocfs2_lock_refcount_tree(osb, tree, rw); 434 if (ret) { 435 mlog_errno(ret); 436 ocfs2_refcount_tree_put(tree); 437 goto out; 438 } 439 440 ret = ocfs2_read_refcount_block(&tree->rf_ci, tree->rf_blkno, 441 &ref_root_bh); 442 if (ret) { 443 mlog_errno(ret); 444 ocfs2_unlock_refcount_tree(osb, tree, rw); 445 ocfs2_refcount_tree_put(tree); 446 goto out; 447 } 448 449 rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data; 450 /* 451 * If the refcount block has been freed and re-created, we may need 452 * to recreate the refcount tree also. 453 * 454 * Here we just remove the tree from the rb-tree, and the last 455 * kref holder will unlock and delete this refcount_tree. 456 * Then we goto "again" and ocfs2_get_refcount_tree will create 457 * the new refcount tree for us. 458 */ 459 if (tree->rf_generation != le32_to_cpu(rb->rf_generation)) { 460 if (!tree->rf_removed) { 461 ocfs2_erase_refcount_tree_from_list(osb, tree); 462 tree->rf_removed = 1; 463 delete_tree = 1; 464 } 465 466 ocfs2_unlock_refcount_tree(osb, tree, rw); 467 /* 468 * We get an extra reference when we create the refcount 469 * tree, so another put will destroy it. 470 */ 471 if (delete_tree) 472 ocfs2_refcount_tree_put(tree); 473 brelse(ref_root_bh); 474 ref_root_bh = NULL; 475 goto again; 476 } 477 478 *ret_tree = tree; 479 if (ref_bh) { 480 *ref_bh = ref_root_bh; 481 ref_root_bh = NULL; 482 } 483 out: 484 brelse(ref_root_bh); 485 return ret; 486 } 487 488 int ocfs2_lock_refcount_tree_by_inode(struct inode *inode, int rw, 489 struct ocfs2_refcount_tree **ret_tree, 490 struct buffer_head **ref_bh) 491 { 492 int ret; 493 u64 ref_blkno; 494 495 ret = ocfs2_get_refcount_block(inode, &ref_blkno); 496 if (ret) { 497 mlog_errno(ret); 498 return ret; 499 } 500 501 return ocfs2_lock_refcount_tree(OCFS2_SB(inode->i_sb), ref_blkno, 502 rw, ret_tree, ref_bh); 503 } 504 505 void ocfs2_unlock_refcount_tree(struct ocfs2_super *osb, 506 struct ocfs2_refcount_tree *tree, int rw) 507 { 508 if (rw) 509 up_write(&tree->rf_sem); 510 else 511 up_read(&tree->rf_sem); 512 513 ocfs2_refcount_unlock(tree, rw); 514 ocfs2_refcount_tree_put(tree); 515 } 516 517 void ocfs2_purge_refcount_trees(struct ocfs2_super *osb) 518 { 519 struct rb_node *node; 520 struct ocfs2_refcount_tree *tree; 521 struct rb_root *root = &osb->osb_rf_lock_tree; 522 523 while ((node = rb_last(root)) != NULL) { 524 tree = rb_entry(node, struct ocfs2_refcount_tree, rf_node); 525 526 mlog(0, "Purge tree %llu\n", 527 (unsigned long long) tree->rf_blkno); 528 529 rb_erase(&tree->rf_node, root); 530 ocfs2_free_refcount_tree(tree); 531 } 532 } 533 534 /* 535 * Create a refcount tree for an inode. 536 * We take for granted that the inode is already locked. 537 */ 538 static int ocfs2_create_refcount_tree(struct inode *inode, 539 struct buffer_head *di_bh) 540 { 541 int ret; 542 handle_t *handle = NULL; 543 struct ocfs2_alloc_context *meta_ac = NULL; 544 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 545 struct ocfs2_inode_info *oi = OCFS2_I(inode); 546 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 547 struct buffer_head *new_bh = NULL; 548 struct ocfs2_refcount_block *rb; 549 struct ocfs2_refcount_tree *new_tree = NULL, *tree = NULL; 550 u16 suballoc_bit_start; 551 u32 num_got; 552 u64 first_blkno; 553 554 BUG_ON(oi->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL); 555 556 mlog(0, "create tree for inode %lu\n", inode->i_ino); 557 558 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &meta_ac); 559 if (ret) { 560 mlog_errno(ret); 561 goto out; 562 } 563 564 handle = ocfs2_start_trans(osb, OCFS2_REFCOUNT_TREE_CREATE_CREDITS); 565 if (IS_ERR(handle)) { 566 ret = PTR_ERR(handle); 567 mlog_errno(ret); 568 goto out; 569 } 570 571 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh, 572 OCFS2_JOURNAL_ACCESS_WRITE); 573 if (ret) { 574 mlog_errno(ret); 575 goto out_commit; 576 } 577 578 ret = ocfs2_claim_metadata(osb, handle, meta_ac, 1, 579 &suballoc_bit_start, &num_got, 580 &first_blkno); 581 if (ret) { 582 mlog_errno(ret); 583 goto out_commit; 584 } 585 586 new_tree = ocfs2_allocate_refcount_tree(osb, first_blkno); 587 if (!new_tree) { 588 ret = -ENOMEM; 589 mlog_errno(ret); 590 goto out_commit; 591 } 592 593 new_bh = sb_getblk(inode->i_sb, first_blkno); 594 ocfs2_set_new_buffer_uptodate(&new_tree->rf_ci, new_bh); 595 596 ret = ocfs2_journal_access_rb(handle, &new_tree->rf_ci, new_bh, 597 OCFS2_JOURNAL_ACCESS_CREATE); 598 if (ret) { 599 mlog_errno(ret); 600 goto out_commit; 601 } 602 603 /* Initialize ocfs2_refcount_block. */ 604 rb = (struct ocfs2_refcount_block *)new_bh->b_data; 605 memset(rb, 0, inode->i_sb->s_blocksize); 606 strcpy((void *)rb, OCFS2_REFCOUNT_BLOCK_SIGNATURE); 607 rb->rf_suballoc_slot = cpu_to_le16(osb->slot_num); 608 rb->rf_suballoc_bit = cpu_to_le16(suballoc_bit_start); 609 rb->rf_fs_generation = cpu_to_le32(osb->fs_generation); 610 rb->rf_blkno = cpu_to_le64(first_blkno); 611 rb->rf_count = cpu_to_le32(1); 612 rb->rf_records.rl_count = 613 cpu_to_le16(ocfs2_refcount_recs_per_rb(osb->sb)); 614 spin_lock(&osb->osb_lock); 615 rb->rf_generation = osb->s_next_generation++; 616 spin_unlock(&osb->osb_lock); 617 618 ocfs2_journal_dirty(handle, new_bh); 619 620 spin_lock(&oi->ip_lock); 621 oi->ip_dyn_features |= OCFS2_HAS_REFCOUNT_FL; 622 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 623 di->i_refcount_loc = cpu_to_le64(first_blkno); 624 spin_unlock(&oi->ip_lock); 625 626 mlog(0, "created tree for inode %lu, refblock %llu\n", 627 inode->i_ino, (unsigned long long)first_blkno); 628 629 ocfs2_journal_dirty(handle, di_bh); 630 631 /* 632 * We have to init the tree lock here since it will use 633 * the generation number to create it. 634 */ 635 new_tree->rf_generation = le32_to_cpu(rb->rf_generation); 636 ocfs2_init_refcount_tree_lock(osb, new_tree, first_blkno, 637 new_tree->rf_generation); 638 639 spin_lock(&osb->osb_lock); 640 tree = ocfs2_find_refcount_tree(osb, first_blkno); 641 642 /* 643 * We've just created a new refcount tree in this block. If 644 * we found a refcount tree on the ocfs2_super, it must be 645 * one we just deleted. We free the old tree before 646 * inserting the new tree. 647 */ 648 BUG_ON(tree && tree->rf_generation == new_tree->rf_generation); 649 if (tree) 650 ocfs2_erase_refcount_tree_from_list_no_lock(osb, tree); 651 ocfs2_insert_refcount_tree(osb, new_tree); 652 spin_unlock(&osb->osb_lock); 653 new_tree = NULL; 654 if (tree) 655 ocfs2_refcount_tree_put(tree); 656 657 out_commit: 658 ocfs2_commit_trans(osb, handle); 659 660 out: 661 if (new_tree) { 662 ocfs2_metadata_cache_exit(&new_tree->rf_ci); 663 kfree(new_tree); 664 } 665 666 brelse(new_bh); 667 if (meta_ac) 668 ocfs2_free_alloc_context(meta_ac); 669 670 return ret; 671 } 672 673 static int ocfs2_set_refcount_tree(struct inode *inode, 674 struct buffer_head *di_bh, 675 u64 refcount_loc) 676 { 677 int ret; 678 handle_t *handle = NULL; 679 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 680 struct ocfs2_inode_info *oi = OCFS2_I(inode); 681 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 682 struct buffer_head *ref_root_bh = NULL; 683 struct ocfs2_refcount_block *rb; 684 struct ocfs2_refcount_tree *ref_tree; 685 686 BUG_ON(oi->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL); 687 688 ret = ocfs2_lock_refcount_tree(osb, refcount_loc, 1, 689 &ref_tree, &ref_root_bh); 690 if (ret) { 691 mlog_errno(ret); 692 return ret; 693 } 694 695 handle = ocfs2_start_trans(osb, OCFS2_REFCOUNT_TREE_SET_CREDITS); 696 if (IS_ERR(handle)) { 697 ret = PTR_ERR(handle); 698 mlog_errno(ret); 699 goto out; 700 } 701 702 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh, 703 OCFS2_JOURNAL_ACCESS_WRITE); 704 if (ret) { 705 mlog_errno(ret); 706 goto out_commit; 707 } 708 709 ret = ocfs2_journal_access_rb(handle, &ref_tree->rf_ci, ref_root_bh, 710 OCFS2_JOURNAL_ACCESS_WRITE); 711 if (ret) { 712 mlog_errno(ret); 713 goto out_commit; 714 } 715 716 rb = (struct ocfs2_refcount_block *)ref_root_bh->b_data; 717 le32_add_cpu(&rb->rf_count, 1); 718 719 ocfs2_journal_dirty(handle, ref_root_bh); 720 721 spin_lock(&oi->ip_lock); 722 oi->ip_dyn_features |= OCFS2_HAS_REFCOUNT_FL; 723 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 724 di->i_refcount_loc = cpu_to_le64(refcount_loc); 725 spin_unlock(&oi->ip_lock); 726 ocfs2_journal_dirty(handle, di_bh); 727 728 out_commit: 729 ocfs2_commit_trans(osb, handle); 730 out: 731 ocfs2_unlock_refcount_tree(osb, ref_tree, 1); 732 brelse(ref_root_bh); 733 734 return ret; 735 } 736 737 int ocfs2_remove_refcount_tree(struct inode *inode, struct buffer_head *di_bh) 738 { 739 int ret, delete_tree = 0; 740 handle_t *handle = NULL; 741 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data; 742 struct ocfs2_inode_info *oi = OCFS2_I(inode); 743 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 744 struct ocfs2_refcount_block *rb; 745 struct inode *alloc_inode = NULL; 746 struct buffer_head *alloc_bh = NULL; 747 struct buffer_head *blk_bh = NULL; 748 struct ocfs2_refcount_tree *ref_tree; 749 int credits = OCFS2_REFCOUNT_TREE_REMOVE_CREDITS; 750 u64 blk = 0, bg_blkno = 0, ref_blkno = le64_to_cpu(di->i_refcount_loc); 751 u16 bit = 0; 752 753 if (!(oi->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL)) 754 return 0; 755 756 BUG_ON(!ref_blkno); 757 ret = ocfs2_lock_refcount_tree(osb, ref_blkno, 1, &ref_tree, &blk_bh); 758 if (ret) { 759 mlog_errno(ret); 760 return ret; 761 } 762 763 rb = (struct ocfs2_refcount_block *)blk_bh->b_data; 764 765 /* 766 * If we are the last user, we need to free the block. 767 * So lock the allocator ahead. 768 */ 769 if (le32_to_cpu(rb->rf_count) == 1) { 770 blk = le64_to_cpu(rb->rf_blkno); 771 bit = le16_to_cpu(rb->rf_suballoc_bit); 772 bg_blkno = ocfs2_which_suballoc_group(blk, bit); 773 774 alloc_inode = ocfs2_get_system_file_inode(osb, 775 EXTENT_ALLOC_SYSTEM_INODE, 776 le16_to_cpu(rb->rf_suballoc_slot)); 777 if (!alloc_inode) { 778 ret = -ENOMEM; 779 mlog_errno(ret); 780 goto out; 781 } 782 mutex_lock(&alloc_inode->i_mutex); 783 784 ret = ocfs2_inode_lock(alloc_inode, &alloc_bh, 1); 785 if (ret) { 786 mlog_errno(ret); 787 goto out_mutex; 788 } 789 790 credits += OCFS2_SUBALLOC_FREE; 791 } 792 793 handle = ocfs2_start_trans(osb, credits); 794 if (IS_ERR(handle)) { 795 ret = PTR_ERR(handle); 796 mlog_errno(ret); 797 goto out_unlock; 798 } 799 800 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh, 801 OCFS2_JOURNAL_ACCESS_WRITE); 802 if (ret) { 803 mlog_errno(ret); 804 goto out_commit; 805 } 806 807 ret = ocfs2_journal_access_rb(handle, &ref_tree->rf_ci, blk_bh, 808 OCFS2_JOURNAL_ACCESS_WRITE); 809 if (ret) { 810 mlog_errno(ret); 811 goto out_commit; 812 } 813 814 spin_lock(&oi->ip_lock); 815 oi->ip_dyn_features &= ~OCFS2_HAS_REFCOUNT_FL; 816 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features); 817 di->i_refcount_loc = 0; 818 spin_unlock(&oi->ip_lock); 819 ocfs2_journal_dirty(handle, di_bh); 820 821 le32_add_cpu(&rb->rf_count , -1); 822 ocfs2_journal_dirty(handle, blk_bh); 823 824 if (!rb->rf_count) { 825 delete_tree = 1; 826 ocfs2_erase_refcount_tree_from_list(osb, ref_tree); 827 ret = ocfs2_free_suballoc_bits(handle, alloc_inode, 828 alloc_bh, bit, bg_blkno, 1); 829 if (ret) 830 mlog_errno(ret); 831 } 832 833 out_commit: 834 ocfs2_commit_trans(osb, handle); 835 out_unlock: 836 if (alloc_inode) { 837 ocfs2_inode_unlock(alloc_inode, 1); 838 brelse(alloc_bh); 839 } 840 out_mutex: 841 if (alloc_inode) { 842 mutex_unlock(&alloc_inode->i_mutex); 843 iput(alloc_inode); 844 } 845 out: 846 ocfs2_unlock_refcount_tree(osb, ref_tree, 1); 847 if (delete_tree) 848 ocfs2_refcount_tree_put(ref_tree); 849 brelse(blk_bh); 850 851 return ret; 852 } 853 854 static void ocfs2_find_refcount_rec_in_rl(struct ocfs2_caching_info *ci, 855 struct buffer_head *ref_leaf_bh, 856 u64 cpos, unsigned int len, 857 struct ocfs2_refcount_rec *ret_rec, 858 int *index) 859 { 860 int i = 0; 861 struct ocfs2_refcount_block *rb = 862 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data; 863 struct ocfs2_refcount_rec *rec = NULL; 864 865 for (; i < le16_to_cpu(rb->rf_records.rl_used); i++) { 866 rec = &rb->rf_records.rl_recs[i]; 867 868 if (le64_to_cpu(rec->r_cpos) + 869 le32_to_cpu(rec->r_clusters) <= cpos) 870 continue; 871 else if (le64_to_cpu(rec->r_cpos) > cpos) 872 break; 873 874 /* ok, cpos fail in this rec. Just return. */ 875 if (ret_rec) 876 *ret_rec = *rec; 877 goto out; 878 } 879 880 if (ret_rec) { 881 /* We meet with a hole here, so fake the rec. */ 882 ret_rec->r_cpos = cpu_to_le64(cpos); 883 ret_rec->r_refcount = 0; 884 if (i < le16_to_cpu(rb->rf_records.rl_used) && 885 le64_to_cpu(rec->r_cpos) < cpos + len) 886 ret_rec->r_clusters = 887 cpu_to_le32(le64_to_cpu(rec->r_cpos) - cpos); 888 else 889 ret_rec->r_clusters = cpu_to_le32(len); 890 } 891 892 out: 893 *index = i; 894 } 895 896 /* 897 * Given a cpos and len, try to find the refcount record which contains cpos. 898 * 1. If cpos can be found in one refcount record, return the record. 899 * 2. If cpos can't be found, return a fake record which start from cpos 900 * and end at a small value between cpos+len and start of the next record. 901 * This fake record has r_refcount = 0. 902 */ 903 static int ocfs2_get_refcount_rec(struct ocfs2_caching_info *ci, 904 struct buffer_head *ref_root_bh, 905 u64 cpos, unsigned int len, 906 struct ocfs2_refcount_rec *ret_rec, 907 int *index, 908 struct buffer_head **ret_bh) 909 { 910 int ret = 0, i, found; 911 u32 low_cpos; 912 struct ocfs2_extent_list *el; 913 struct ocfs2_extent_rec *tmp, *rec = NULL; 914 struct ocfs2_extent_block *eb; 915 struct buffer_head *eb_bh = NULL, *ref_leaf_bh = NULL; 916 struct super_block *sb = ocfs2_metadata_cache_get_super(ci); 917 struct ocfs2_refcount_block *rb = 918 (struct ocfs2_refcount_block *)ref_root_bh->b_data; 919 920 if (!(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)) { 921 ocfs2_find_refcount_rec_in_rl(ci, ref_root_bh, cpos, len, 922 ret_rec, index); 923 *ret_bh = ref_root_bh; 924 get_bh(ref_root_bh); 925 return 0; 926 } 927 928 el = &rb->rf_list; 929 low_cpos = cpos & OCFS2_32BIT_POS_MASK; 930 931 if (el->l_tree_depth) { 932 ret = ocfs2_find_leaf(ci, el, low_cpos, &eb_bh); 933 if (ret) { 934 mlog_errno(ret); 935 goto out; 936 } 937 938 eb = (struct ocfs2_extent_block *) eb_bh->b_data; 939 el = &eb->h_list; 940 941 if (el->l_tree_depth) { 942 ocfs2_error(sb, 943 "refcount tree %llu has non zero tree " 944 "depth in leaf btree tree block %llu\n", 945 (unsigned long long)ocfs2_metadata_cache_owner(ci), 946 (unsigned long long)eb_bh->b_blocknr); 947 ret = -EROFS; 948 goto out; 949 } 950 } 951 952 found = 0; 953 for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) { 954 rec = &el->l_recs[i]; 955 956 if (le32_to_cpu(rec->e_cpos) <= low_cpos) { 957 found = 1; 958 break; 959 } 960 } 961 962 /* adjust len when we have ocfs2_extent_rec after it. */ 963 if (found && i < le16_to_cpu(el->l_next_free_rec) - 1) { 964 tmp = &el->l_recs[i+1]; 965 966 if (le32_to_cpu(tmp->e_cpos) < cpos + len) 967 len = le32_to_cpu(tmp->e_cpos) - cpos; 968 } 969 970 ret = ocfs2_read_refcount_block(ci, le64_to_cpu(rec->e_blkno), 971 &ref_leaf_bh); 972 if (ret) { 973 mlog_errno(ret); 974 goto out; 975 } 976 977 ocfs2_find_refcount_rec_in_rl(ci, ref_leaf_bh, cpos, len, 978 ret_rec, index); 979 *ret_bh = ref_leaf_bh; 980 out: 981 brelse(eb_bh); 982 return ret; 983 } 984 985 enum ocfs2_ref_rec_contig { 986 REF_CONTIG_NONE = 0, 987 REF_CONTIG_LEFT, 988 REF_CONTIG_RIGHT, 989 REF_CONTIG_LEFTRIGHT, 990 }; 991 992 static enum ocfs2_ref_rec_contig 993 ocfs2_refcount_rec_adjacent(struct ocfs2_refcount_block *rb, 994 int index) 995 { 996 if ((rb->rf_records.rl_recs[index].r_refcount == 997 rb->rf_records.rl_recs[index + 1].r_refcount) && 998 (le64_to_cpu(rb->rf_records.rl_recs[index].r_cpos) + 999 le32_to_cpu(rb->rf_records.rl_recs[index].r_clusters) == 1000 le64_to_cpu(rb->rf_records.rl_recs[index + 1].r_cpos))) 1001 return REF_CONTIG_RIGHT; 1002 1003 return REF_CONTIG_NONE; 1004 } 1005 1006 static enum ocfs2_ref_rec_contig 1007 ocfs2_refcount_rec_contig(struct ocfs2_refcount_block *rb, 1008 int index) 1009 { 1010 enum ocfs2_ref_rec_contig ret = REF_CONTIG_NONE; 1011 1012 if (index < le16_to_cpu(rb->rf_records.rl_used) - 1) 1013 ret = ocfs2_refcount_rec_adjacent(rb, index); 1014 1015 if (index > 0) { 1016 enum ocfs2_ref_rec_contig tmp; 1017 1018 tmp = ocfs2_refcount_rec_adjacent(rb, index - 1); 1019 1020 if (tmp == REF_CONTIG_RIGHT) { 1021 if (ret == REF_CONTIG_RIGHT) 1022 ret = REF_CONTIG_LEFTRIGHT; 1023 else 1024 ret = REF_CONTIG_LEFT; 1025 } 1026 } 1027 1028 return ret; 1029 } 1030 1031 static void ocfs2_rotate_refcount_rec_left(struct ocfs2_refcount_block *rb, 1032 int index) 1033 { 1034 BUG_ON(rb->rf_records.rl_recs[index].r_refcount != 1035 rb->rf_records.rl_recs[index+1].r_refcount); 1036 1037 le32_add_cpu(&rb->rf_records.rl_recs[index].r_clusters, 1038 le32_to_cpu(rb->rf_records.rl_recs[index+1].r_clusters)); 1039 1040 if (index < le16_to_cpu(rb->rf_records.rl_used) - 2) 1041 memmove(&rb->rf_records.rl_recs[index + 1], 1042 &rb->rf_records.rl_recs[index + 2], 1043 sizeof(struct ocfs2_refcount_rec) * 1044 (le16_to_cpu(rb->rf_records.rl_used) - index - 2)); 1045 1046 memset(&rb->rf_records.rl_recs[le16_to_cpu(rb->rf_records.rl_used) - 1], 1047 0, sizeof(struct ocfs2_refcount_rec)); 1048 le16_add_cpu(&rb->rf_records.rl_used, -1); 1049 } 1050 1051 /* 1052 * Merge the refcount rec if we are contiguous with the adjacent recs. 1053 */ 1054 static void ocfs2_refcount_rec_merge(struct ocfs2_refcount_block *rb, 1055 int index) 1056 { 1057 enum ocfs2_ref_rec_contig contig = 1058 ocfs2_refcount_rec_contig(rb, index); 1059 1060 if (contig == REF_CONTIG_NONE) 1061 return; 1062 1063 if (contig == REF_CONTIG_LEFT || contig == REF_CONTIG_LEFTRIGHT) { 1064 BUG_ON(index == 0); 1065 index--; 1066 } 1067 1068 ocfs2_rotate_refcount_rec_left(rb, index); 1069 1070 if (contig == REF_CONTIG_LEFTRIGHT) 1071 ocfs2_rotate_refcount_rec_left(rb, index); 1072 } 1073 1074 static int ocfs2_change_refcount_rec(handle_t *handle, 1075 struct ocfs2_caching_info *ci, 1076 struct buffer_head *ref_leaf_bh, 1077 int index, int change) 1078 { 1079 int ret; 1080 struct ocfs2_refcount_block *rb = 1081 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data; 1082 struct ocfs2_refcount_rec *rec = &rb->rf_records.rl_recs[index]; 1083 1084 ret = ocfs2_journal_access_rb(handle, ci, ref_leaf_bh, 1085 OCFS2_JOURNAL_ACCESS_WRITE); 1086 if (ret) { 1087 mlog_errno(ret); 1088 goto out; 1089 } 1090 1091 mlog(0, "change index %d, old count %u, change %d\n", index, 1092 le32_to_cpu(rec->r_refcount), change); 1093 le32_add_cpu(&rec->r_refcount, change); 1094 1095 ocfs2_refcount_rec_merge(rb, index); 1096 1097 ret = ocfs2_journal_dirty(handle, ref_leaf_bh); 1098 if (ret) 1099 mlog_errno(ret); 1100 out: 1101 return ret; 1102 } 1103 1104 static int ocfs2_expand_inline_ref_root(handle_t *handle, 1105 struct ocfs2_caching_info *ci, 1106 struct buffer_head *ref_root_bh, 1107 struct buffer_head **ref_leaf_bh, 1108 struct ocfs2_alloc_context *meta_ac) 1109 { 1110 int ret; 1111 u16 suballoc_bit_start; 1112 u32 num_got; 1113 u64 blkno; 1114 struct super_block *sb = ocfs2_metadata_cache_get_super(ci); 1115 struct buffer_head *new_bh = NULL; 1116 struct ocfs2_refcount_block *new_rb; 1117 struct ocfs2_refcount_block *root_rb = 1118 (struct ocfs2_refcount_block *)ref_root_bh->b_data; 1119 1120 ret = ocfs2_journal_access_rb(handle, ci, ref_root_bh, 1121 OCFS2_JOURNAL_ACCESS_WRITE); 1122 if (ret) { 1123 mlog_errno(ret); 1124 goto out; 1125 } 1126 1127 ret = ocfs2_claim_metadata(OCFS2_SB(sb), handle, meta_ac, 1, 1128 &suballoc_bit_start, &num_got, 1129 &blkno); 1130 if (ret) { 1131 mlog_errno(ret); 1132 goto out; 1133 } 1134 1135 new_bh = sb_getblk(sb, blkno); 1136 if (new_bh == NULL) { 1137 ret = -EIO; 1138 mlog_errno(ret); 1139 goto out; 1140 } 1141 ocfs2_set_new_buffer_uptodate(ci, new_bh); 1142 1143 ret = ocfs2_journal_access_rb(handle, ci, new_bh, 1144 OCFS2_JOURNAL_ACCESS_CREATE); 1145 if (ret) { 1146 mlog_errno(ret); 1147 goto out; 1148 } 1149 1150 /* 1151 * Initialize ocfs2_refcount_block. 1152 * It should contain the same information as the old root. 1153 * so just memcpy it and change the corresponding field. 1154 */ 1155 memcpy(new_bh->b_data, ref_root_bh->b_data, sb->s_blocksize); 1156 1157 new_rb = (struct ocfs2_refcount_block *)new_bh->b_data; 1158 new_rb->rf_suballoc_slot = cpu_to_le16(OCFS2_SB(sb)->slot_num); 1159 new_rb->rf_suballoc_bit = cpu_to_le16(suballoc_bit_start); 1160 new_rb->rf_blkno = cpu_to_le64(blkno); 1161 new_rb->rf_cpos = cpu_to_le32(0); 1162 new_rb->rf_parent = cpu_to_le64(ref_root_bh->b_blocknr); 1163 new_rb->rf_flags = cpu_to_le32(OCFS2_REFCOUNT_LEAF_FL); 1164 ocfs2_journal_dirty(handle, new_bh); 1165 1166 /* Now change the root. */ 1167 memset(&root_rb->rf_list, 0, sb->s_blocksize - 1168 offsetof(struct ocfs2_refcount_block, rf_list)); 1169 root_rb->rf_list.l_count = cpu_to_le16(ocfs2_extent_recs_per_rb(sb)); 1170 root_rb->rf_clusters = cpu_to_le32(1); 1171 root_rb->rf_list.l_next_free_rec = cpu_to_le16(1); 1172 root_rb->rf_list.l_recs[0].e_blkno = cpu_to_le64(blkno); 1173 root_rb->rf_list.l_recs[0].e_leaf_clusters = cpu_to_le16(1); 1174 root_rb->rf_flags = cpu_to_le32(OCFS2_REFCOUNT_TREE_FL); 1175 1176 ocfs2_journal_dirty(handle, ref_root_bh); 1177 1178 mlog(0, "new leaf block %llu, used %u\n", (unsigned long long)blkno, 1179 le16_to_cpu(new_rb->rf_records.rl_used)); 1180 1181 *ref_leaf_bh = new_bh; 1182 new_bh = NULL; 1183 out: 1184 brelse(new_bh); 1185 return ret; 1186 } 1187 1188 static int ocfs2_refcount_rec_no_intersect(struct ocfs2_refcount_rec *prev, 1189 struct ocfs2_refcount_rec *next) 1190 { 1191 if (ocfs2_get_ref_rec_low_cpos(prev) + le32_to_cpu(prev->r_clusters) <= 1192 ocfs2_get_ref_rec_low_cpos(next)) 1193 return 1; 1194 1195 return 0; 1196 } 1197 1198 static int cmp_refcount_rec_by_low_cpos(const void *a, const void *b) 1199 { 1200 const struct ocfs2_refcount_rec *l = a, *r = b; 1201 u32 l_cpos = ocfs2_get_ref_rec_low_cpos(l); 1202 u32 r_cpos = ocfs2_get_ref_rec_low_cpos(r); 1203 1204 if (l_cpos > r_cpos) 1205 return 1; 1206 if (l_cpos < r_cpos) 1207 return -1; 1208 return 0; 1209 } 1210 1211 static int cmp_refcount_rec_by_cpos(const void *a, const void *b) 1212 { 1213 const struct ocfs2_refcount_rec *l = a, *r = b; 1214 u64 l_cpos = le64_to_cpu(l->r_cpos); 1215 u64 r_cpos = le64_to_cpu(r->r_cpos); 1216 1217 if (l_cpos > r_cpos) 1218 return 1; 1219 if (l_cpos < r_cpos) 1220 return -1; 1221 return 0; 1222 } 1223 1224 static void swap_refcount_rec(void *a, void *b, int size) 1225 { 1226 struct ocfs2_refcount_rec *l = a, *r = b, tmp; 1227 1228 tmp = *(struct ocfs2_refcount_rec *)l; 1229 *(struct ocfs2_refcount_rec *)l = 1230 *(struct ocfs2_refcount_rec *)r; 1231 *(struct ocfs2_refcount_rec *)r = tmp; 1232 } 1233 1234 /* 1235 * The refcount cpos are ordered by their 64bit cpos, 1236 * But we will use the low 32 bit to be the e_cpos in the b-tree. 1237 * So we need to make sure that this pos isn't intersected with others. 1238 * 1239 * Note: The refcount block is already sorted by their low 32 bit cpos, 1240 * So just try the middle pos first, and we will exit when we find 1241 * the good position. 1242 */ 1243 static int ocfs2_find_refcount_split_pos(struct ocfs2_refcount_list *rl, 1244 u32 *split_pos, int *split_index) 1245 { 1246 int num_used = le16_to_cpu(rl->rl_used); 1247 int delta, middle = num_used / 2; 1248 1249 for (delta = 0; delta < middle; delta++) { 1250 /* Let's check delta earlier than middle */ 1251 if (ocfs2_refcount_rec_no_intersect( 1252 &rl->rl_recs[middle - delta - 1], 1253 &rl->rl_recs[middle - delta])) { 1254 *split_index = middle - delta; 1255 break; 1256 } 1257 1258 /* For even counts, don't walk off the end */ 1259 if ((middle + delta + 1) == num_used) 1260 continue; 1261 1262 /* Now try delta past middle */ 1263 if (ocfs2_refcount_rec_no_intersect( 1264 &rl->rl_recs[middle + delta], 1265 &rl->rl_recs[middle + delta + 1])) { 1266 *split_index = middle + delta + 1; 1267 break; 1268 } 1269 } 1270 1271 if (delta >= middle) 1272 return -ENOSPC; 1273 1274 *split_pos = ocfs2_get_ref_rec_low_cpos(&rl->rl_recs[*split_index]); 1275 return 0; 1276 } 1277 1278 static int ocfs2_divide_leaf_refcount_block(struct buffer_head *ref_leaf_bh, 1279 struct buffer_head *new_bh, 1280 u32 *split_cpos) 1281 { 1282 int split_index = 0, num_moved, ret; 1283 u32 cpos = 0; 1284 struct ocfs2_refcount_block *rb = 1285 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data; 1286 struct ocfs2_refcount_list *rl = &rb->rf_records; 1287 struct ocfs2_refcount_block *new_rb = 1288 (struct ocfs2_refcount_block *)new_bh->b_data; 1289 struct ocfs2_refcount_list *new_rl = &new_rb->rf_records; 1290 1291 mlog(0, "split old leaf refcount block %llu, count = %u, used = %u\n", 1292 (unsigned long long)ref_leaf_bh->b_blocknr, 1293 le32_to_cpu(rl->rl_count), le32_to_cpu(rl->rl_used)); 1294 1295 /* 1296 * XXX: Improvement later. 1297 * If we know all the high 32 bit cpos is the same, no need to sort. 1298 * 1299 * In order to make the whole process safe, we do: 1300 * 1. sort the entries by their low 32 bit cpos first so that we can 1301 * find the split cpos easily. 1302 * 2. call ocfs2_insert_extent to insert the new refcount block. 1303 * 3. move the refcount rec to the new block. 1304 * 4. sort the entries by their 64 bit cpos. 1305 * 5. dirty the new_rb and rb. 1306 */ 1307 sort(&rl->rl_recs, le16_to_cpu(rl->rl_used), 1308 sizeof(struct ocfs2_refcount_rec), 1309 cmp_refcount_rec_by_low_cpos, swap_refcount_rec); 1310 1311 ret = ocfs2_find_refcount_split_pos(rl, &cpos, &split_index); 1312 if (ret) { 1313 mlog_errno(ret); 1314 return ret; 1315 } 1316 1317 new_rb->rf_cpos = cpu_to_le32(cpos); 1318 1319 /* move refcount records starting from split_index to the new block. */ 1320 num_moved = le16_to_cpu(rl->rl_used) - split_index; 1321 memcpy(new_rl->rl_recs, &rl->rl_recs[split_index], 1322 num_moved * sizeof(struct ocfs2_refcount_rec)); 1323 1324 /*ok, remove the entries we just moved over to the other block. */ 1325 memset(&rl->rl_recs[split_index], 0, 1326 num_moved * sizeof(struct ocfs2_refcount_rec)); 1327 1328 /* change old and new rl_used accordingly. */ 1329 le16_add_cpu(&rl->rl_used, -num_moved); 1330 new_rl->rl_used = cpu_to_le32(num_moved); 1331 1332 sort(&rl->rl_recs, le16_to_cpu(rl->rl_used), 1333 sizeof(struct ocfs2_refcount_rec), 1334 cmp_refcount_rec_by_cpos, swap_refcount_rec); 1335 1336 sort(&new_rl->rl_recs, le16_to_cpu(new_rl->rl_used), 1337 sizeof(struct ocfs2_refcount_rec), 1338 cmp_refcount_rec_by_cpos, swap_refcount_rec); 1339 1340 *split_cpos = cpos; 1341 return 0; 1342 } 1343 1344 static int ocfs2_new_leaf_refcount_block(handle_t *handle, 1345 struct ocfs2_caching_info *ci, 1346 struct buffer_head *ref_root_bh, 1347 struct buffer_head *ref_leaf_bh, 1348 struct ocfs2_alloc_context *meta_ac) 1349 { 1350 int ret; 1351 u16 suballoc_bit_start; 1352 u32 num_got, new_cpos; 1353 u64 blkno; 1354 struct super_block *sb = ocfs2_metadata_cache_get_super(ci); 1355 struct ocfs2_refcount_block *root_rb = 1356 (struct ocfs2_refcount_block *)ref_root_bh->b_data; 1357 struct buffer_head *new_bh = NULL; 1358 struct ocfs2_refcount_block *new_rb; 1359 struct ocfs2_extent_tree ref_et; 1360 1361 BUG_ON(!(le32_to_cpu(root_rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)); 1362 1363 ret = ocfs2_journal_access_rb(handle, ci, ref_root_bh, 1364 OCFS2_JOURNAL_ACCESS_WRITE); 1365 if (ret) { 1366 mlog_errno(ret); 1367 goto out; 1368 } 1369 1370 ret = ocfs2_journal_access_rb(handle, ci, ref_leaf_bh, 1371 OCFS2_JOURNAL_ACCESS_WRITE); 1372 if (ret) { 1373 mlog_errno(ret); 1374 goto out; 1375 } 1376 1377 ret = ocfs2_claim_metadata(OCFS2_SB(sb), handle, meta_ac, 1, 1378 &suballoc_bit_start, &num_got, 1379 &blkno); 1380 if (ret) { 1381 mlog_errno(ret); 1382 goto out; 1383 } 1384 1385 new_bh = sb_getblk(sb, blkno); 1386 if (new_bh == NULL) { 1387 ret = -EIO; 1388 mlog_errno(ret); 1389 goto out; 1390 } 1391 ocfs2_set_new_buffer_uptodate(ci, new_bh); 1392 1393 ret = ocfs2_journal_access_rb(handle, ci, new_bh, 1394 OCFS2_JOURNAL_ACCESS_CREATE); 1395 if (ret) { 1396 mlog_errno(ret); 1397 goto out; 1398 } 1399 1400 /* Initialize ocfs2_refcount_block. */ 1401 new_rb = (struct ocfs2_refcount_block *)new_bh->b_data; 1402 memset(new_rb, 0, sb->s_blocksize); 1403 strcpy((void *)new_rb, OCFS2_REFCOUNT_BLOCK_SIGNATURE); 1404 new_rb->rf_suballoc_slot = cpu_to_le16(OCFS2_SB(sb)->slot_num); 1405 new_rb->rf_suballoc_bit = cpu_to_le16(suballoc_bit_start); 1406 new_rb->rf_fs_generation = cpu_to_le32(OCFS2_SB(sb)->fs_generation); 1407 new_rb->rf_blkno = cpu_to_le64(blkno); 1408 new_rb->rf_parent = cpu_to_le64(ref_root_bh->b_blocknr); 1409 new_rb->rf_flags = cpu_to_le32(OCFS2_REFCOUNT_LEAF_FL); 1410 new_rb->rf_records.rl_count = 1411 cpu_to_le16(ocfs2_refcount_recs_per_rb(sb)); 1412 new_rb->rf_generation = root_rb->rf_generation; 1413 1414 ret = ocfs2_divide_leaf_refcount_block(ref_leaf_bh, new_bh, &new_cpos); 1415 if (ret) { 1416 mlog_errno(ret); 1417 goto out; 1418 } 1419 1420 ocfs2_journal_dirty(handle, ref_leaf_bh); 1421 ocfs2_journal_dirty(handle, new_bh); 1422 1423 ocfs2_init_refcount_extent_tree(&ref_et, ci, ref_root_bh); 1424 1425 mlog(0, "insert new leaf block %llu at %u\n", 1426 (unsigned long long)new_bh->b_blocknr, new_cpos); 1427 1428 /* Insert the new leaf block with the specific offset cpos. */ 1429 ret = ocfs2_insert_extent(handle, &ref_et, new_cpos, new_bh->b_blocknr, 1430 1, 0, meta_ac); 1431 if (ret) 1432 mlog_errno(ret); 1433 1434 out: 1435 brelse(new_bh); 1436 return ret; 1437 } 1438 1439 static int ocfs2_expand_refcount_tree(handle_t *handle, 1440 struct ocfs2_caching_info *ci, 1441 struct buffer_head *ref_root_bh, 1442 struct buffer_head *ref_leaf_bh, 1443 struct ocfs2_alloc_context *meta_ac) 1444 { 1445 int ret; 1446 struct buffer_head *expand_bh = NULL; 1447 1448 if (ref_root_bh == ref_leaf_bh) { 1449 /* 1450 * the old root bh hasn't been expanded to a b-tree, 1451 * so expand it first. 1452 */ 1453 ret = ocfs2_expand_inline_ref_root(handle, ci, ref_root_bh, 1454 &expand_bh, meta_ac); 1455 if (ret) { 1456 mlog_errno(ret); 1457 goto out; 1458 } 1459 } else { 1460 expand_bh = ref_leaf_bh; 1461 get_bh(expand_bh); 1462 } 1463 1464 1465 /* Now add a new refcount block into the tree.*/ 1466 ret = ocfs2_new_leaf_refcount_block(handle, ci, ref_root_bh, 1467 expand_bh, meta_ac); 1468 if (ret) 1469 mlog_errno(ret); 1470 out: 1471 brelse(expand_bh); 1472 return ret; 1473 } 1474 1475 /* 1476 * Adjust the extent rec in b-tree representing ref_leaf_bh. 1477 * 1478 * Only called when we have inserted a new refcount rec at index 0 1479 * which means ocfs2_extent_rec.e_cpos may need some change. 1480 */ 1481 static int ocfs2_adjust_refcount_rec(handle_t *handle, 1482 struct ocfs2_caching_info *ci, 1483 struct buffer_head *ref_root_bh, 1484 struct buffer_head *ref_leaf_bh, 1485 struct ocfs2_refcount_rec *rec) 1486 { 1487 int ret = 0, i; 1488 u32 new_cpos, old_cpos; 1489 struct ocfs2_path *path = NULL; 1490 struct ocfs2_extent_tree et; 1491 struct ocfs2_refcount_block *rb = 1492 (struct ocfs2_refcount_block *)ref_root_bh->b_data; 1493 struct ocfs2_extent_list *el; 1494 1495 if (!(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL)) 1496 goto out; 1497 1498 rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data; 1499 old_cpos = le32_to_cpu(rb->rf_cpos); 1500 new_cpos = le64_to_cpu(rec->r_cpos) & OCFS2_32BIT_POS_MASK; 1501 if (old_cpos <= new_cpos) 1502 goto out; 1503 1504 ocfs2_init_refcount_extent_tree(&et, ci, ref_root_bh); 1505 1506 path = ocfs2_new_path_from_et(&et); 1507 if (!path) { 1508 ret = -ENOMEM; 1509 mlog_errno(ret); 1510 goto out; 1511 } 1512 1513 ret = ocfs2_find_path(ci, path, old_cpos); 1514 if (ret) { 1515 mlog_errno(ret); 1516 goto out; 1517 } 1518 1519 /* 1520 * 2 more credits, one for the leaf refcount block, one for 1521 * the extent block contains the extent rec. 1522 */ 1523 ret = ocfs2_extend_trans(handle, handle->h_buffer_credits + 2); 1524 if (ret < 0) { 1525 mlog_errno(ret); 1526 goto out; 1527 } 1528 1529 ret = ocfs2_journal_access_rb(handle, ci, ref_leaf_bh, 1530 OCFS2_JOURNAL_ACCESS_WRITE); 1531 if (ret < 0) { 1532 mlog_errno(ret); 1533 goto out; 1534 } 1535 1536 ret = ocfs2_journal_access_eb(handle, ci, path_leaf_bh(path), 1537 OCFS2_JOURNAL_ACCESS_WRITE); 1538 if (ret < 0) { 1539 mlog_errno(ret); 1540 goto out; 1541 } 1542 1543 /* change the leaf extent block first. */ 1544 el = path_leaf_el(path); 1545 1546 for (i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) 1547 if (le32_to_cpu(el->l_recs[i].e_cpos) == old_cpos) 1548 break; 1549 1550 BUG_ON(i == le16_to_cpu(el->l_next_free_rec)); 1551 1552 el->l_recs[i].e_cpos = cpu_to_le32(new_cpos); 1553 1554 /* change the r_cpos in the leaf block. */ 1555 rb->rf_cpos = cpu_to_le32(new_cpos); 1556 1557 ocfs2_journal_dirty(handle, path_leaf_bh(path)); 1558 ocfs2_journal_dirty(handle, ref_leaf_bh); 1559 1560 out: 1561 ocfs2_free_path(path); 1562 return ret; 1563 } 1564 1565 static int ocfs2_insert_refcount_rec(handle_t *handle, 1566 struct ocfs2_caching_info *ci, 1567 struct buffer_head *ref_root_bh, 1568 struct buffer_head *ref_leaf_bh, 1569 struct ocfs2_refcount_rec *rec, 1570 int index, 1571 struct ocfs2_alloc_context *meta_ac) 1572 { 1573 int ret; 1574 struct ocfs2_refcount_block *rb = 1575 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data; 1576 struct ocfs2_refcount_list *rf_list = &rb->rf_records; 1577 struct buffer_head *new_bh = NULL; 1578 1579 BUG_ON(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL); 1580 1581 if (rf_list->rl_used == rf_list->rl_count) { 1582 u64 cpos = le64_to_cpu(rec->r_cpos); 1583 u32 len = le32_to_cpu(rec->r_clusters); 1584 1585 ret = ocfs2_expand_refcount_tree(handle, ci, ref_root_bh, 1586 ref_leaf_bh, meta_ac); 1587 if (ret) { 1588 mlog_errno(ret); 1589 goto out; 1590 } 1591 1592 ret = ocfs2_get_refcount_rec(ci, ref_root_bh, 1593 cpos, len, NULL, &index, 1594 &new_bh); 1595 if (ret) { 1596 mlog_errno(ret); 1597 goto out; 1598 } 1599 1600 ref_leaf_bh = new_bh; 1601 rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data; 1602 rf_list = &rb->rf_records; 1603 } 1604 1605 ret = ocfs2_journal_access_rb(handle, ci, ref_leaf_bh, 1606 OCFS2_JOURNAL_ACCESS_WRITE); 1607 if (ret) { 1608 mlog_errno(ret); 1609 goto out; 1610 } 1611 1612 if (index < le16_to_cpu(rf_list->rl_used)) 1613 memmove(&rf_list->rl_recs[index + 1], 1614 &rf_list->rl_recs[index], 1615 (le16_to_cpu(rf_list->rl_used) - index) * 1616 sizeof(struct ocfs2_refcount_rec)); 1617 1618 mlog(0, "insert refcount record start %llu, len %u, count %u " 1619 "to leaf block %llu at index %d\n", 1620 (unsigned long long)le64_to_cpu(rec->r_cpos), 1621 le32_to_cpu(rec->r_clusters), le32_to_cpu(rec->r_refcount), 1622 (unsigned long long)ref_leaf_bh->b_blocknr, index); 1623 1624 rf_list->rl_recs[index] = *rec; 1625 1626 le16_add_cpu(&rf_list->rl_used, 1); 1627 1628 ocfs2_refcount_rec_merge(rb, index); 1629 1630 ret = ocfs2_journal_dirty(handle, ref_leaf_bh); 1631 if (ret) { 1632 mlog_errno(ret); 1633 goto out; 1634 } 1635 1636 if (index == 0) { 1637 ret = ocfs2_adjust_refcount_rec(handle, ci, 1638 ref_root_bh, 1639 ref_leaf_bh, rec); 1640 if (ret) 1641 mlog_errno(ret); 1642 } 1643 out: 1644 brelse(new_bh); 1645 return ret; 1646 } 1647 1648 /* 1649 * Split the refcount_rec indexed by "index" in ref_leaf_bh. 1650 * This is much simple than our b-tree code. 1651 * split_rec is the new refcount rec we want to insert. 1652 * If split_rec->r_refcount > 0, we are changing the refcount(in case we 1653 * increase refcount or decrease a refcount to non-zero). 1654 * If split_rec->r_refcount == 0, we are punching a hole in current refcount 1655 * rec( in case we decrease a refcount to zero). 1656 */ 1657 static int ocfs2_split_refcount_rec(handle_t *handle, 1658 struct ocfs2_caching_info *ci, 1659 struct buffer_head *ref_root_bh, 1660 struct buffer_head *ref_leaf_bh, 1661 struct ocfs2_refcount_rec *split_rec, 1662 int index, 1663 struct ocfs2_alloc_context *meta_ac, 1664 struct ocfs2_cached_dealloc_ctxt *dealloc) 1665 { 1666 int ret, recs_need; 1667 u32 len; 1668 struct ocfs2_refcount_block *rb = 1669 (struct ocfs2_refcount_block *)ref_leaf_bh->b_data; 1670 struct ocfs2_refcount_list *rf_list = &rb->rf_records; 1671 struct ocfs2_refcount_rec *orig_rec = &rf_list->rl_recs[index]; 1672 struct ocfs2_refcount_rec *tail_rec = NULL; 1673 struct buffer_head *new_bh = NULL; 1674 1675 BUG_ON(le32_to_cpu(rb->rf_flags) & OCFS2_REFCOUNT_TREE_FL); 1676 1677 mlog(0, "original r_pos %llu, cluster %u, split %llu, cluster %u\n", 1678 le64_to_cpu(orig_rec->r_cpos), le32_to_cpu(orig_rec->r_clusters), 1679 le64_to_cpu(split_rec->r_cpos), 1680 le32_to_cpu(split_rec->r_clusters)); 1681 1682 /* 1683 * If we just need to split the header or tail clusters, 1684 * no more recs are needed, just split is OK. 1685 * Otherwise we at least need one new recs. 1686 */ 1687 if (!split_rec->r_refcount && 1688 (split_rec->r_cpos == orig_rec->r_cpos || 1689 le64_to_cpu(split_rec->r_cpos) + 1690 le32_to_cpu(split_rec->r_clusters) == 1691 le64_to_cpu(orig_rec->r_cpos) + le32_to_cpu(orig_rec->r_clusters))) 1692 recs_need = 0; 1693 else 1694 recs_need = 1; 1695 1696 /* 1697 * We need one more rec if we split in the middle and the new rec have 1698 * some refcount in it. 1699 */ 1700 if (split_rec->r_refcount && 1701 (split_rec->r_cpos != orig_rec->r_cpos && 1702 le64_to_cpu(split_rec->r_cpos) + 1703 le32_to_cpu(split_rec->r_clusters) != 1704 le64_to_cpu(orig_rec->r_cpos) + le32_to_cpu(orig_rec->r_clusters))) 1705 recs_need++; 1706 1707 /* If the leaf block don't have enough record, expand it. */ 1708 if (le16_to_cpu(rf_list->rl_used) + recs_need > rf_list->rl_count) { 1709 struct ocfs2_refcount_rec tmp_rec; 1710 u64 cpos = le64_to_cpu(orig_rec->r_cpos); 1711 len = le32_to_cpu(orig_rec->r_clusters); 1712 ret = ocfs2_expand_refcount_tree(handle, ci, ref_root_bh, 1713 ref_leaf_bh, meta_ac); 1714 if (ret) { 1715 mlog_errno(ret); 1716 goto out; 1717 } 1718 1719 /* 1720 * We have to re-get it since now cpos may be moved to 1721 * another leaf block. 1722 */ 1723 ret = ocfs2_get_refcount_rec(ci, ref_root_bh, 1724 cpos, len, &tmp_rec, &index, 1725 &new_bh); 1726 if (ret) { 1727 mlog_errno(ret); 1728 goto out; 1729 } 1730 1731 ref_leaf_bh = new_bh; 1732 rb = (struct ocfs2_refcount_block *)ref_leaf_bh->b_data; 1733 rf_list = &rb->rf_records; 1734 orig_rec = &rf_list->rl_recs[index]; 1735 } 1736 1737 ret = ocfs2_journal_access_rb(handle, ci, ref_leaf_bh, 1738 OCFS2_JOURNAL_ACCESS_WRITE); 1739 if (ret) { 1740 mlog_errno(ret); 1741 goto out; 1742 } 1743 1744 /* 1745 * We have calculated out how many new records we need and store 1746 * in recs_need, so spare enough space first by moving the records 1747 * after "index" to the end. 1748 */ 1749 if (index != le16_to_cpu(rf_list->rl_used) - 1) 1750 memmove(&rf_list->rl_recs[index + 1 + recs_need], 1751 &rf_list->rl_recs[index + 1], 1752 (le16_to_cpu(rf_list->rl_used) - index - 1) * 1753 sizeof(struct ocfs2_refcount_rec)); 1754 1755 len = (le64_to_cpu(orig_rec->r_cpos) + 1756 le32_to_cpu(orig_rec->r_clusters)) - 1757 (le64_to_cpu(split_rec->r_cpos) + 1758 le32_to_cpu(split_rec->r_clusters)); 1759 1760 /* 1761 * If we have "len", the we will split in the tail and move it 1762 * to the end of the space we have just spared. 1763 */ 1764 if (len) { 1765 tail_rec = &rf_list->rl_recs[index + recs_need]; 1766 1767 memcpy(tail_rec, orig_rec, sizeof(struct ocfs2_refcount_rec)); 1768 le64_add_cpu(&tail_rec->r_cpos, 1769 le32_to_cpu(tail_rec->r_clusters) - len); 1770 tail_rec->r_clusters = le32_to_cpu(len); 1771 } 1772 1773 /* 1774 * If the split pos isn't the same as the original one, we need to 1775 * split in the head. 1776 * 1777 * Note: We have the chance that split_rec.r_refcount = 0, 1778 * recs_need = 0 and len > 0, which means we just cut the head from 1779 * the orig_rec and in that case we have done some modification in 1780 * orig_rec above, so the check for r_cpos is faked. 1781 */ 1782 if (split_rec->r_cpos != orig_rec->r_cpos && tail_rec != orig_rec) { 1783 len = le64_to_cpu(split_rec->r_cpos) - 1784 le64_to_cpu(orig_rec->r_cpos); 1785 orig_rec->r_clusters = cpu_to_le32(len); 1786 index++; 1787 } 1788 1789 le16_add_cpu(&rf_list->rl_used, recs_need); 1790 1791 if (split_rec->r_refcount) { 1792 rf_list->rl_recs[index] = *split_rec; 1793 mlog(0, "insert refcount record start %llu, len %u, count %u " 1794 "to leaf block %llu at index %d\n", 1795 (unsigned long long)le64_to_cpu(split_rec->r_cpos), 1796 le32_to_cpu(split_rec->r_clusters), 1797 le32_to_cpu(split_rec->r_refcount), 1798 (unsigned long long)ref_leaf_bh->b_blocknr, index); 1799 1800 ocfs2_refcount_rec_merge(rb, index); 1801 } 1802 1803 ret = ocfs2_journal_dirty(handle, ref_leaf_bh); 1804 if (ret) 1805 mlog_errno(ret); 1806 1807 out: 1808 brelse(new_bh); 1809 return ret; 1810 } 1811 1812 static int __ocfs2_increase_refcount(handle_t *handle, 1813 struct ocfs2_caching_info *ci, 1814 struct buffer_head *ref_root_bh, 1815 u64 cpos, u32 len, 1816 struct ocfs2_alloc_context *meta_ac, 1817 struct ocfs2_cached_dealloc_ctxt *dealloc) 1818 { 1819 int ret = 0, index; 1820 struct buffer_head *ref_leaf_bh = NULL; 1821 struct ocfs2_refcount_rec rec; 1822 unsigned int set_len = 0; 1823 1824 mlog(0, "Tree owner %llu, add refcount start %llu, len %u\n", 1825 (unsigned long long)ocfs2_metadata_cache_owner(ci), 1826 (unsigned long long)cpos, len); 1827 1828 while (len) { 1829 ret = ocfs2_get_refcount_rec(ci, ref_root_bh, 1830 cpos, len, &rec, &index, 1831 &ref_leaf_bh); 1832 if (ret) { 1833 mlog_errno(ret); 1834 goto out; 1835 } 1836 1837 set_len = le32_to_cpu(rec.r_clusters); 1838 1839 /* 1840 * Here we may meet with 3 situations: 1841 * 1842 * 1. If we find an already existing record, and the length 1843 * is the same, cool, we just need to increase the r_refcount 1844 * and it is OK. 1845 * 2. If we find a hole, just insert it with r_refcount = 1. 1846 * 3. If we are in the middle of one extent record, split 1847 * it. 1848 */ 1849 if (rec.r_refcount && le64_to_cpu(rec.r_cpos) == cpos && 1850 set_len <= len) { 1851 mlog(0, "increase refcount rec, start %llu, len %u, " 1852 "count %u\n", (unsigned long long)cpos, set_len, 1853 le32_to_cpu(rec.r_refcount)); 1854 ret = ocfs2_change_refcount_rec(handle, ci, 1855 ref_leaf_bh, index, 1); 1856 if (ret) { 1857 mlog_errno(ret); 1858 goto out; 1859 } 1860 } else if (!rec.r_refcount) { 1861 rec.r_refcount = cpu_to_le32(1); 1862 1863 mlog(0, "insert refcount rec, start %llu, len %u\n", 1864 (unsigned long long)le64_to_cpu(rec.r_cpos), 1865 set_len); 1866 ret = ocfs2_insert_refcount_rec(handle, ci, ref_root_bh, 1867 ref_leaf_bh, 1868 &rec, index, meta_ac); 1869 if (ret) { 1870 mlog_errno(ret); 1871 goto out; 1872 } 1873 } else { 1874 set_len = min((u64)(cpos + len), 1875 le64_to_cpu(rec.r_cpos) + set_len) - cpos; 1876 rec.r_cpos = cpu_to_le64(cpos); 1877 rec.r_clusters = cpu_to_le32(set_len); 1878 le32_add_cpu(&rec.r_refcount, 1); 1879 1880 mlog(0, "split refcount rec, start %llu, " 1881 "len %u, count %u\n", 1882 (unsigned long long)le64_to_cpu(rec.r_cpos), 1883 set_len, le32_to_cpu(rec.r_refcount)); 1884 ret = ocfs2_split_refcount_rec(handle, ci, 1885 ref_root_bh, ref_leaf_bh, 1886 &rec, index, 1887 meta_ac, dealloc); 1888 if (ret) { 1889 mlog_errno(ret); 1890 goto out; 1891 } 1892 } 1893 1894 cpos += set_len; 1895 len -= set_len; 1896 brelse(ref_leaf_bh); 1897 ref_leaf_bh = NULL; 1898 } 1899 1900 out: 1901 brelse(ref_leaf_bh); 1902 return ret; 1903 } 1904