1 /* 2 * Copyright (C) 2011 Fujitsu. All rights reserved. 3 * Written by Miao Xie <miaox@cn.fujitsu.com> 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public 7 * License v2 as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public 15 * License along with this program; if not, write to the 16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 17 * Boston, MA 021110-1307, USA. 18 */ 19 20 #include <linux/slab.h> 21 #include "delayed-inode.h" 22 #include "disk-io.h" 23 #include "transaction.h" 24 #include "ctree.h" 25 26 #define BTRFS_DELAYED_WRITEBACK 512 27 #define BTRFS_DELAYED_BACKGROUND 128 28 #define BTRFS_DELAYED_BATCH 16 29 30 static struct kmem_cache *delayed_node_cache; 31 32 int __init btrfs_delayed_inode_init(void) 33 { 34 delayed_node_cache = kmem_cache_create("btrfs_delayed_node", 35 sizeof(struct btrfs_delayed_node), 36 0, 37 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, 38 NULL); 39 if (!delayed_node_cache) 40 return -ENOMEM; 41 return 0; 42 } 43 44 void btrfs_delayed_inode_exit(void) 45 { 46 if (delayed_node_cache) 47 kmem_cache_destroy(delayed_node_cache); 48 } 49 50 static inline void btrfs_init_delayed_node( 51 struct btrfs_delayed_node *delayed_node, 52 struct btrfs_root *root, u64 inode_id) 53 { 54 delayed_node->root = root; 55 delayed_node->inode_id = inode_id; 56 atomic_set(&delayed_node->refs, 0); 57 delayed_node->count = 0; 58 delayed_node->flags = 0; 59 delayed_node->ins_root = RB_ROOT; 60 delayed_node->del_root = RB_ROOT; 61 mutex_init(&delayed_node->mutex); 62 delayed_node->index_cnt = 0; 63 INIT_LIST_HEAD(&delayed_node->n_list); 64 INIT_LIST_HEAD(&delayed_node->p_list); 65 delayed_node->bytes_reserved = 0; 66 memset(&delayed_node->inode_item, 0, sizeof(delayed_node->inode_item)); 67 } 68 69 static inline int btrfs_is_continuous_delayed_item( 70 struct btrfs_delayed_item *item1, 71 struct btrfs_delayed_item *item2) 72 { 73 if (item1->key.type == BTRFS_DIR_INDEX_KEY && 74 item1->key.objectid == item2->key.objectid && 75 item1->key.type == item2->key.type && 76 item1->key.offset + 1 == item2->key.offset) 77 return 1; 78 return 0; 79 } 80 81 static inline struct btrfs_delayed_root *btrfs_get_delayed_root( 82 struct btrfs_root *root) 83 { 84 return root->fs_info->delayed_root; 85 } 86 87 static struct btrfs_delayed_node *btrfs_get_delayed_node(struct inode *inode) 88 { 89 struct btrfs_inode *btrfs_inode = BTRFS_I(inode); 90 struct btrfs_root *root = btrfs_inode->root; 91 u64 ino = btrfs_ino(inode); 92 struct btrfs_delayed_node *node; 93 94 node = ACCESS_ONCE(btrfs_inode->delayed_node); 95 if (node) { 96 atomic_inc(&node->refs); 97 return node; 98 } 99 100 spin_lock(&root->inode_lock); 101 node = radix_tree_lookup(&root->delayed_nodes_tree, ino); 102 if (node) { 103 if (btrfs_inode->delayed_node) { 104 atomic_inc(&node->refs); /* can be accessed */ 105 BUG_ON(btrfs_inode->delayed_node != node); 106 spin_unlock(&root->inode_lock); 107 return node; 108 } 109 btrfs_inode->delayed_node = node; 110 /* can be accessed and cached in the inode */ 111 atomic_add(2, &node->refs); 112 spin_unlock(&root->inode_lock); 113 return node; 114 } 115 spin_unlock(&root->inode_lock); 116 117 return NULL; 118 } 119 120 /* Will return either the node or PTR_ERR(-ENOMEM) */ 121 static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node( 122 struct inode *inode) 123 { 124 struct btrfs_delayed_node *node; 125 struct btrfs_inode *btrfs_inode = BTRFS_I(inode); 126 struct btrfs_root *root = btrfs_inode->root; 127 u64 ino = btrfs_ino(inode); 128 int ret; 129 130 again: 131 node = btrfs_get_delayed_node(inode); 132 if (node) 133 return node; 134 135 node = kmem_cache_alloc(delayed_node_cache, GFP_NOFS); 136 if (!node) 137 return ERR_PTR(-ENOMEM); 138 btrfs_init_delayed_node(node, root, ino); 139 140 /* cached in the btrfs inode and can be accessed */ 141 atomic_add(2, &node->refs); 142 143 ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM); 144 if (ret) { 145 kmem_cache_free(delayed_node_cache, node); 146 return ERR_PTR(ret); 147 } 148 149 spin_lock(&root->inode_lock); 150 ret = radix_tree_insert(&root->delayed_nodes_tree, ino, node); 151 if (ret == -EEXIST) { 152 spin_unlock(&root->inode_lock); 153 kmem_cache_free(delayed_node_cache, node); 154 radix_tree_preload_end(); 155 goto again; 156 } 157 btrfs_inode->delayed_node = node; 158 spin_unlock(&root->inode_lock); 159 radix_tree_preload_end(); 160 161 return node; 162 } 163 164 /* 165 * Call it when holding delayed_node->mutex 166 * 167 * If mod = 1, add this node into the prepared list. 168 */ 169 static void btrfs_queue_delayed_node(struct btrfs_delayed_root *root, 170 struct btrfs_delayed_node *node, 171 int mod) 172 { 173 spin_lock(&root->lock); 174 if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { 175 if (!list_empty(&node->p_list)) 176 list_move_tail(&node->p_list, &root->prepare_list); 177 else if (mod) 178 list_add_tail(&node->p_list, &root->prepare_list); 179 } else { 180 list_add_tail(&node->n_list, &root->node_list); 181 list_add_tail(&node->p_list, &root->prepare_list); 182 atomic_inc(&node->refs); /* inserted into list */ 183 root->nodes++; 184 set_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags); 185 } 186 spin_unlock(&root->lock); 187 } 188 189 /* Call it when holding delayed_node->mutex */ 190 static void btrfs_dequeue_delayed_node(struct btrfs_delayed_root *root, 191 struct btrfs_delayed_node *node) 192 { 193 spin_lock(&root->lock); 194 if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { 195 root->nodes--; 196 atomic_dec(&node->refs); /* not in the list */ 197 list_del_init(&node->n_list); 198 if (!list_empty(&node->p_list)) 199 list_del_init(&node->p_list); 200 clear_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags); 201 } 202 spin_unlock(&root->lock); 203 } 204 205 static struct btrfs_delayed_node *btrfs_first_delayed_node( 206 struct btrfs_delayed_root *delayed_root) 207 { 208 struct list_head *p; 209 struct btrfs_delayed_node *node = NULL; 210 211 spin_lock(&delayed_root->lock); 212 if (list_empty(&delayed_root->node_list)) 213 goto out; 214 215 p = delayed_root->node_list.next; 216 node = list_entry(p, struct btrfs_delayed_node, n_list); 217 atomic_inc(&node->refs); 218 out: 219 spin_unlock(&delayed_root->lock); 220 221 return node; 222 } 223 224 static struct btrfs_delayed_node *btrfs_next_delayed_node( 225 struct btrfs_delayed_node *node) 226 { 227 struct btrfs_delayed_root *delayed_root; 228 struct list_head *p; 229 struct btrfs_delayed_node *next = NULL; 230 231 delayed_root = node->root->fs_info->delayed_root; 232 spin_lock(&delayed_root->lock); 233 if (!test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { 234 /* not in the list */ 235 if (list_empty(&delayed_root->node_list)) 236 goto out; 237 p = delayed_root->node_list.next; 238 } else if (list_is_last(&node->n_list, &delayed_root->node_list)) 239 goto out; 240 else 241 p = node->n_list.next; 242 243 next = list_entry(p, struct btrfs_delayed_node, n_list); 244 atomic_inc(&next->refs); 245 out: 246 spin_unlock(&delayed_root->lock); 247 248 return next; 249 } 250 251 static void __btrfs_release_delayed_node( 252 struct btrfs_delayed_node *delayed_node, 253 int mod) 254 { 255 struct btrfs_delayed_root *delayed_root; 256 257 if (!delayed_node) 258 return; 259 260 delayed_root = delayed_node->root->fs_info->delayed_root; 261 262 mutex_lock(&delayed_node->mutex); 263 if (delayed_node->count) 264 btrfs_queue_delayed_node(delayed_root, delayed_node, mod); 265 else 266 btrfs_dequeue_delayed_node(delayed_root, delayed_node); 267 mutex_unlock(&delayed_node->mutex); 268 269 if (atomic_dec_and_test(&delayed_node->refs)) { 270 bool free = false; 271 struct btrfs_root *root = delayed_node->root; 272 spin_lock(&root->inode_lock); 273 if (atomic_read(&delayed_node->refs) == 0) { 274 radix_tree_delete(&root->delayed_nodes_tree, 275 delayed_node->inode_id); 276 free = true; 277 } 278 spin_unlock(&root->inode_lock); 279 if (free) 280 kmem_cache_free(delayed_node_cache, delayed_node); 281 } 282 } 283 284 static inline void btrfs_release_delayed_node(struct btrfs_delayed_node *node) 285 { 286 __btrfs_release_delayed_node(node, 0); 287 } 288 289 static struct btrfs_delayed_node *btrfs_first_prepared_delayed_node( 290 struct btrfs_delayed_root *delayed_root) 291 { 292 struct list_head *p; 293 struct btrfs_delayed_node *node = NULL; 294 295 spin_lock(&delayed_root->lock); 296 if (list_empty(&delayed_root->prepare_list)) 297 goto out; 298 299 p = delayed_root->prepare_list.next; 300 list_del_init(p); 301 node = list_entry(p, struct btrfs_delayed_node, p_list); 302 atomic_inc(&node->refs); 303 out: 304 spin_unlock(&delayed_root->lock); 305 306 return node; 307 } 308 309 static inline void btrfs_release_prepared_delayed_node( 310 struct btrfs_delayed_node *node) 311 { 312 __btrfs_release_delayed_node(node, 1); 313 } 314 315 static struct btrfs_delayed_item *btrfs_alloc_delayed_item(u32 data_len) 316 { 317 struct btrfs_delayed_item *item; 318 item = kmalloc(sizeof(*item) + data_len, GFP_NOFS); 319 if (item) { 320 item->data_len = data_len; 321 item->ins_or_del = 0; 322 item->bytes_reserved = 0; 323 item->delayed_node = NULL; 324 atomic_set(&item->refs, 1); 325 } 326 return item; 327 } 328 329 /* 330 * __btrfs_lookup_delayed_item - look up the delayed item by key 331 * @delayed_node: pointer to the delayed node 332 * @key: the key to look up 333 * @prev: used to store the prev item if the right item isn't found 334 * @next: used to store the next item if the right item isn't found 335 * 336 * Note: if we don't find the right item, we will return the prev item and 337 * the next item. 338 */ 339 static struct btrfs_delayed_item *__btrfs_lookup_delayed_item( 340 struct rb_root *root, 341 struct btrfs_key *key, 342 struct btrfs_delayed_item **prev, 343 struct btrfs_delayed_item **next) 344 { 345 struct rb_node *node, *prev_node = NULL; 346 struct btrfs_delayed_item *delayed_item = NULL; 347 int ret = 0; 348 349 node = root->rb_node; 350 351 while (node) { 352 delayed_item = rb_entry(node, struct btrfs_delayed_item, 353 rb_node); 354 prev_node = node; 355 ret = btrfs_comp_cpu_keys(&delayed_item->key, key); 356 if (ret < 0) 357 node = node->rb_right; 358 else if (ret > 0) 359 node = node->rb_left; 360 else 361 return delayed_item; 362 } 363 364 if (prev) { 365 if (!prev_node) 366 *prev = NULL; 367 else if (ret < 0) 368 *prev = delayed_item; 369 else if ((node = rb_prev(prev_node)) != NULL) { 370 *prev = rb_entry(node, struct btrfs_delayed_item, 371 rb_node); 372 } else 373 *prev = NULL; 374 } 375 376 if (next) { 377 if (!prev_node) 378 *next = NULL; 379 else if (ret > 0) 380 *next = delayed_item; 381 else if ((node = rb_next(prev_node)) != NULL) { 382 *next = rb_entry(node, struct btrfs_delayed_item, 383 rb_node); 384 } else 385 *next = NULL; 386 } 387 return NULL; 388 } 389 390 static struct btrfs_delayed_item *__btrfs_lookup_delayed_insertion_item( 391 struct btrfs_delayed_node *delayed_node, 392 struct btrfs_key *key) 393 { 394 struct btrfs_delayed_item *item; 395 396 item = __btrfs_lookup_delayed_item(&delayed_node->ins_root, key, 397 NULL, NULL); 398 return item; 399 } 400 401 static int __btrfs_add_delayed_item(struct btrfs_delayed_node *delayed_node, 402 struct btrfs_delayed_item *ins, 403 int action) 404 { 405 struct rb_node **p, *node; 406 struct rb_node *parent_node = NULL; 407 struct rb_root *root; 408 struct btrfs_delayed_item *item; 409 int cmp; 410 411 if (action == BTRFS_DELAYED_INSERTION_ITEM) 412 root = &delayed_node->ins_root; 413 else if (action == BTRFS_DELAYED_DELETION_ITEM) 414 root = &delayed_node->del_root; 415 else 416 BUG(); 417 p = &root->rb_node; 418 node = &ins->rb_node; 419 420 while (*p) { 421 parent_node = *p; 422 item = rb_entry(parent_node, struct btrfs_delayed_item, 423 rb_node); 424 425 cmp = btrfs_comp_cpu_keys(&item->key, &ins->key); 426 if (cmp < 0) 427 p = &(*p)->rb_right; 428 else if (cmp > 0) 429 p = &(*p)->rb_left; 430 else 431 return -EEXIST; 432 } 433 434 rb_link_node(node, parent_node, p); 435 rb_insert_color(node, root); 436 ins->delayed_node = delayed_node; 437 ins->ins_or_del = action; 438 439 if (ins->key.type == BTRFS_DIR_INDEX_KEY && 440 action == BTRFS_DELAYED_INSERTION_ITEM && 441 ins->key.offset >= delayed_node->index_cnt) 442 delayed_node->index_cnt = ins->key.offset + 1; 443 444 delayed_node->count++; 445 atomic_inc(&delayed_node->root->fs_info->delayed_root->items); 446 return 0; 447 } 448 449 static int __btrfs_add_delayed_insertion_item(struct btrfs_delayed_node *node, 450 struct btrfs_delayed_item *item) 451 { 452 return __btrfs_add_delayed_item(node, item, 453 BTRFS_DELAYED_INSERTION_ITEM); 454 } 455 456 static int __btrfs_add_delayed_deletion_item(struct btrfs_delayed_node *node, 457 struct btrfs_delayed_item *item) 458 { 459 return __btrfs_add_delayed_item(node, item, 460 BTRFS_DELAYED_DELETION_ITEM); 461 } 462 463 static void finish_one_item(struct btrfs_delayed_root *delayed_root) 464 { 465 int seq = atomic_inc_return(&delayed_root->items_seq); 466 if ((atomic_dec_return(&delayed_root->items) < 467 BTRFS_DELAYED_BACKGROUND || seq % BTRFS_DELAYED_BATCH == 0) && 468 waitqueue_active(&delayed_root->wait)) 469 wake_up(&delayed_root->wait); 470 } 471 472 static void __btrfs_remove_delayed_item(struct btrfs_delayed_item *delayed_item) 473 { 474 struct rb_root *root; 475 struct btrfs_delayed_root *delayed_root; 476 477 delayed_root = delayed_item->delayed_node->root->fs_info->delayed_root; 478 479 BUG_ON(!delayed_root); 480 BUG_ON(delayed_item->ins_or_del != BTRFS_DELAYED_DELETION_ITEM && 481 delayed_item->ins_or_del != BTRFS_DELAYED_INSERTION_ITEM); 482 483 if (delayed_item->ins_or_del == BTRFS_DELAYED_INSERTION_ITEM) 484 root = &delayed_item->delayed_node->ins_root; 485 else 486 root = &delayed_item->delayed_node->del_root; 487 488 rb_erase(&delayed_item->rb_node, root); 489 delayed_item->delayed_node->count--; 490 491 finish_one_item(delayed_root); 492 } 493 494 static void btrfs_release_delayed_item(struct btrfs_delayed_item *item) 495 { 496 if (item) { 497 __btrfs_remove_delayed_item(item); 498 if (atomic_dec_and_test(&item->refs)) 499 kfree(item); 500 } 501 } 502 503 static struct btrfs_delayed_item *__btrfs_first_delayed_insertion_item( 504 struct btrfs_delayed_node *delayed_node) 505 { 506 struct rb_node *p; 507 struct btrfs_delayed_item *item = NULL; 508 509 p = rb_first(&delayed_node->ins_root); 510 if (p) 511 item = rb_entry(p, struct btrfs_delayed_item, rb_node); 512 513 return item; 514 } 515 516 static struct btrfs_delayed_item *__btrfs_first_delayed_deletion_item( 517 struct btrfs_delayed_node *delayed_node) 518 { 519 struct rb_node *p; 520 struct btrfs_delayed_item *item = NULL; 521 522 p = rb_first(&delayed_node->del_root); 523 if (p) 524 item = rb_entry(p, struct btrfs_delayed_item, rb_node); 525 526 return item; 527 } 528 529 static struct btrfs_delayed_item *__btrfs_next_delayed_item( 530 struct btrfs_delayed_item *item) 531 { 532 struct rb_node *p; 533 struct btrfs_delayed_item *next = NULL; 534 535 p = rb_next(&item->rb_node); 536 if (p) 537 next = rb_entry(p, struct btrfs_delayed_item, rb_node); 538 539 return next; 540 } 541 542 static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans, 543 struct btrfs_root *root, 544 struct btrfs_delayed_item *item) 545 { 546 struct btrfs_block_rsv *src_rsv; 547 struct btrfs_block_rsv *dst_rsv; 548 u64 num_bytes; 549 int ret; 550 551 if (!trans->bytes_reserved) 552 return 0; 553 554 src_rsv = trans->block_rsv; 555 dst_rsv = &root->fs_info->delayed_block_rsv; 556 557 num_bytes = btrfs_calc_trans_metadata_size(root, 1); 558 ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes); 559 if (!ret) { 560 trace_btrfs_space_reservation(root->fs_info, "delayed_item", 561 item->key.objectid, 562 num_bytes, 1); 563 item->bytes_reserved = num_bytes; 564 } 565 566 return ret; 567 } 568 569 static void btrfs_delayed_item_release_metadata(struct btrfs_root *root, 570 struct btrfs_delayed_item *item) 571 { 572 struct btrfs_block_rsv *rsv; 573 574 if (!item->bytes_reserved) 575 return; 576 577 rsv = &root->fs_info->delayed_block_rsv; 578 trace_btrfs_space_reservation(root->fs_info, "delayed_item", 579 item->key.objectid, item->bytes_reserved, 580 0); 581 btrfs_block_rsv_release(root, rsv, 582 item->bytes_reserved); 583 } 584 585 static int btrfs_delayed_inode_reserve_metadata( 586 struct btrfs_trans_handle *trans, 587 struct btrfs_root *root, 588 struct inode *inode, 589 struct btrfs_delayed_node *node) 590 { 591 struct btrfs_block_rsv *src_rsv; 592 struct btrfs_block_rsv *dst_rsv; 593 u64 num_bytes; 594 int ret; 595 bool release = false; 596 597 src_rsv = trans->block_rsv; 598 dst_rsv = &root->fs_info->delayed_block_rsv; 599 600 num_bytes = btrfs_calc_trans_metadata_size(root, 1); 601 602 /* 603 * btrfs_dirty_inode will update the inode under btrfs_join_transaction 604 * which doesn't reserve space for speed. This is a problem since we 605 * still need to reserve space for this update, so try to reserve the 606 * space. 607 * 608 * Now if src_rsv == delalloc_block_rsv we'll let it just steal since 609 * we're accounted for. 610 */ 611 if (!src_rsv || (!trans->bytes_reserved && 612 src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) { 613 ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes, 614 BTRFS_RESERVE_NO_FLUSH); 615 /* 616 * Since we're under a transaction reserve_metadata_bytes could 617 * try to commit the transaction which will make it return 618 * EAGAIN to make us stop the transaction we have, so return 619 * ENOSPC instead so that btrfs_dirty_inode knows what to do. 620 */ 621 if (ret == -EAGAIN) 622 ret = -ENOSPC; 623 if (!ret) { 624 node->bytes_reserved = num_bytes; 625 trace_btrfs_space_reservation(root->fs_info, 626 "delayed_inode", 627 btrfs_ino(inode), 628 num_bytes, 1); 629 } 630 return ret; 631 } else if (src_rsv->type == BTRFS_BLOCK_RSV_DELALLOC) { 632 spin_lock(&BTRFS_I(inode)->lock); 633 if (test_and_clear_bit(BTRFS_INODE_DELALLOC_META_RESERVED, 634 &BTRFS_I(inode)->runtime_flags)) { 635 spin_unlock(&BTRFS_I(inode)->lock); 636 release = true; 637 goto migrate; 638 } 639 spin_unlock(&BTRFS_I(inode)->lock); 640 641 /* Ok we didn't have space pre-reserved. This shouldn't happen 642 * too often but it can happen if we do delalloc to an existing 643 * inode which gets dirtied because of the time update, and then 644 * isn't touched again until after the transaction commits and 645 * then we try to write out the data. First try to be nice and 646 * reserve something strictly for us. If not be a pain and try 647 * to steal from the delalloc block rsv. 648 */ 649 ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes, 650 BTRFS_RESERVE_NO_FLUSH); 651 if (!ret) 652 goto out; 653 654 ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes); 655 if (!WARN_ON(ret)) 656 goto out; 657 658 /* 659 * Ok this is a problem, let's just steal from the global rsv 660 * since this really shouldn't happen that often. 661 */ 662 ret = btrfs_block_rsv_migrate(&root->fs_info->global_block_rsv, 663 dst_rsv, num_bytes); 664 goto out; 665 } 666 667 migrate: 668 ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes); 669 670 out: 671 /* 672 * Migrate only takes a reservation, it doesn't touch the size of the 673 * block_rsv. This is to simplify people who don't normally have things 674 * migrated from their block rsv. If they go to release their 675 * reservation, that will decrease the size as well, so if migrate 676 * reduced size we'd end up with a negative size. But for the 677 * delalloc_meta_reserved stuff we will only know to drop 1 reservation, 678 * but we could in fact do this reserve/migrate dance several times 679 * between the time we did the original reservation and we'd clean it 680 * up. So to take care of this, release the space for the meta 681 * reservation here. I think it may be time for a documentation page on 682 * how block rsvs. work. 683 */ 684 if (!ret) { 685 trace_btrfs_space_reservation(root->fs_info, "delayed_inode", 686 btrfs_ino(inode), num_bytes, 1); 687 node->bytes_reserved = num_bytes; 688 } 689 690 if (release) { 691 trace_btrfs_space_reservation(root->fs_info, "delalloc", 692 btrfs_ino(inode), num_bytes, 0); 693 btrfs_block_rsv_release(root, src_rsv, num_bytes); 694 } 695 696 return ret; 697 } 698 699 static void btrfs_delayed_inode_release_metadata(struct btrfs_root *root, 700 struct btrfs_delayed_node *node) 701 { 702 struct btrfs_block_rsv *rsv; 703 704 if (!node->bytes_reserved) 705 return; 706 707 rsv = &root->fs_info->delayed_block_rsv; 708 trace_btrfs_space_reservation(root->fs_info, "delayed_inode", 709 node->inode_id, node->bytes_reserved, 0); 710 btrfs_block_rsv_release(root, rsv, 711 node->bytes_reserved); 712 node->bytes_reserved = 0; 713 } 714 715 /* 716 * This helper will insert some continuous items into the same leaf according 717 * to the free space of the leaf. 718 */ 719 static int btrfs_batch_insert_items(struct btrfs_root *root, 720 struct btrfs_path *path, 721 struct btrfs_delayed_item *item) 722 { 723 struct btrfs_delayed_item *curr, *next; 724 int free_space; 725 int total_data_size = 0, total_size = 0; 726 struct extent_buffer *leaf; 727 char *data_ptr; 728 struct btrfs_key *keys; 729 u32 *data_size; 730 struct list_head head; 731 int slot; 732 int nitems; 733 int i; 734 int ret = 0; 735 736 BUG_ON(!path->nodes[0]); 737 738 leaf = path->nodes[0]; 739 free_space = btrfs_leaf_free_space(root, leaf); 740 INIT_LIST_HEAD(&head); 741 742 next = item; 743 nitems = 0; 744 745 /* 746 * count the number of the continuous items that we can insert in batch 747 */ 748 while (total_size + next->data_len + sizeof(struct btrfs_item) <= 749 free_space) { 750 total_data_size += next->data_len; 751 total_size += next->data_len + sizeof(struct btrfs_item); 752 list_add_tail(&next->tree_list, &head); 753 nitems++; 754 755 curr = next; 756 next = __btrfs_next_delayed_item(curr); 757 if (!next) 758 break; 759 760 if (!btrfs_is_continuous_delayed_item(curr, next)) 761 break; 762 } 763 764 if (!nitems) { 765 ret = 0; 766 goto out; 767 } 768 769 /* 770 * we need allocate some memory space, but it might cause the task 771 * to sleep, so we set all locked nodes in the path to blocking locks 772 * first. 773 */ 774 btrfs_set_path_blocking(path); 775 776 keys = kmalloc_array(nitems, sizeof(struct btrfs_key), GFP_NOFS); 777 if (!keys) { 778 ret = -ENOMEM; 779 goto out; 780 } 781 782 data_size = kmalloc_array(nitems, sizeof(u32), GFP_NOFS); 783 if (!data_size) { 784 ret = -ENOMEM; 785 goto error; 786 } 787 788 /* get keys of all the delayed items */ 789 i = 0; 790 list_for_each_entry(next, &head, tree_list) { 791 keys[i] = next->key; 792 data_size[i] = next->data_len; 793 i++; 794 } 795 796 /* reset all the locked nodes in the patch to spinning locks. */ 797 btrfs_clear_path_blocking(path, NULL, 0); 798 799 /* insert the keys of the items */ 800 setup_items_for_insert(root, path, keys, data_size, 801 total_data_size, total_size, nitems); 802 803 /* insert the dir index items */ 804 slot = path->slots[0]; 805 list_for_each_entry_safe(curr, next, &head, tree_list) { 806 data_ptr = btrfs_item_ptr(leaf, slot, char); 807 write_extent_buffer(leaf, &curr->data, 808 (unsigned long)data_ptr, 809 curr->data_len); 810 slot++; 811 812 btrfs_delayed_item_release_metadata(root, curr); 813 814 list_del(&curr->tree_list); 815 btrfs_release_delayed_item(curr); 816 } 817 818 error: 819 kfree(data_size); 820 kfree(keys); 821 out: 822 return ret; 823 } 824 825 /* 826 * This helper can just do simple insertion that needn't extend item for new 827 * data, such as directory name index insertion, inode insertion. 828 */ 829 static int btrfs_insert_delayed_item(struct btrfs_trans_handle *trans, 830 struct btrfs_root *root, 831 struct btrfs_path *path, 832 struct btrfs_delayed_item *delayed_item) 833 { 834 struct extent_buffer *leaf; 835 char *ptr; 836 int ret; 837 838 ret = btrfs_insert_empty_item(trans, root, path, &delayed_item->key, 839 delayed_item->data_len); 840 if (ret < 0 && ret != -EEXIST) 841 return ret; 842 843 leaf = path->nodes[0]; 844 845 ptr = btrfs_item_ptr(leaf, path->slots[0], char); 846 847 write_extent_buffer(leaf, delayed_item->data, (unsigned long)ptr, 848 delayed_item->data_len); 849 btrfs_mark_buffer_dirty(leaf); 850 851 btrfs_delayed_item_release_metadata(root, delayed_item); 852 return 0; 853 } 854 855 /* 856 * we insert an item first, then if there are some continuous items, we try 857 * to insert those items into the same leaf. 858 */ 859 static int btrfs_insert_delayed_items(struct btrfs_trans_handle *trans, 860 struct btrfs_path *path, 861 struct btrfs_root *root, 862 struct btrfs_delayed_node *node) 863 { 864 struct btrfs_delayed_item *curr, *prev; 865 int ret = 0; 866 867 do_again: 868 mutex_lock(&node->mutex); 869 curr = __btrfs_first_delayed_insertion_item(node); 870 if (!curr) 871 goto insert_end; 872 873 ret = btrfs_insert_delayed_item(trans, root, path, curr); 874 if (ret < 0) { 875 btrfs_release_path(path); 876 goto insert_end; 877 } 878 879 prev = curr; 880 curr = __btrfs_next_delayed_item(prev); 881 if (curr && btrfs_is_continuous_delayed_item(prev, curr)) { 882 /* insert the continuous items into the same leaf */ 883 path->slots[0]++; 884 btrfs_batch_insert_items(root, path, curr); 885 } 886 btrfs_release_delayed_item(prev); 887 btrfs_mark_buffer_dirty(path->nodes[0]); 888 889 btrfs_release_path(path); 890 mutex_unlock(&node->mutex); 891 goto do_again; 892 893 insert_end: 894 mutex_unlock(&node->mutex); 895 return ret; 896 } 897 898 static int btrfs_batch_delete_items(struct btrfs_trans_handle *trans, 899 struct btrfs_root *root, 900 struct btrfs_path *path, 901 struct btrfs_delayed_item *item) 902 { 903 struct btrfs_delayed_item *curr, *next; 904 struct extent_buffer *leaf; 905 struct btrfs_key key; 906 struct list_head head; 907 int nitems, i, last_item; 908 int ret = 0; 909 910 BUG_ON(!path->nodes[0]); 911 912 leaf = path->nodes[0]; 913 914 i = path->slots[0]; 915 last_item = btrfs_header_nritems(leaf) - 1; 916 if (i > last_item) 917 return -ENOENT; /* FIXME: Is errno suitable? */ 918 919 next = item; 920 INIT_LIST_HEAD(&head); 921 btrfs_item_key_to_cpu(leaf, &key, i); 922 nitems = 0; 923 /* 924 * count the number of the dir index items that we can delete in batch 925 */ 926 while (btrfs_comp_cpu_keys(&next->key, &key) == 0) { 927 list_add_tail(&next->tree_list, &head); 928 nitems++; 929 930 curr = next; 931 next = __btrfs_next_delayed_item(curr); 932 if (!next) 933 break; 934 935 if (!btrfs_is_continuous_delayed_item(curr, next)) 936 break; 937 938 i++; 939 if (i > last_item) 940 break; 941 btrfs_item_key_to_cpu(leaf, &key, i); 942 } 943 944 if (!nitems) 945 return 0; 946 947 ret = btrfs_del_items(trans, root, path, path->slots[0], nitems); 948 if (ret) 949 goto out; 950 951 list_for_each_entry_safe(curr, next, &head, tree_list) { 952 btrfs_delayed_item_release_metadata(root, curr); 953 list_del(&curr->tree_list); 954 btrfs_release_delayed_item(curr); 955 } 956 957 out: 958 return ret; 959 } 960 961 static int btrfs_delete_delayed_items(struct btrfs_trans_handle *trans, 962 struct btrfs_path *path, 963 struct btrfs_root *root, 964 struct btrfs_delayed_node *node) 965 { 966 struct btrfs_delayed_item *curr, *prev; 967 int ret = 0; 968 969 do_again: 970 mutex_lock(&node->mutex); 971 curr = __btrfs_first_delayed_deletion_item(node); 972 if (!curr) 973 goto delete_fail; 974 975 ret = btrfs_search_slot(trans, root, &curr->key, path, -1, 1); 976 if (ret < 0) 977 goto delete_fail; 978 else if (ret > 0) { 979 /* 980 * can't find the item which the node points to, so this node 981 * is invalid, just drop it. 982 */ 983 prev = curr; 984 curr = __btrfs_next_delayed_item(prev); 985 btrfs_release_delayed_item(prev); 986 ret = 0; 987 btrfs_release_path(path); 988 if (curr) { 989 mutex_unlock(&node->mutex); 990 goto do_again; 991 } else 992 goto delete_fail; 993 } 994 995 btrfs_batch_delete_items(trans, root, path, curr); 996 btrfs_release_path(path); 997 mutex_unlock(&node->mutex); 998 goto do_again; 999 1000 delete_fail: 1001 btrfs_release_path(path); 1002 mutex_unlock(&node->mutex); 1003 return ret; 1004 } 1005 1006 static void btrfs_release_delayed_inode(struct btrfs_delayed_node *delayed_node) 1007 { 1008 struct btrfs_delayed_root *delayed_root; 1009 1010 if (delayed_node && 1011 test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 1012 BUG_ON(!delayed_node->root); 1013 clear_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags); 1014 delayed_node->count--; 1015 1016 delayed_root = delayed_node->root->fs_info->delayed_root; 1017 finish_one_item(delayed_root); 1018 } 1019 } 1020 1021 static void btrfs_release_delayed_iref(struct btrfs_delayed_node *delayed_node) 1022 { 1023 struct btrfs_delayed_root *delayed_root; 1024 1025 ASSERT(delayed_node->root); 1026 clear_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags); 1027 delayed_node->count--; 1028 1029 delayed_root = delayed_node->root->fs_info->delayed_root; 1030 finish_one_item(delayed_root); 1031 } 1032 1033 static int __btrfs_update_delayed_inode(struct btrfs_trans_handle *trans, 1034 struct btrfs_root *root, 1035 struct btrfs_path *path, 1036 struct btrfs_delayed_node *node) 1037 { 1038 struct btrfs_key key; 1039 struct btrfs_inode_item *inode_item; 1040 struct extent_buffer *leaf; 1041 int mod; 1042 int ret; 1043 1044 key.objectid = node->inode_id; 1045 key.type = BTRFS_INODE_ITEM_KEY; 1046 key.offset = 0; 1047 1048 if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags)) 1049 mod = -1; 1050 else 1051 mod = 1; 1052 1053 ret = btrfs_lookup_inode(trans, root, path, &key, mod); 1054 if (ret > 0) { 1055 btrfs_release_path(path); 1056 return -ENOENT; 1057 } else if (ret < 0) { 1058 return ret; 1059 } 1060 1061 leaf = path->nodes[0]; 1062 inode_item = btrfs_item_ptr(leaf, path->slots[0], 1063 struct btrfs_inode_item); 1064 write_extent_buffer(leaf, &node->inode_item, (unsigned long)inode_item, 1065 sizeof(struct btrfs_inode_item)); 1066 btrfs_mark_buffer_dirty(leaf); 1067 1068 if (!test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags)) 1069 goto no_iref; 1070 1071 path->slots[0]++; 1072 if (path->slots[0] >= btrfs_header_nritems(leaf)) 1073 goto search; 1074 again: 1075 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 1076 if (key.objectid != node->inode_id) 1077 goto out; 1078 1079 if (key.type != BTRFS_INODE_REF_KEY && 1080 key.type != BTRFS_INODE_EXTREF_KEY) 1081 goto out; 1082 1083 /* 1084 * Delayed iref deletion is for the inode who has only one link, 1085 * so there is only one iref. The case that several irefs are 1086 * in the same item doesn't exist. 1087 */ 1088 btrfs_del_item(trans, root, path); 1089 out: 1090 btrfs_release_delayed_iref(node); 1091 no_iref: 1092 btrfs_release_path(path); 1093 err_out: 1094 btrfs_delayed_inode_release_metadata(root, node); 1095 btrfs_release_delayed_inode(node); 1096 1097 return ret; 1098 1099 search: 1100 btrfs_release_path(path); 1101 1102 key.type = BTRFS_INODE_EXTREF_KEY; 1103 key.offset = -1; 1104 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 1105 if (ret < 0) 1106 goto err_out; 1107 ASSERT(ret); 1108 1109 ret = 0; 1110 leaf = path->nodes[0]; 1111 path->slots[0]--; 1112 goto again; 1113 } 1114 1115 static inline int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans, 1116 struct btrfs_root *root, 1117 struct btrfs_path *path, 1118 struct btrfs_delayed_node *node) 1119 { 1120 int ret; 1121 1122 mutex_lock(&node->mutex); 1123 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &node->flags)) { 1124 mutex_unlock(&node->mutex); 1125 return 0; 1126 } 1127 1128 ret = __btrfs_update_delayed_inode(trans, root, path, node); 1129 mutex_unlock(&node->mutex); 1130 return ret; 1131 } 1132 1133 static inline int 1134 __btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans, 1135 struct btrfs_path *path, 1136 struct btrfs_delayed_node *node) 1137 { 1138 int ret; 1139 1140 ret = btrfs_insert_delayed_items(trans, path, node->root, node); 1141 if (ret) 1142 return ret; 1143 1144 ret = btrfs_delete_delayed_items(trans, path, node->root, node); 1145 if (ret) 1146 return ret; 1147 1148 ret = btrfs_update_delayed_inode(trans, node->root, path, node); 1149 return ret; 1150 } 1151 1152 /* 1153 * Called when committing the transaction. 1154 * Returns 0 on success. 1155 * Returns < 0 on error and returns with an aborted transaction with any 1156 * outstanding delayed items cleaned up. 1157 */ 1158 static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans, 1159 struct btrfs_root *root, int nr) 1160 { 1161 struct btrfs_delayed_root *delayed_root; 1162 struct btrfs_delayed_node *curr_node, *prev_node; 1163 struct btrfs_path *path; 1164 struct btrfs_block_rsv *block_rsv; 1165 int ret = 0; 1166 bool count = (nr > 0); 1167 1168 if (trans->aborted) 1169 return -EIO; 1170 1171 path = btrfs_alloc_path(); 1172 if (!path) 1173 return -ENOMEM; 1174 path->leave_spinning = 1; 1175 1176 block_rsv = trans->block_rsv; 1177 trans->block_rsv = &root->fs_info->delayed_block_rsv; 1178 1179 delayed_root = btrfs_get_delayed_root(root); 1180 1181 curr_node = btrfs_first_delayed_node(delayed_root); 1182 while (curr_node && (!count || (count && nr--))) { 1183 ret = __btrfs_commit_inode_delayed_items(trans, path, 1184 curr_node); 1185 if (ret) { 1186 btrfs_release_delayed_node(curr_node); 1187 curr_node = NULL; 1188 btrfs_abort_transaction(trans, root, ret); 1189 break; 1190 } 1191 1192 prev_node = curr_node; 1193 curr_node = btrfs_next_delayed_node(curr_node); 1194 btrfs_release_delayed_node(prev_node); 1195 } 1196 1197 if (curr_node) 1198 btrfs_release_delayed_node(curr_node); 1199 btrfs_free_path(path); 1200 trans->block_rsv = block_rsv; 1201 1202 return ret; 1203 } 1204 1205 int btrfs_run_delayed_items(struct btrfs_trans_handle *trans, 1206 struct btrfs_root *root) 1207 { 1208 return __btrfs_run_delayed_items(trans, root, -1); 1209 } 1210 1211 int btrfs_run_delayed_items_nr(struct btrfs_trans_handle *trans, 1212 struct btrfs_root *root, int nr) 1213 { 1214 return __btrfs_run_delayed_items(trans, root, nr); 1215 } 1216 1217 int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans, 1218 struct inode *inode) 1219 { 1220 struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 1221 struct btrfs_path *path; 1222 struct btrfs_block_rsv *block_rsv; 1223 int ret; 1224 1225 if (!delayed_node) 1226 return 0; 1227 1228 mutex_lock(&delayed_node->mutex); 1229 if (!delayed_node->count) { 1230 mutex_unlock(&delayed_node->mutex); 1231 btrfs_release_delayed_node(delayed_node); 1232 return 0; 1233 } 1234 mutex_unlock(&delayed_node->mutex); 1235 1236 path = btrfs_alloc_path(); 1237 if (!path) { 1238 btrfs_release_delayed_node(delayed_node); 1239 return -ENOMEM; 1240 } 1241 path->leave_spinning = 1; 1242 1243 block_rsv = trans->block_rsv; 1244 trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv; 1245 1246 ret = __btrfs_commit_inode_delayed_items(trans, path, delayed_node); 1247 1248 btrfs_release_delayed_node(delayed_node); 1249 btrfs_free_path(path); 1250 trans->block_rsv = block_rsv; 1251 1252 return ret; 1253 } 1254 1255 int btrfs_commit_inode_delayed_inode(struct inode *inode) 1256 { 1257 struct btrfs_trans_handle *trans; 1258 struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 1259 struct btrfs_path *path; 1260 struct btrfs_block_rsv *block_rsv; 1261 int ret; 1262 1263 if (!delayed_node) 1264 return 0; 1265 1266 mutex_lock(&delayed_node->mutex); 1267 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 1268 mutex_unlock(&delayed_node->mutex); 1269 btrfs_release_delayed_node(delayed_node); 1270 return 0; 1271 } 1272 mutex_unlock(&delayed_node->mutex); 1273 1274 trans = btrfs_join_transaction(delayed_node->root); 1275 if (IS_ERR(trans)) { 1276 ret = PTR_ERR(trans); 1277 goto out; 1278 } 1279 1280 path = btrfs_alloc_path(); 1281 if (!path) { 1282 ret = -ENOMEM; 1283 goto trans_out; 1284 } 1285 path->leave_spinning = 1; 1286 1287 block_rsv = trans->block_rsv; 1288 trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv; 1289 1290 mutex_lock(&delayed_node->mutex); 1291 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) 1292 ret = __btrfs_update_delayed_inode(trans, delayed_node->root, 1293 path, delayed_node); 1294 else 1295 ret = 0; 1296 mutex_unlock(&delayed_node->mutex); 1297 1298 btrfs_free_path(path); 1299 trans->block_rsv = block_rsv; 1300 trans_out: 1301 btrfs_end_transaction(trans, delayed_node->root); 1302 btrfs_btree_balance_dirty(delayed_node->root); 1303 out: 1304 btrfs_release_delayed_node(delayed_node); 1305 1306 return ret; 1307 } 1308 1309 void btrfs_remove_delayed_node(struct inode *inode) 1310 { 1311 struct btrfs_delayed_node *delayed_node; 1312 1313 delayed_node = ACCESS_ONCE(BTRFS_I(inode)->delayed_node); 1314 if (!delayed_node) 1315 return; 1316 1317 BTRFS_I(inode)->delayed_node = NULL; 1318 btrfs_release_delayed_node(delayed_node); 1319 } 1320 1321 struct btrfs_async_delayed_work { 1322 struct btrfs_delayed_root *delayed_root; 1323 int nr; 1324 struct btrfs_work work; 1325 }; 1326 1327 static void btrfs_async_run_delayed_root(struct btrfs_work *work) 1328 { 1329 struct btrfs_async_delayed_work *async_work; 1330 struct btrfs_delayed_root *delayed_root; 1331 struct btrfs_trans_handle *trans; 1332 struct btrfs_path *path; 1333 struct btrfs_delayed_node *delayed_node = NULL; 1334 struct btrfs_root *root; 1335 struct btrfs_block_rsv *block_rsv; 1336 int total_done = 0; 1337 1338 async_work = container_of(work, struct btrfs_async_delayed_work, work); 1339 delayed_root = async_work->delayed_root; 1340 1341 path = btrfs_alloc_path(); 1342 if (!path) 1343 goto out; 1344 1345 again: 1346 if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND / 2) 1347 goto free_path; 1348 1349 delayed_node = btrfs_first_prepared_delayed_node(delayed_root); 1350 if (!delayed_node) 1351 goto free_path; 1352 1353 path->leave_spinning = 1; 1354 root = delayed_node->root; 1355 1356 trans = btrfs_join_transaction(root); 1357 if (IS_ERR(trans)) 1358 goto release_path; 1359 1360 block_rsv = trans->block_rsv; 1361 trans->block_rsv = &root->fs_info->delayed_block_rsv; 1362 1363 __btrfs_commit_inode_delayed_items(trans, path, delayed_node); 1364 1365 trans->block_rsv = block_rsv; 1366 btrfs_end_transaction(trans, root); 1367 btrfs_btree_balance_dirty_nodelay(root); 1368 1369 release_path: 1370 btrfs_release_path(path); 1371 total_done++; 1372 1373 btrfs_release_prepared_delayed_node(delayed_node); 1374 if (async_work->nr == 0 || total_done < async_work->nr) 1375 goto again; 1376 1377 free_path: 1378 btrfs_free_path(path); 1379 out: 1380 wake_up(&delayed_root->wait); 1381 kfree(async_work); 1382 } 1383 1384 1385 static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root, 1386 struct btrfs_root *root, int nr) 1387 { 1388 struct btrfs_async_delayed_work *async_work; 1389 1390 if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) 1391 return 0; 1392 1393 async_work = kmalloc(sizeof(*async_work), GFP_NOFS); 1394 if (!async_work) 1395 return -ENOMEM; 1396 1397 async_work->delayed_root = delayed_root; 1398 btrfs_init_work(&async_work->work, btrfs_delayed_meta_helper, 1399 btrfs_async_run_delayed_root, NULL, NULL); 1400 async_work->nr = nr; 1401 1402 btrfs_queue_work(root->fs_info->delayed_workers, &async_work->work); 1403 return 0; 1404 } 1405 1406 void btrfs_assert_delayed_root_empty(struct btrfs_root *root) 1407 { 1408 struct btrfs_delayed_root *delayed_root; 1409 delayed_root = btrfs_get_delayed_root(root); 1410 WARN_ON(btrfs_first_delayed_node(delayed_root)); 1411 } 1412 1413 static int could_end_wait(struct btrfs_delayed_root *delayed_root, int seq) 1414 { 1415 int val = atomic_read(&delayed_root->items_seq); 1416 1417 if (val < seq || val >= seq + BTRFS_DELAYED_BATCH) 1418 return 1; 1419 1420 if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) 1421 return 1; 1422 1423 return 0; 1424 } 1425 1426 void btrfs_balance_delayed_items(struct btrfs_root *root) 1427 { 1428 struct btrfs_delayed_root *delayed_root; 1429 1430 delayed_root = btrfs_get_delayed_root(root); 1431 1432 if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) 1433 return; 1434 1435 if (atomic_read(&delayed_root->items) >= BTRFS_DELAYED_WRITEBACK) { 1436 int seq; 1437 int ret; 1438 1439 seq = atomic_read(&delayed_root->items_seq); 1440 1441 ret = btrfs_wq_run_delayed_node(delayed_root, root, 0); 1442 if (ret) 1443 return; 1444 1445 wait_event_interruptible(delayed_root->wait, 1446 could_end_wait(delayed_root, seq)); 1447 return; 1448 } 1449 1450 btrfs_wq_run_delayed_node(delayed_root, root, BTRFS_DELAYED_BATCH); 1451 } 1452 1453 /* Will return 0 or -ENOMEM */ 1454 int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans, 1455 struct btrfs_root *root, const char *name, 1456 int name_len, struct inode *dir, 1457 struct btrfs_disk_key *disk_key, u8 type, 1458 u64 index) 1459 { 1460 struct btrfs_delayed_node *delayed_node; 1461 struct btrfs_delayed_item *delayed_item; 1462 struct btrfs_dir_item *dir_item; 1463 int ret; 1464 1465 delayed_node = btrfs_get_or_create_delayed_node(dir); 1466 if (IS_ERR(delayed_node)) 1467 return PTR_ERR(delayed_node); 1468 1469 delayed_item = btrfs_alloc_delayed_item(sizeof(*dir_item) + name_len); 1470 if (!delayed_item) { 1471 ret = -ENOMEM; 1472 goto release_node; 1473 } 1474 1475 delayed_item->key.objectid = btrfs_ino(dir); 1476 delayed_item->key.type = BTRFS_DIR_INDEX_KEY; 1477 delayed_item->key.offset = index; 1478 1479 dir_item = (struct btrfs_dir_item *)delayed_item->data; 1480 dir_item->location = *disk_key; 1481 btrfs_set_stack_dir_transid(dir_item, trans->transid); 1482 btrfs_set_stack_dir_data_len(dir_item, 0); 1483 btrfs_set_stack_dir_name_len(dir_item, name_len); 1484 btrfs_set_stack_dir_type(dir_item, type); 1485 memcpy((char *)(dir_item + 1), name, name_len); 1486 1487 ret = btrfs_delayed_item_reserve_metadata(trans, root, delayed_item); 1488 /* 1489 * we have reserved enough space when we start a new transaction, 1490 * so reserving metadata failure is impossible 1491 */ 1492 BUG_ON(ret); 1493 1494 1495 mutex_lock(&delayed_node->mutex); 1496 ret = __btrfs_add_delayed_insertion_item(delayed_node, delayed_item); 1497 if (unlikely(ret)) { 1498 btrfs_err(root->fs_info, "err add delayed dir index item(name: %.*s) " 1499 "into the insertion tree of the delayed node" 1500 "(root id: %llu, inode id: %llu, errno: %d)", 1501 name_len, name, delayed_node->root->objectid, 1502 delayed_node->inode_id, ret); 1503 BUG(); 1504 } 1505 mutex_unlock(&delayed_node->mutex); 1506 1507 release_node: 1508 btrfs_release_delayed_node(delayed_node); 1509 return ret; 1510 } 1511 1512 static int btrfs_delete_delayed_insertion_item(struct btrfs_root *root, 1513 struct btrfs_delayed_node *node, 1514 struct btrfs_key *key) 1515 { 1516 struct btrfs_delayed_item *item; 1517 1518 mutex_lock(&node->mutex); 1519 item = __btrfs_lookup_delayed_insertion_item(node, key); 1520 if (!item) { 1521 mutex_unlock(&node->mutex); 1522 return 1; 1523 } 1524 1525 btrfs_delayed_item_release_metadata(root, item); 1526 btrfs_release_delayed_item(item); 1527 mutex_unlock(&node->mutex); 1528 return 0; 1529 } 1530 1531 int btrfs_delete_delayed_dir_index(struct btrfs_trans_handle *trans, 1532 struct btrfs_root *root, struct inode *dir, 1533 u64 index) 1534 { 1535 struct btrfs_delayed_node *node; 1536 struct btrfs_delayed_item *item; 1537 struct btrfs_key item_key; 1538 int ret; 1539 1540 node = btrfs_get_or_create_delayed_node(dir); 1541 if (IS_ERR(node)) 1542 return PTR_ERR(node); 1543 1544 item_key.objectid = btrfs_ino(dir); 1545 item_key.type = BTRFS_DIR_INDEX_KEY; 1546 item_key.offset = index; 1547 1548 ret = btrfs_delete_delayed_insertion_item(root, node, &item_key); 1549 if (!ret) 1550 goto end; 1551 1552 item = btrfs_alloc_delayed_item(0); 1553 if (!item) { 1554 ret = -ENOMEM; 1555 goto end; 1556 } 1557 1558 item->key = item_key; 1559 1560 ret = btrfs_delayed_item_reserve_metadata(trans, root, item); 1561 /* 1562 * we have reserved enough space when we start a new transaction, 1563 * so reserving metadata failure is impossible. 1564 */ 1565 BUG_ON(ret); 1566 1567 mutex_lock(&node->mutex); 1568 ret = __btrfs_add_delayed_deletion_item(node, item); 1569 if (unlikely(ret)) { 1570 btrfs_err(root->fs_info, "err add delayed dir index item(index: %llu) " 1571 "into the deletion tree of the delayed node" 1572 "(root id: %llu, inode id: %llu, errno: %d)", 1573 index, node->root->objectid, node->inode_id, 1574 ret); 1575 BUG(); 1576 } 1577 mutex_unlock(&node->mutex); 1578 end: 1579 btrfs_release_delayed_node(node); 1580 return ret; 1581 } 1582 1583 int btrfs_inode_delayed_dir_index_count(struct inode *inode) 1584 { 1585 struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 1586 1587 if (!delayed_node) 1588 return -ENOENT; 1589 1590 /* 1591 * Since we have held i_mutex of this directory, it is impossible that 1592 * a new directory index is added into the delayed node and index_cnt 1593 * is updated now. So we needn't lock the delayed node. 1594 */ 1595 if (!delayed_node->index_cnt) { 1596 btrfs_release_delayed_node(delayed_node); 1597 return -EINVAL; 1598 } 1599 1600 BTRFS_I(inode)->index_cnt = delayed_node->index_cnt; 1601 btrfs_release_delayed_node(delayed_node); 1602 return 0; 1603 } 1604 1605 void btrfs_get_delayed_items(struct inode *inode, struct list_head *ins_list, 1606 struct list_head *del_list) 1607 { 1608 struct btrfs_delayed_node *delayed_node; 1609 struct btrfs_delayed_item *item; 1610 1611 delayed_node = btrfs_get_delayed_node(inode); 1612 if (!delayed_node) 1613 return; 1614 1615 mutex_lock(&delayed_node->mutex); 1616 item = __btrfs_first_delayed_insertion_item(delayed_node); 1617 while (item) { 1618 atomic_inc(&item->refs); 1619 list_add_tail(&item->readdir_list, ins_list); 1620 item = __btrfs_next_delayed_item(item); 1621 } 1622 1623 item = __btrfs_first_delayed_deletion_item(delayed_node); 1624 while (item) { 1625 atomic_inc(&item->refs); 1626 list_add_tail(&item->readdir_list, del_list); 1627 item = __btrfs_next_delayed_item(item); 1628 } 1629 mutex_unlock(&delayed_node->mutex); 1630 /* 1631 * This delayed node is still cached in the btrfs inode, so refs 1632 * must be > 1 now, and we needn't check it is going to be freed 1633 * or not. 1634 * 1635 * Besides that, this function is used to read dir, we do not 1636 * insert/delete delayed items in this period. So we also needn't 1637 * requeue or dequeue this delayed node. 1638 */ 1639 atomic_dec(&delayed_node->refs); 1640 } 1641 1642 void btrfs_put_delayed_items(struct list_head *ins_list, 1643 struct list_head *del_list) 1644 { 1645 struct btrfs_delayed_item *curr, *next; 1646 1647 list_for_each_entry_safe(curr, next, ins_list, readdir_list) { 1648 list_del(&curr->readdir_list); 1649 if (atomic_dec_and_test(&curr->refs)) 1650 kfree(curr); 1651 } 1652 1653 list_for_each_entry_safe(curr, next, del_list, readdir_list) { 1654 list_del(&curr->readdir_list); 1655 if (atomic_dec_and_test(&curr->refs)) 1656 kfree(curr); 1657 } 1658 } 1659 1660 int btrfs_should_delete_dir_index(struct list_head *del_list, 1661 u64 index) 1662 { 1663 struct btrfs_delayed_item *curr, *next; 1664 int ret; 1665 1666 if (list_empty(del_list)) 1667 return 0; 1668 1669 list_for_each_entry_safe(curr, next, del_list, readdir_list) { 1670 if (curr->key.offset > index) 1671 break; 1672 1673 list_del(&curr->readdir_list); 1674 ret = (curr->key.offset == index); 1675 1676 if (atomic_dec_and_test(&curr->refs)) 1677 kfree(curr); 1678 1679 if (ret) 1680 return 1; 1681 else 1682 continue; 1683 } 1684 return 0; 1685 } 1686 1687 /* 1688 * btrfs_readdir_delayed_dir_index - read dir info stored in the delayed tree 1689 * 1690 */ 1691 int btrfs_readdir_delayed_dir_index(struct dir_context *ctx, 1692 struct list_head *ins_list) 1693 { 1694 struct btrfs_dir_item *di; 1695 struct btrfs_delayed_item *curr, *next; 1696 struct btrfs_key location; 1697 char *name; 1698 int name_len; 1699 int over = 0; 1700 unsigned char d_type; 1701 1702 if (list_empty(ins_list)) 1703 return 0; 1704 1705 /* 1706 * Changing the data of the delayed item is impossible. So 1707 * we needn't lock them. And we have held i_mutex of the 1708 * directory, nobody can delete any directory indexes now. 1709 */ 1710 list_for_each_entry_safe(curr, next, ins_list, readdir_list) { 1711 list_del(&curr->readdir_list); 1712 1713 if (curr->key.offset < ctx->pos) { 1714 if (atomic_dec_and_test(&curr->refs)) 1715 kfree(curr); 1716 continue; 1717 } 1718 1719 ctx->pos = curr->key.offset; 1720 1721 di = (struct btrfs_dir_item *)curr->data; 1722 name = (char *)(di + 1); 1723 name_len = btrfs_stack_dir_name_len(di); 1724 1725 d_type = btrfs_filetype_table[di->type]; 1726 btrfs_disk_key_to_cpu(&location, &di->location); 1727 1728 over = !dir_emit(ctx, name, name_len, 1729 location.objectid, d_type); 1730 1731 if (atomic_dec_and_test(&curr->refs)) 1732 kfree(curr); 1733 1734 if (over) 1735 return 1; 1736 } 1737 return 0; 1738 } 1739 1740 static void fill_stack_inode_item(struct btrfs_trans_handle *trans, 1741 struct btrfs_inode_item *inode_item, 1742 struct inode *inode) 1743 { 1744 btrfs_set_stack_inode_uid(inode_item, i_uid_read(inode)); 1745 btrfs_set_stack_inode_gid(inode_item, i_gid_read(inode)); 1746 btrfs_set_stack_inode_size(inode_item, BTRFS_I(inode)->disk_i_size); 1747 btrfs_set_stack_inode_mode(inode_item, inode->i_mode); 1748 btrfs_set_stack_inode_nlink(inode_item, inode->i_nlink); 1749 btrfs_set_stack_inode_nbytes(inode_item, inode_get_bytes(inode)); 1750 btrfs_set_stack_inode_generation(inode_item, 1751 BTRFS_I(inode)->generation); 1752 btrfs_set_stack_inode_sequence(inode_item, inode->i_version); 1753 btrfs_set_stack_inode_transid(inode_item, trans->transid); 1754 btrfs_set_stack_inode_rdev(inode_item, inode->i_rdev); 1755 btrfs_set_stack_inode_flags(inode_item, BTRFS_I(inode)->flags); 1756 btrfs_set_stack_inode_block_group(inode_item, 0); 1757 1758 btrfs_set_stack_timespec_sec(btrfs_inode_atime(inode_item), 1759 inode->i_atime.tv_sec); 1760 btrfs_set_stack_timespec_nsec(btrfs_inode_atime(inode_item), 1761 inode->i_atime.tv_nsec); 1762 1763 btrfs_set_stack_timespec_sec(btrfs_inode_mtime(inode_item), 1764 inode->i_mtime.tv_sec); 1765 btrfs_set_stack_timespec_nsec(btrfs_inode_mtime(inode_item), 1766 inode->i_mtime.tv_nsec); 1767 1768 btrfs_set_stack_timespec_sec(btrfs_inode_ctime(inode_item), 1769 inode->i_ctime.tv_sec); 1770 btrfs_set_stack_timespec_nsec(btrfs_inode_ctime(inode_item), 1771 inode->i_ctime.tv_nsec); 1772 } 1773 1774 int btrfs_fill_inode(struct inode *inode, u32 *rdev) 1775 { 1776 struct btrfs_delayed_node *delayed_node; 1777 struct btrfs_inode_item *inode_item; 1778 struct btrfs_timespec *tspec; 1779 1780 delayed_node = btrfs_get_delayed_node(inode); 1781 if (!delayed_node) 1782 return -ENOENT; 1783 1784 mutex_lock(&delayed_node->mutex); 1785 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 1786 mutex_unlock(&delayed_node->mutex); 1787 btrfs_release_delayed_node(delayed_node); 1788 return -ENOENT; 1789 } 1790 1791 inode_item = &delayed_node->inode_item; 1792 1793 i_uid_write(inode, btrfs_stack_inode_uid(inode_item)); 1794 i_gid_write(inode, btrfs_stack_inode_gid(inode_item)); 1795 btrfs_i_size_write(inode, btrfs_stack_inode_size(inode_item)); 1796 inode->i_mode = btrfs_stack_inode_mode(inode_item); 1797 set_nlink(inode, btrfs_stack_inode_nlink(inode_item)); 1798 inode_set_bytes(inode, btrfs_stack_inode_nbytes(inode_item)); 1799 BTRFS_I(inode)->generation = btrfs_stack_inode_generation(inode_item); 1800 inode->i_version = btrfs_stack_inode_sequence(inode_item); 1801 inode->i_rdev = 0; 1802 *rdev = btrfs_stack_inode_rdev(inode_item); 1803 BTRFS_I(inode)->flags = btrfs_stack_inode_flags(inode_item); 1804 1805 tspec = btrfs_inode_atime(inode_item); 1806 inode->i_atime.tv_sec = btrfs_stack_timespec_sec(tspec); 1807 inode->i_atime.tv_nsec = btrfs_stack_timespec_nsec(tspec); 1808 1809 tspec = btrfs_inode_mtime(inode_item); 1810 inode->i_mtime.tv_sec = btrfs_stack_timespec_sec(tspec); 1811 inode->i_mtime.tv_nsec = btrfs_stack_timespec_nsec(tspec); 1812 1813 tspec = btrfs_inode_ctime(inode_item); 1814 inode->i_ctime.tv_sec = btrfs_stack_timespec_sec(tspec); 1815 inode->i_ctime.tv_nsec = btrfs_stack_timespec_nsec(tspec); 1816 1817 inode->i_generation = BTRFS_I(inode)->generation; 1818 BTRFS_I(inode)->index_cnt = (u64)-1; 1819 1820 mutex_unlock(&delayed_node->mutex); 1821 btrfs_release_delayed_node(delayed_node); 1822 return 0; 1823 } 1824 1825 int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans, 1826 struct btrfs_root *root, struct inode *inode) 1827 { 1828 struct btrfs_delayed_node *delayed_node; 1829 int ret = 0; 1830 1831 delayed_node = btrfs_get_or_create_delayed_node(inode); 1832 if (IS_ERR(delayed_node)) 1833 return PTR_ERR(delayed_node); 1834 1835 mutex_lock(&delayed_node->mutex); 1836 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 1837 fill_stack_inode_item(trans, &delayed_node->inode_item, inode); 1838 goto release_node; 1839 } 1840 1841 ret = btrfs_delayed_inode_reserve_metadata(trans, root, inode, 1842 delayed_node); 1843 if (ret) 1844 goto release_node; 1845 1846 fill_stack_inode_item(trans, &delayed_node->inode_item, inode); 1847 set_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags); 1848 delayed_node->count++; 1849 atomic_inc(&root->fs_info->delayed_root->items); 1850 release_node: 1851 mutex_unlock(&delayed_node->mutex); 1852 btrfs_release_delayed_node(delayed_node); 1853 return ret; 1854 } 1855 1856 int btrfs_delayed_delete_inode_ref(struct inode *inode) 1857 { 1858 struct btrfs_delayed_node *delayed_node; 1859 1860 /* 1861 * we don't do delayed inode updates during log recovery because it 1862 * leads to enospc problems. This means we also can't do 1863 * delayed inode refs 1864 */ 1865 if (BTRFS_I(inode)->root->fs_info->log_root_recovering) 1866 return -EAGAIN; 1867 1868 delayed_node = btrfs_get_or_create_delayed_node(inode); 1869 if (IS_ERR(delayed_node)) 1870 return PTR_ERR(delayed_node); 1871 1872 /* 1873 * We don't reserve space for inode ref deletion is because: 1874 * - We ONLY do async inode ref deletion for the inode who has only 1875 * one link(i_nlink == 1), it means there is only one inode ref. 1876 * And in most case, the inode ref and the inode item are in the 1877 * same leaf, and we will deal with them at the same time. 1878 * Since we are sure we will reserve the space for the inode item, 1879 * it is unnecessary to reserve space for inode ref deletion. 1880 * - If the inode ref and the inode item are not in the same leaf, 1881 * We also needn't worry about enospc problem, because we reserve 1882 * much more space for the inode update than it needs. 1883 * - At the worst, we can steal some space from the global reservation. 1884 * It is very rare. 1885 */ 1886 mutex_lock(&delayed_node->mutex); 1887 if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags)) 1888 goto release_node; 1889 1890 set_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags); 1891 delayed_node->count++; 1892 atomic_inc(&BTRFS_I(inode)->root->fs_info->delayed_root->items); 1893 release_node: 1894 mutex_unlock(&delayed_node->mutex); 1895 btrfs_release_delayed_node(delayed_node); 1896 return 0; 1897 } 1898 1899 static void __btrfs_kill_delayed_node(struct btrfs_delayed_node *delayed_node) 1900 { 1901 struct btrfs_root *root = delayed_node->root; 1902 struct btrfs_delayed_item *curr_item, *prev_item; 1903 1904 mutex_lock(&delayed_node->mutex); 1905 curr_item = __btrfs_first_delayed_insertion_item(delayed_node); 1906 while (curr_item) { 1907 btrfs_delayed_item_release_metadata(root, curr_item); 1908 prev_item = curr_item; 1909 curr_item = __btrfs_next_delayed_item(prev_item); 1910 btrfs_release_delayed_item(prev_item); 1911 } 1912 1913 curr_item = __btrfs_first_delayed_deletion_item(delayed_node); 1914 while (curr_item) { 1915 btrfs_delayed_item_release_metadata(root, curr_item); 1916 prev_item = curr_item; 1917 curr_item = __btrfs_next_delayed_item(prev_item); 1918 btrfs_release_delayed_item(prev_item); 1919 } 1920 1921 if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags)) 1922 btrfs_release_delayed_iref(delayed_node); 1923 1924 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 1925 btrfs_delayed_inode_release_metadata(root, delayed_node); 1926 btrfs_release_delayed_inode(delayed_node); 1927 } 1928 mutex_unlock(&delayed_node->mutex); 1929 } 1930 1931 void btrfs_kill_delayed_inode_items(struct inode *inode) 1932 { 1933 struct btrfs_delayed_node *delayed_node; 1934 1935 delayed_node = btrfs_get_delayed_node(inode); 1936 if (!delayed_node) 1937 return; 1938 1939 __btrfs_kill_delayed_node(delayed_node); 1940 btrfs_release_delayed_node(delayed_node); 1941 } 1942 1943 void btrfs_kill_all_delayed_nodes(struct btrfs_root *root) 1944 { 1945 u64 inode_id = 0; 1946 struct btrfs_delayed_node *delayed_nodes[8]; 1947 int i, n; 1948 1949 while (1) { 1950 spin_lock(&root->inode_lock); 1951 n = radix_tree_gang_lookup(&root->delayed_nodes_tree, 1952 (void **)delayed_nodes, inode_id, 1953 ARRAY_SIZE(delayed_nodes)); 1954 if (!n) { 1955 spin_unlock(&root->inode_lock); 1956 break; 1957 } 1958 1959 inode_id = delayed_nodes[n - 1]->inode_id + 1; 1960 1961 for (i = 0; i < n; i++) 1962 atomic_inc(&delayed_nodes[i]->refs); 1963 spin_unlock(&root->inode_lock); 1964 1965 for (i = 0; i < n; i++) { 1966 __btrfs_kill_delayed_node(delayed_nodes[i]); 1967 btrfs_release_delayed_node(delayed_nodes[i]); 1968 } 1969 } 1970 } 1971 1972 void btrfs_destroy_delayed_inodes(struct btrfs_root *root) 1973 { 1974 struct btrfs_delayed_root *delayed_root; 1975 struct btrfs_delayed_node *curr_node, *prev_node; 1976 1977 delayed_root = btrfs_get_delayed_root(root); 1978 1979 curr_node = btrfs_first_delayed_node(delayed_root); 1980 while (curr_node) { 1981 __btrfs_kill_delayed_node(curr_node); 1982 1983 prev_node = curr_node; 1984 curr_node = btrfs_next_delayed_node(curr_node); 1985 btrfs_release_delayed_node(prev_node); 1986 } 1987 } 1988 1989