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