Lines Matching +full:root +full:- +full:node
1 // SPDX-License-Identifier: GPL-2.0
13 #include "delayed-inode.h"
14 #include "disk-io.h"
18 #include "inode-item.h"
19 #include "space-info.h"
21 #include "file-item.h"
37 return -ENOMEM; in btrfs_delayed_inode_init()
48 struct btrfs_root *root, u64 inode_id) in btrfs_init_delayed_node() argument
50 delayed_node->root = root; in btrfs_init_delayed_node()
51 delayed_node->inode_id = inode_id; in btrfs_init_delayed_node()
52 refcount_set(&delayed_node->refs, 0); in btrfs_init_delayed_node()
53 delayed_node->ins_root = RB_ROOT_CACHED; in btrfs_init_delayed_node()
54 delayed_node->del_root = RB_ROOT_CACHED; in btrfs_init_delayed_node()
55 mutex_init(&delayed_node->mutex); in btrfs_init_delayed_node()
56 INIT_LIST_HEAD(&delayed_node->n_list); in btrfs_init_delayed_node()
57 INIT_LIST_HEAD(&delayed_node->p_list); in btrfs_init_delayed_node()
63 struct btrfs_root *root = btrfs_inode->root; in btrfs_get_delayed_node() local
65 struct btrfs_delayed_node *node; in btrfs_get_delayed_node() local
67 node = READ_ONCE(btrfs_inode->delayed_node); in btrfs_get_delayed_node()
68 if (node) { in btrfs_get_delayed_node()
69 refcount_inc(&node->refs); in btrfs_get_delayed_node()
70 return node; in btrfs_get_delayed_node()
73 spin_lock(&root->inode_lock); in btrfs_get_delayed_node()
74 node = radix_tree_lookup(&root->delayed_nodes_tree, ino); in btrfs_get_delayed_node()
76 if (node) { in btrfs_get_delayed_node()
77 if (btrfs_inode->delayed_node) { in btrfs_get_delayed_node()
78 refcount_inc(&node->refs); /* can be accessed */ in btrfs_get_delayed_node()
79 BUG_ON(btrfs_inode->delayed_node != node); in btrfs_get_delayed_node()
80 spin_unlock(&root->inode_lock); in btrfs_get_delayed_node()
81 return node; in btrfs_get_delayed_node()
86 * this node from the radix tree. In this case, the refcount in btrfs_get_delayed_node()
96 * If this node is properly in the radix, we want to bump the in btrfs_get_delayed_node()
100 if (refcount_inc_not_zero(&node->refs)) { in btrfs_get_delayed_node()
101 refcount_inc(&node->refs); in btrfs_get_delayed_node()
102 btrfs_inode->delayed_node = node; in btrfs_get_delayed_node()
104 node = NULL; in btrfs_get_delayed_node()
107 spin_unlock(&root->inode_lock); in btrfs_get_delayed_node()
108 return node; in btrfs_get_delayed_node()
110 spin_unlock(&root->inode_lock); in btrfs_get_delayed_node()
115 /* Will return either the node or PTR_ERR(-ENOMEM) */
119 struct btrfs_delayed_node *node; in btrfs_get_or_create_delayed_node() local
120 struct btrfs_root *root = btrfs_inode->root; in btrfs_get_or_create_delayed_node() local
125 node = btrfs_get_delayed_node(btrfs_inode); in btrfs_get_or_create_delayed_node()
126 if (node) in btrfs_get_or_create_delayed_node()
127 return node; in btrfs_get_or_create_delayed_node()
129 node = kmem_cache_zalloc(delayed_node_cache, GFP_NOFS); in btrfs_get_or_create_delayed_node()
130 if (!node) in btrfs_get_or_create_delayed_node()
131 return ERR_PTR(-ENOMEM); in btrfs_get_or_create_delayed_node()
132 btrfs_init_delayed_node(node, root, ino); in btrfs_get_or_create_delayed_node()
135 refcount_set(&node->refs, 2); in btrfs_get_or_create_delayed_node()
139 kmem_cache_free(delayed_node_cache, node); in btrfs_get_or_create_delayed_node()
143 spin_lock(&root->inode_lock); in btrfs_get_or_create_delayed_node()
144 ret = radix_tree_insert(&root->delayed_nodes_tree, ino, node); in btrfs_get_or_create_delayed_node()
145 if (ret == -EEXIST) { in btrfs_get_or_create_delayed_node()
146 spin_unlock(&root->inode_lock); in btrfs_get_or_create_delayed_node()
147 kmem_cache_free(delayed_node_cache, node); in btrfs_get_or_create_delayed_node()
151 btrfs_inode->delayed_node = node; in btrfs_get_or_create_delayed_node()
152 spin_unlock(&root->inode_lock); in btrfs_get_or_create_delayed_node()
155 return node; in btrfs_get_or_create_delayed_node()
159 * Call it when holding delayed_node->mutex
161 * If mod = 1, add this node into the prepared list.
163 static void btrfs_queue_delayed_node(struct btrfs_delayed_root *root, in btrfs_queue_delayed_node() argument
164 struct btrfs_delayed_node *node, in btrfs_queue_delayed_node() argument
167 spin_lock(&root->lock); in btrfs_queue_delayed_node()
168 if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { in btrfs_queue_delayed_node()
169 if (!list_empty(&node->p_list)) in btrfs_queue_delayed_node()
170 list_move_tail(&node->p_list, &root->prepare_list); in btrfs_queue_delayed_node()
172 list_add_tail(&node->p_list, &root->prepare_list); in btrfs_queue_delayed_node()
174 list_add_tail(&node->n_list, &root->node_list); in btrfs_queue_delayed_node()
175 list_add_tail(&node->p_list, &root->prepare_list); in btrfs_queue_delayed_node()
176 refcount_inc(&node->refs); /* inserted into list */ in btrfs_queue_delayed_node()
177 root->nodes++; in btrfs_queue_delayed_node()
178 set_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags); in btrfs_queue_delayed_node()
180 spin_unlock(&root->lock); in btrfs_queue_delayed_node()
183 /* Call it when holding delayed_node->mutex */
184 static void btrfs_dequeue_delayed_node(struct btrfs_delayed_root *root, in btrfs_dequeue_delayed_node() argument
185 struct btrfs_delayed_node *node) in btrfs_dequeue_delayed_node() argument
187 spin_lock(&root->lock); in btrfs_dequeue_delayed_node()
188 if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { in btrfs_dequeue_delayed_node()
189 root->nodes--; in btrfs_dequeue_delayed_node()
190 refcount_dec(&node->refs); /* not in the list */ in btrfs_dequeue_delayed_node()
191 list_del_init(&node->n_list); in btrfs_dequeue_delayed_node()
192 if (!list_empty(&node->p_list)) in btrfs_dequeue_delayed_node()
193 list_del_init(&node->p_list); in btrfs_dequeue_delayed_node()
194 clear_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags); in btrfs_dequeue_delayed_node()
196 spin_unlock(&root->lock); in btrfs_dequeue_delayed_node()
203 struct btrfs_delayed_node *node = NULL; in btrfs_first_delayed_node() local
205 spin_lock(&delayed_root->lock); in btrfs_first_delayed_node()
206 if (list_empty(&delayed_root->node_list)) in btrfs_first_delayed_node()
209 p = delayed_root->node_list.next; in btrfs_first_delayed_node()
210 node = list_entry(p, struct btrfs_delayed_node, n_list); in btrfs_first_delayed_node()
211 refcount_inc(&node->refs); in btrfs_first_delayed_node()
213 spin_unlock(&delayed_root->lock); in btrfs_first_delayed_node()
215 return node; in btrfs_first_delayed_node()
219 struct btrfs_delayed_node *node) in btrfs_next_delayed_node() argument
225 delayed_root = node->root->fs_info->delayed_root; in btrfs_next_delayed_node()
226 spin_lock(&delayed_root->lock); in btrfs_next_delayed_node()
227 if (!test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { in btrfs_next_delayed_node()
229 if (list_empty(&delayed_root->node_list)) in btrfs_next_delayed_node()
231 p = delayed_root->node_list.next; in btrfs_next_delayed_node()
232 } else if (list_is_last(&node->n_list, &delayed_root->node_list)) in btrfs_next_delayed_node()
235 p = node->n_list.next; in btrfs_next_delayed_node()
238 refcount_inc(&next->refs); in btrfs_next_delayed_node()
240 spin_unlock(&delayed_root->lock); in btrfs_next_delayed_node()
254 delayed_root = delayed_node->root->fs_info->delayed_root; in __btrfs_release_delayed_node()
256 mutex_lock(&delayed_node->mutex); in __btrfs_release_delayed_node()
257 if (delayed_node->count) in __btrfs_release_delayed_node()
261 mutex_unlock(&delayed_node->mutex); in __btrfs_release_delayed_node()
263 if (refcount_dec_and_test(&delayed_node->refs)) { in __btrfs_release_delayed_node()
264 struct btrfs_root *root = delayed_node->root; in __btrfs_release_delayed_node() local
266 spin_lock(&root->inode_lock); in __btrfs_release_delayed_node()
271 ASSERT(refcount_read(&delayed_node->refs) == 0); in __btrfs_release_delayed_node()
272 radix_tree_delete(&root->delayed_nodes_tree, in __btrfs_release_delayed_node()
273 delayed_node->inode_id); in __btrfs_release_delayed_node()
274 spin_unlock(&root->inode_lock); in __btrfs_release_delayed_node()
279 static inline void btrfs_release_delayed_node(struct btrfs_delayed_node *node) in btrfs_release_delayed_node() argument
281 __btrfs_release_delayed_node(node, 0); in btrfs_release_delayed_node()
288 struct btrfs_delayed_node *node = NULL; in btrfs_first_prepared_delayed_node() local
290 spin_lock(&delayed_root->lock); in btrfs_first_prepared_delayed_node()
291 if (list_empty(&delayed_root->prepare_list)) in btrfs_first_prepared_delayed_node()
294 p = delayed_root->prepare_list.next; in btrfs_first_prepared_delayed_node()
296 node = list_entry(p, struct btrfs_delayed_node, p_list); in btrfs_first_prepared_delayed_node()
297 refcount_inc(&node->refs); in btrfs_first_prepared_delayed_node()
299 spin_unlock(&delayed_root->lock); in btrfs_first_prepared_delayed_node()
301 return node; in btrfs_first_prepared_delayed_node()
305 struct btrfs_delayed_node *node) in btrfs_release_prepared_delayed_node() argument
307 __btrfs_release_delayed_node(node, 1); in btrfs_release_prepared_delayed_node()
311 struct btrfs_delayed_node *node, in btrfs_alloc_delayed_item() argument
318 item->data_len = data_len; in btrfs_alloc_delayed_item()
319 item->type = type; in btrfs_alloc_delayed_item()
320 item->bytes_reserved = 0; in btrfs_alloc_delayed_item()
321 item->delayed_node = node; in btrfs_alloc_delayed_item()
322 RB_CLEAR_NODE(&item->rb_node); in btrfs_alloc_delayed_item()
323 INIT_LIST_HEAD(&item->log_list); in btrfs_alloc_delayed_item()
324 item->logged = false; in btrfs_alloc_delayed_item()
325 refcount_set(&item->refs, 1); in btrfs_alloc_delayed_item()
331 * __btrfs_lookup_delayed_item - look up the delayed item by key
332 * @delayed_node: pointer to the delayed node
339 struct rb_root *root, in __btrfs_lookup_delayed_item() argument
342 struct rb_node *node = root->rb_node; in __btrfs_lookup_delayed_item() local
345 while (node) { in __btrfs_lookup_delayed_item()
346 delayed_item = rb_entry(node, struct btrfs_delayed_item, in __btrfs_lookup_delayed_item()
348 if (delayed_item->index < index) in __btrfs_lookup_delayed_item()
349 node = node->rb_right; in __btrfs_lookup_delayed_item()
350 else if (delayed_item->index > index) in __btrfs_lookup_delayed_item()
351 node = node->rb_left; in __btrfs_lookup_delayed_item()
362 struct rb_node **p, *node; in __btrfs_add_delayed_item() local
364 struct rb_root_cached *root; in __btrfs_add_delayed_item() local
368 if (ins->type == BTRFS_DELAYED_INSERTION_ITEM) in __btrfs_add_delayed_item()
369 root = &delayed_node->ins_root; in __btrfs_add_delayed_item()
371 root = &delayed_node->del_root; in __btrfs_add_delayed_item()
373 p = &root->rb_root.rb_node; in __btrfs_add_delayed_item()
374 node = &ins->rb_node; in __btrfs_add_delayed_item()
381 if (item->index < ins->index) { in __btrfs_add_delayed_item()
382 p = &(*p)->rb_right; in __btrfs_add_delayed_item()
384 } else if (item->index > ins->index) { in __btrfs_add_delayed_item()
385 p = &(*p)->rb_left; in __btrfs_add_delayed_item()
387 return -EEXIST; in __btrfs_add_delayed_item()
391 rb_link_node(node, parent_node, p); in __btrfs_add_delayed_item()
392 rb_insert_color_cached(node, root, leftmost); in __btrfs_add_delayed_item()
394 if (ins->type == BTRFS_DELAYED_INSERTION_ITEM && in __btrfs_add_delayed_item()
395 ins->index >= delayed_node->index_cnt) in __btrfs_add_delayed_item()
396 delayed_node->index_cnt = ins->index + 1; in __btrfs_add_delayed_item()
398 delayed_node->count++; in __btrfs_add_delayed_item()
399 atomic_inc(&delayed_node->root->fs_info->delayed_root->items); in __btrfs_add_delayed_item()
405 int seq = atomic_inc_return(&delayed_root->items_seq); in finish_one_item()
408 if ((atomic_dec_return(&delayed_root->items) < in finish_one_item()
410 cond_wake_up_nomb(&delayed_root->wait); in finish_one_item()
415 struct btrfs_delayed_node *delayed_node = delayed_item->delayed_node; in __btrfs_remove_delayed_item()
416 struct rb_root_cached *root; in __btrfs_remove_delayed_item() local
420 if (RB_EMPTY_NODE(&delayed_item->rb_node)) in __btrfs_remove_delayed_item()
423 /* If it's in a rbtree, then we need to have delayed node locked. */ in __btrfs_remove_delayed_item()
424 lockdep_assert_held(&delayed_node->mutex); in __btrfs_remove_delayed_item()
426 delayed_root = delayed_node->root->fs_info->delayed_root; in __btrfs_remove_delayed_item()
428 if (delayed_item->type == BTRFS_DELAYED_INSERTION_ITEM) in __btrfs_remove_delayed_item()
429 root = &delayed_node->ins_root; in __btrfs_remove_delayed_item()
431 root = &delayed_node->del_root; in __btrfs_remove_delayed_item()
433 rb_erase_cached(&delayed_item->rb_node, root); in __btrfs_remove_delayed_item()
434 RB_CLEAR_NODE(&delayed_item->rb_node); in __btrfs_remove_delayed_item()
435 delayed_node->count--; in __btrfs_remove_delayed_item()
444 if (refcount_dec_and_test(&item->refs)) in btrfs_release_delayed_item()
455 p = rb_first_cached(&delayed_node->ins_root); in __btrfs_first_delayed_insertion_item()
468 p = rb_first_cached(&delayed_node->del_root); in __btrfs_first_delayed_deletion_item()
481 p = rb_next(&item->rb_node); in __btrfs_next_delayed_item()
493 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_delayed_item_reserve_metadata()
497 if (!trans->bytes_reserved) in btrfs_delayed_item_reserve_metadata()
500 src_rsv = trans->block_rsv; in btrfs_delayed_item_reserve_metadata()
501 dst_rsv = &fs_info->delayed_block_rsv; in btrfs_delayed_item_reserve_metadata()
513 item->delayed_node->inode_id, in btrfs_delayed_item_reserve_metadata()
518 * node's index_items_size field. in btrfs_delayed_item_reserve_metadata()
520 if (item->type == BTRFS_DELAYED_DELETION_ITEM) in btrfs_delayed_item_reserve_metadata()
521 item->bytes_reserved = num_bytes; in btrfs_delayed_item_reserve_metadata()
527 static void btrfs_delayed_item_release_metadata(struct btrfs_root *root, in btrfs_delayed_item_release_metadata() argument
531 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_delayed_item_release_metadata()
533 if (!item->bytes_reserved) in btrfs_delayed_item_release_metadata()
536 rsv = &fs_info->delayed_block_rsv; in btrfs_delayed_item_release_metadata()
542 item->delayed_node->inode_id, in btrfs_delayed_item_release_metadata()
543 item->bytes_reserved, 0); in btrfs_delayed_item_release_metadata()
544 btrfs_block_rsv_release(fs_info, rsv, item->bytes_reserved, NULL); in btrfs_delayed_item_release_metadata()
547 static void btrfs_delayed_item_release_leaves(struct btrfs_delayed_node *node, in btrfs_delayed_item_release_leaves() argument
550 struct btrfs_fs_info *fs_info = node->root->fs_info; in btrfs_delayed_item_release_leaves()
554 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) in btrfs_delayed_item_release_leaves()
557 trace_btrfs_space_reservation(fs_info, "delayed_item", node->inode_id, in btrfs_delayed_item_release_leaves()
559 btrfs_block_rsv_release(fs_info, &fs_info->delayed_block_rsv, bytes, NULL); in btrfs_delayed_item_release_leaves()
564 struct btrfs_root *root, in btrfs_delayed_inode_reserve_metadata() argument
565 struct btrfs_delayed_node *node) in btrfs_delayed_inode_reserve_metadata() argument
567 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_delayed_inode_reserve_metadata()
573 src_rsv = trans->block_rsv; in btrfs_delayed_inode_reserve_metadata()
574 dst_rsv = &fs_info->delayed_block_rsv; in btrfs_delayed_inode_reserve_metadata()
587 if (!src_rsv || (!trans->bytes_reserved && in btrfs_delayed_inode_reserve_metadata()
588 src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) { in btrfs_delayed_inode_reserve_metadata()
589 ret = btrfs_qgroup_reserve_meta(root, num_bytes, in btrfs_delayed_inode_reserve_metadata()
595 /* NO_FLUSH could only fail with -ENOSPC */ in btrfs_delayed_inode_reserve_metadata()
596 ASSERT(ret == 0 || ret == -ENOSPC); in btrfs_delayed_inode_reserve_metadata()
598 btrfs_qgroup_free_meta_prealloc(root, num_bytes); in btrfs_delayed_inode_reserve_metadata()
605 node->inode_id, num_bytes, 1); in btrfs_delayed_inode_reserve_metadata()
606 node->bytes_reserved = num_bytes; in btrfs_delayed_inode_reserve_metadata()
613 struct btrfs_delayed_node *node, in btrfs_delayed_inode_release_metadata() argument
618 if (!node->bytes_reserved) in btrfs_delayed_inode_release_metadata()
621 rsv = &fs_info->delayed_block_rsv; in btrfs_delayed_inode_release_metadata()
623 node->inode_id, node->bytes_reserved, 0); in btrfs_delayed_inode_release_metadata()
624 btrfs_block_rsv_release(fs_info, rsv, node->bytes_reserved, NULL); in btrfs_delayed_inode_release_metadata()
626 btrfs_qgroup_free_meta_prealloc(node->root, in btrfs_delayed_inode_release_metadata()
627 node->bytes_reserved); in btrfs_delayed_inode_release_metadata()
629 btrfs_qgroup_convert_reserved_meta(node->root, in btrfs_delayed_inode_release_metadata()
630 node->bytes_reserved); in btrfs_delayed_inode_release_metadata()
631 node->bytes_reserved = 0; in btrfs_delayed_inode_release_metadata()
645 struct btrfs_root *root, in btrfs_insert_delayed_item() argument
649 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_insert_delayed_item()
650 struct btrfs_delayed_node *node = first_item->delayed_node; in btrfs_insert_delayed_item() local
657 const u32 first_data_size = first_item->data_len; in btrfs_insert_delayed_item()
663 lockdep_assert_held(&node->mutex); in btrfs_insert_delayed_item()
674 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) in btrfs_insert_delayed_item()
683 ASSERT(first_item->bytes_reserved == 0); in btrfs_insert_delayed_item()
685 list_add_tail(&first_item->tree_list, &item_list); in btrfs_insert_delayed_item()
702 if (continuous_keys_only && (next->index != curr->index + 1)) in btrfs_insert_delayed_item()
705 ASSERT(next->bytes_reserved == 0); in btrfs_insert_delayed_item()
707 next_size = next->data_len + sizeof(struct btrfs_item); in btrfs_insert_delayed_item()
711 list_add_tail(&next->tree_list, &item_list); in btrfs_insert_delayed_item()
714 batch.total_data_size += next->data_len; in btrfs_insert_delayed_item()
719 first_key.objectid = node->inode_id; in btrfs_insert_delayed_item()
721 first_key.offset = first_item->index; in btrfs_insert_delayed_item()
732 ret = -ENOMEM; in btrfs_insert_delayed_item()
740 ins_keys[i].objectid = node->inode_id; in btrfs_insert_delayed_item()
742 ins_keys[i].offset = curr->index; in btrfs_insert_delayed_item()
743 ins_sizes[i] = curr->data_len; in btrfs_insert_delayed_item()
748 ret = btrfs_insert_empty_items(trans, root, path, &batch); in btrfs_insert_delayed_item()
755 data_ptr = btrfs_item_ptr(path->nodes[0], path->slots[0], char); in btrfs_insert_delayed_item()
756 write_extent_buffer(path->nodes[0], &curr->data, in btrfs_insert_delayed_item()
757 (unsigned long)data_ptr, curr->data_len); in btrfs_insert_delayed_item()
758 path->slots[0]++; in btrfs_insert_delayed_item()
768 ASSERT(node->index_item_leaves > 0); in btrfs_insert_delayed_item()
787 btrfs_delayed_item_release_leaves(node, 1); in btrfs_insert_delayed_item()
788 node->index_item_leaves--; in btrfs_insert_delayed_item()
792 * reserved leaves > 1 here - this happens when many dir index in btrfs_insert_delayed_item()
797 btrfs_delayed_item_release_leaves(node, node->index_item_leaves); in btrfs_insert_delayed_item()
798 node->index_item_leaves = 0; in btrfs_insert_delayed_item()
802 list_del(&curr->tree_list); in btrfs_insert_delayed_item()
812 struct btrfs_root *root, in btrfs_insert_delayed_items() argument
813 struct btrfs_delayed_node *node) in btrfs_insert_delayed_items() argument
820 mutex_lock(&node->mutex); in btrfs_insert_delayed_items()
821 curr = __btrfs_first_delayed_insertion_item(node); in btrfs_insert_delayed_items()
823 mutex_unlock(&node->mutex); in btrfs_insert_delayed_items()
826 ret = btrfs_insert_delayed_item(trans, root, path, curr); in btrfs_insert_delayed_items()
827 mutex_unlock(&node->mutex); in btrfs_insert_delayed_items()
834 struct btrfs_root *root, in btrfs_batch_delete_items() argument
838 const u64 ino = item->delayed_node->inode_id; in btrfs_batch_delete_items()
839 struct btrfs_fs_info *fs_info = root->fs_info; in btrfs_batch_delete_items()
841 struct extent_buffer *leaf = path->nodes[0]; in btrfs_batch_delete_items()
845 u64 total_reserved_size = item->bytes_reserved; in btrfs_batch_delete_items()
849 slot = path->slots[0]; in btrfs_batch_delete_items()
850 last_slot = btrfs_header_nritems(leaf) - 1; in btrfs_batch_delete_items()
857 return -ENOENT; in btrfs_batch_delete_items()
861 list_add_tail(&curr->tree_list, &batch_list); in btrfs_batch_delete_items()
865 * leaf - if so, we can add it to the batch of items to delete from the in btrfs_batch_delete_items()
879 key.offset != next->index) in btrfs_batch_delete_items()
883 list_add_tail(&curr->tree_list, &batch_list); in btrfs_batch_delete_items()
884 total_reserved_size += curr->bytes_reserved; in btrfs_batch_delete_items()
887 ret = btrfs_del_items(trans, root, path, path->slots[0], nitems); in btrfs_batch_delete_items()
899 btrfs_block_rsv_release(fs_info, &fs_info->delayed_block_rsv, in btrfs_batch_delete_items()
904 list_del(&curr->tree_list); in btrfs_batch_delete_items()
913 struct btrfs_root *root, in btrfs_delete_delayed_items() argument
914 struct btrfs_delayed_node *node) in btrfs_delete_delayed_items() argument
919 key.objectid = node->inode_id; in btrfs_delete_delayed_items()
925 mutex_lock(&node->mutex); in btrfs_delete_delayed_items()
926 item = __btrfs_first_delayed_deletion_item(node); in btrfs_delete_delayed_items()
928 mutex_unlock(&node->mutex); in btrfs_delete_delayed_items()
932 key.offset = item->index; in btrfs_delete_delayed_items()
933 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_delete_delayed_items()
953 ret = btrfs_batch_delete_items(trans, root, path, item); in btrfs_delete_delayed_items()
962 * need to add delayed items to this delayed node. in btrfs_delete_delayed_items()
964 mutex_unlock(&node->mutex); in btrfs_delete_delayed_items()
975 test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { in btrfs_release_delayed_inode()
976 ASSERT(delayed_node->root); in btrfs_release_delayed_inode()
977 clear_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags); in btrfs_release_delayed_inode()
978 delayed_node->count--; in btrfs_release_delayed_inode()
980 delayed_root = delayed_node->root->fs_info->delayed_root; in btrfs_release_delayed_inode()
988 if (test_and_clear_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags)) { in btrfs_release_delayed_iref()
991 ASSERT(delayed_node->root); in btrfs_release_delayed_iref()
992 delayed_node->count--; in btrfs_release_delayed_iref()
994 delayed_root = delayed_node->root->fs_info->delayed_root; in btrfs_release_delayed_iref()
1000 struct btrfs_root *root, in __btrfs_update_delayed_inode() argument
1002 struct btrfs_delayed_node *node) in __btrfs_update_delayed_inode() argument
1004 struct btrfs_fs_info *fs_info = root->fs_info; in __btrfs_update_delayed_inode()
1011 key.objectid = node->inode_id; in __btrfs_update_delayed_inode()
1015 if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags)) in __btrfs_update_delayed_inode()
1016 mod = -1; in __btrfs_update_delayed_inode()
1020 ret = btrfs_lookup_inode(trans, root, path, &key, mod); in __btrfs_update_delayed_inode()
1022 ret = -ENOENT; in __btrfs_update_delayed_inode()
1026 leaf = path->nodes[0]; in __btrfs_update_delayed_inode()
1027 inode_item = btrfs_item_ptr(leaf, path->slots[0], in __btrfs_update_delayed_inode()
1029 write_extent_buffer(leaf, &node->inode_item, (unsigned long)inode_item, in __btrfs_update_delayed_inode()
1033 if (!test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags)) in __btrfs_update_delayed_inode()
1036 path->slots[0]++; in __btrfs_update_delayed_inode()
1037 if (path->slots[0] >= btrfs_header_nritems(leaf)) in __btrfs_update_delayed_inode()
1040 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in __btrfs_update_delayed_inode()
1041 if (key.objectid != node->inode_id) in __btrfs_update_delayed_inode()
1053 ret = btrfs_del_item(trans, root, path); in __btrfs_update_delayed_inode()
1055 btrfs_release_delayed_iref(node); in __btrfs_update_delayed_inode()
1058 btrfs_delayed_inode_release_metadata(fs_info, node, (ret < 0)); in __btrfs_update_delayed_inode()
1059 btrfs_release_delayed_inode(node); in __btrfs_update_delayed_inode()
1066 if (ret && ret != -ENOENT) in __btrfs_update_delayed_inode()
1075 key.offset = -1; in __btrfs_update_delayed_inode()
1077 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in __btrfs_update_delayed_inode()
1083 leaf = path->nodes[0]; in __btrfs_update_delayed_inode()
1084 path->slots[0]--; in __btrfs_update_delayed_inode()
1089 struct btrfs_root *root, in btrfs_update_delayed_inode() argument
1091 struct btrfs_delayed_node *node) in btrfs_update_delayed_inode() argument
1095 mutex_lock(&node->mutex); in btrfs_update_delayed_inode()
1096 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &node->flags)) { in btrfs_update_delayed_inode()
1097 mutex_unlock(&node->mutex); in btrfs_update_delayed_inode()
1101 ret = __btrfs_update_delayed_inode(trans, root, path, node); in btrfs_update_delayed_inode()
1102 mutex_unlock(&node->mutex); in btrfs_update_delayed_inode()
1109 struct btrfs_delayed_node *node) in __btrfs_commit_inode_delayed_items() argument
1113 ret = btrfs_insert_delayed_items(trans, path, node->root, node); in __btrfs_commit_inode_delayed_items()
1117 ret = btrfs_delete_delayed_items(trans, path, node->root, node); in __btrfs_commit_inode_delayed_items()
1121 ret = btrfs_record_root_in_trans(trans, node->root); in __btrfs_commit_inode_delayed_items()
1124 ret = btrfs_update_delayed_inode(trans, node->root, path, node); in __btrfs_commit_inode_delayed_items()
1136 struct btrfs_fs_info *fs_info = trans->fs_info; in __btrfs_run_delayed_items()
1145 return -EIO; in __btrfs_run_delayed_items()
1149 return -ENOMEM; in __btrfs_run_delayed_items()
1151 block_rsv = trans->block_rsv; in __btrfs_run_delayed_items()
1152 trans->block_rsv = &fs_info->delayed_block_rsv; in __btrfs_run_delayed_items()
1154 delayed_root = fs_info->delayed_root; in __btrfs_run_delayed_items()
1157 while (curr_node && (!count || nr--)) { in __btrfs_run_delayed_items()
1169 * node. If the commit of delayed items was successful the path in __btrfs_run_delayed_items()
1173 ASSERT(path->nodes[0] == NULL); in __btrfs_run_delayed_items()
1179 * releasing the delayed node, as that requires taking the delayed node's in __btrfs_run_delayed_items()
1188 trans->block_rsv = block_rsv; in __btrfs_run_delayed_items()
1195 return __btrfs_run_delayed_items(trans, -1); in btrfs_run_delayed_items()
1214 mutex_lock(&delayed_node->mutex); in btrfs_commit_inode_delayed_items()
1215 if (!delayed_node->count) { in btrfs_commit_inode_delayed_items()
1216 mutex_unlock(&delayed_node->mutex); in btrfs_commit_inode_delayed_items()
1220 mutex_unlock(&delayed_node->mutex); in btrfs_commit_inode_delayed_items()
1225 return -ENOMEM; in btrfs_commit_inode_delayed_items()
1228 block_rsv = trans->block_rsv; in btrfs_commit_inode_delayed_items()
1229 trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv; in btrfs_commit_inode_delayed_items()
1235 trans->block_rsv = block_rsv; in btrfs_commit_inode_delayed_items()
1242 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_commit_inode_delayed_inode()
1252 mutex_lock(&delayed_node->mutex); in btrfs_commit_inode_delayed_inode()
1253 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { in btrfs_commit_inode_delayed_inode()
1254 mutex_unlock(&delayed_node->mutex); in btrfs_commit_inode_delayed_inode()
1258 mutex_unlock(&delayed_node->mutex); in btrfs_commit_inode_delayed_inode()
1260 trans = btrfs_join_transaction(delayed_node->root); in btrfs_commit_inode_delayed_inode()
1268 ret = -ENOMEM; in btrfs_commit_inode_delayed_inode()
1272 block_rsv = trans->block_rsv; in btrfs_commit_inode_delayed_inode()
1273 trans->block_rsv = &fs_info->delayed_block_rsv; in btrfs_commit_inode_delayed_inode()
1275 mutex_lock(&delayed_node->mutex); in btrfs_commit_inode_delayed_inode()
1276 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) in btrfs_commit_inode_delayed_inode()
1277 ret = __btrfs_update_delayed_inode(trans, delayed_node->root, in btrfs_commit_inode_delayed_inode()
1281 mutex_unlock(&delayed_node->mutex); in btrfs_commit_inode_delayed_inode()
1284 trans->block_rsv = block_rsv; in btrfs_commit_inode_delayed_inode()
1298 delayed_node = READ_ONCE(inode->delayed_node); in btrfs_remove_delayed_node()
1302 inode->delayed_node = NULL; in btrfs_remove_delayed_node()
1319 struct btrfs_root *root; in btrfs_async_run_delayed_root() local
1324 delayed_root = async_work->delayed_root; in btrfs_async_run_delayed_root()
1331 if (atomic_read(&delayed_root->items) < in btrfs_async_run_delayed_root()
1339 root = delayed_node->root; in btrfs_async_run_delayed_root()
1341 trans = btrfs_join_transaction(root); in btrfs_async_run_delayed_root()
1349 block_rsv = trans->block_rsv; in btrfs_async_run_delayed_root()
1350 trans->block_rsv = &root->fs_info->delayed_block_rsv; in btrfs_async_run_delayed_root()
1354 trans->block_rsv = block_rsv; in btrfs_async_run_delayed_root()
1356 btrfs_btree_balance_dirty_nodelay(root->fs_info); in btrfs_async_run_delayed_root()
1362 } while ((async_work->nr == 0 && total_done < BTRFS_DELAYED_WRITEBACK) in btrfs_async_run_delayed_root()
1363 || total_done < async_work->nr); in btrfs_async_run_delayed_root()
1367 wake_up(&delayed_root->wait); in btrfs_async_run_delayed_root()
1379 return -ENOMEM; in btrfs_wq_run_delayed_node()
1381 async_work->delayed_root = delayed_root; in btrfs_wq_run_delayed_node()
1382 btrfs_init_work(&async_work->work, btrfs_async_run_delayed_root, NULL, in btrfs_wq_run_delayed_node()
1384 async_work->nr = nr; in btrfs_wq_run_delayed_node()
1386 btrfs_queue_work(fs_info->delayed_workers, &async_work->work); in btrfs_wq_run_delayed_node()
1392 WARN_ON(btrfs_first_delayed_node(fs_info->delayed_root)); in btrfs_assert_delayed_root_empty()
1397 int val = atomic_read(&delayed_root->items_seq); in could_end_wait()
1402 if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) in could_end_wait()
1410 struct btrfs_delayed_root *delayed_root = fs_info->delayed_root; in btrfs_balance_delayed_items()
1412 if ((atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) || in btrfs_balance_delayed_items()
1413 btrfs_workqueue_normal_congested(fs_info->delayed_workers)) in btrfs_balance_delayed_items()
1416 if (atomic_read(&delayed_root->items) >= BTRFS_DELAYED_WRITEBACK) { in btrfs_balance_delayed_items()
1420 seq = atomic_read(&delayed_root->items_seq); in btrfs_balance_delayed_items()
1426 wait_event_interruptible(delayed_root->wait, in btrfs_balance_delayed_items()
1436 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_release_dir_index_item_space()
1439 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) in btrfs_release_dir_index_item_space()
1450 trans->transid, bytes, 0); in btrfs_release_dir_index_item_space()
1451 btrfs_block_rsv_release(fs_info, trans->block_rsv, bytes, NULL); in btrfs_release_dir_index_item_space()
1452 ASSERT(trans->bytes_reserved >= bytes); in btrfs_release_dir_index_item_space()
1453 trans->bytes_reserved -= bytes; in btrfs_release_dir_index_item_space()
1456 /* Will return 0, -ENOMEM or -EEXIST (index number collision, unexpected). */
1463 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_insert_delayed_dir_index()
1480 ret = -ENOMEM; in btrfs_insert_delayed_dir_index()
1484 delayed_item->index = index; in btrfs_insert_delayed_dir_index()
1486 dir_item = (struct btrfs_dir_item *)delayed_item->data; in btrfs_insert_delayed_dir_index()
1487 dir_item->location = *disk_key; in btrfs_insert_delayed_dir_index()
1488 btrfs_set_stack_dir_transid(dir_item, trans->transid); in btrfs_insert_delayed_dir_index()
1494 data_len = delayed_item->data_len + sizeof(struct btrfs_item); in btrfs_insert_delayed_dir_index()
1496 mutex_lock(&delayed_node->mutex); in btrfs_insert_delayed_dir_index()
1500 * handling path simpler in case we fail (-EEXIST). There's no risk of in btrfs_insert_delayed_dir_index()
1503 * delayed node's mutex and that mutex must also be locked before the in btrfs_insert_delayed_dir_index()
1504 * node's delayed items can be run. in btrfs_insert_delayed_dir_index()
1508 btrfs_err(trans->fs_info, in btrfs_insert_delayed_dir_index()
1509 …layed dir index item, name: %.*s, index: %llu, root: %llu, dir: %llu, dir->index_cnt: %llu, delaye… in btrfs_insert_delayed_dir_index()
1510 name_len, name, index, btrfs_root_id(delayed_node->root), in btrfs_insert_delayed_dir_index()
1511 delayed_node->inode_id, dir->index_cnt, in btrfs_insert_delayed_dir_index()
1512 delayed_node->index_cnt, ret); in btrfs_insert_delayed_dir_index()
1515 mutex_unlock(&delayed_node->mutex); in btrfs_insert_delayed_dir_index()
1519 if (delayed_node->index_item_leaves == 0 || in btrfs_insert_delayed_dir_index()
1520 delayed_node->curr_index_batch_size + data_len > leaf_data_size) { in btrfs_insert_delayed_dir_index()
1521 delayed_node->curr_index_batch_size = data_len; in btrfs_insert_delayed_dir_index()
1524 delayed_node->curr_index_batch_size += data_len; in btrfs_insert_delayed_dir_index()
1537 mutex_unlock(&delayed_node->mutex); in btrfs_insert_delayed_dir_index()
1541 delayed_node->index_item_leaves++; in btrfs_insert_delayed_dir_index()
1545 mutex_unlock(&delayed_node->mutex); in btrfs_insert_delayed_dir_index()
1553 struct btrfs_delayed_node *node, in btrfs_delete_delayed_insertion_item() argument
1558 mutex_lock(&node->mutex); in btrfs_delete_delayed_insertion_item()
1559 item = __btrfs_lookup_delayed_item(&node->ins_root.rb_root, index); in btrfs_delete_delayed_insertion_item()
1561 mutex_unlock(&node->mutex); in btrfs_delete_delayed_insertion_item()
1571 ASSERT(item->bytes_reserved == 0); in btrfs_delete_delayed_insertion_item()
1572 ASSERT(node->index_item_leaves > 0); in btrfs_delete_delayed_insertion_item()
1581 if (node->index_item_leaves == 1) { in btrfs_delete_delayed_insertion_item()
1582 const u32 data_len = item->data_len + sizeof(struct btrfs_item); in btrfs_delete_delayed_insertion_item()
1584 ASSERT(node->curr_index_batch_size >= data_len); in btrfs_delete_delayed_insertion_item()
1585 node->curr_index_batch_size -= data_len; in btrfs_delete_delayed_insertion_item()
1591 if (RB_EMPTY_ROOT(&node->ins_root.rb_root)) { in btrfs_delete_delayed_insertion_item()
1592 btrfs_delayed_item_release_leaves(node, node->index_item_leaves); in btrfs_delete_delayed_insertion_item()
1593 node->index_item_leaves = 0; in btrfs_delete_delayed_insertion_item()
1596 mutex_unlock(&node->mutex); in btrfs_delete_delayed_insertion_item()
1603 struct btrfs_delayed_node *node; in btrfs_delete_delayed_dir_index() local
1607 node = btrfs_get_or_create_delayed_node(dir); in btrfs_delete_delayed_dir_index()
1608 if (IS_ERR(node)) in btrfs_delete_delayed_dir_index()
1609 return PTR_ERR(node); in btrfs_delete_delayed_dir_index()
1611 ret = btrfs_delete_delayed_insertion_item(trans->fs_info, node, index); in btrfs_delete_delayed_dir_index()
1615 item = btrfs_alloc_delayed_item(0, node, BTRFS_DELAYED_DELETION_ITEM); in btrfs_delete_delayed_dir_index()
1617 ret = -ENOMEM; in btrfs_delete_delayed_dir_index()
1621 item->index = index; in btrfs_delete_delayed_dir_index()
1629 btrfs_err(trans->fs_info, in btrfs_delete_delayed_dir_index()
1635 mutex_lock(&node->mutex); in btrfs_delete_delayed_dir_index()
1636 ret = __btrfs_add_delayed_item(node, item); in btrfs_delete_delayed_dir_index()
1638 btrfs_err(trans->fs_info, in btrfs_delete_delayed_dir_index()
1639 …"err add delayed dir index item(index: %llu) into the deletion tree of the delayed node(root id: %… in btrfs_delete_delayed_dir_index()
1640 index, node->root->root_key.objectid, in btrfs_delete_delayed_dir_index()
1641 node->inode_id, ret); in btrfs_delete_delayed_dir_index()
1642 btrfs_delayed_item_release_metadata(dir->root, item); in btrfs_delete_delayed_dir_index()
1645 mutex_unlock(&node->mutex); in btrfs_delete_delayed_dir_index()
1647 btrfs_release_delayed_node(node); in btrfs_delete_delayed_dir_index()
1656 return -ENOENT; in btrfs_inode_delayed_dir_index_count()
1660 * a new directory index is added into the delayed node and index_cnt in btrfs_inode_delayed_dir_index_count()
1661 * is updated now. So we needn't lock the delayed node. in btrfs_inode_delayed_dir_index_count()
1663 if (!delayed_node->index_cnt) { in btrfs_inode_delayed_dir_index_count()
1665 return -EINVAL; in btrfs_inode_delayed_dir_index_count()
1668 inode->index_cnt = delayed_node->index_cnt; in btrfs_inode_delayed_dir_index_count()
1687 * item->readdir_list. in btrfs_readdir_get_delayed_items()
1692 mutex_lock(&delayed_node->mutex); in btrfs_readdir_get_delayed_items()
1694 while (item && item->index <= last_index) { in btrfs_readdir_get_delayed_items()
1695 refcount_inc(&item->refs); in btrfs_readdir_get_delayed_items()
1696 list_add_tail(&item->readdir_list, ins_list); in btrfs_readdir_get_delayed_items()
1701 while (item && item->index <= last_index) { in btrfs_readdir_get_delayed_items()
1702 refcount_inc(&item->refs); in btrfs_readdir_get_delayed_items()
1703 list_add_tail(&item->readdir_list, del_list); in btrfs_readdir_get_delayed_items()
1706 mutex_unlock(&delayed_node->mutex); in btrfs_readdir_get_delayed_items()
1708 * This delayed node is still cached in the btrfs inode, so refs in btrfs_readdir_get_delayed_items()
1714 * requeue or dequeue this delayed node. in btrfs_readdir_get_delayed_items()
1716 refcount_dec(&delayed_node->refs); in btrfs_readdir_get_delayed_items()
1728 list_del(&curr->readdir_list); in btrfs_readdir_put_delayed_items()
1729 if (refcount_dec_and_test(&curr->refs)) in btrfs_readdir_put_delayed_items()
1734 list_del(&curr->readdir_list); in btrfs_readdir_put_delayed_items()
1735 if (refcount_dec_and_test(&curr->refs)) in btrfs_readdir_put_delayed_items()
1743 downgrade_write(&inode->i_rwsem); in btrfs_readdir_put_delayed_items()
1753 if (curr->index > index) in btrfs_should_delete_dir_index()
1755 if (curr->index == index) { in btrfs_should_delete_dir_index()
1764 * btrfs_readdir_delayed_dir_index - read dir info stored in the delayed tree
1784 list_del(&curr->readdir_list); in btrfs_readdir_delayed_dir_index()
1786 if (curr->index < ctx->pos) { in btrfs_readdir_delayed_dir_index()
1787 if (refcount_dec_and_test(&curr->refs)) in btrfs_readdir_delayed_dir_index()
1792 ctx->pos = curr->index; in btrfs_readdir_delayed_dir_index()
1794 di = (struct btrfs_dir_item *)curr->data; in btrfs_readdir_delayed_dir_index()
1798 d_type = fs_ftype_to_dtype(btrfs_dir_flags_to_ftype(di->type)); in btrfs_readdir_delayed_dir_index()
1799 btrfs_disk_key_to_cpu(&location, &di->location); in btrfs_readdir_delayed_dir_index()
1804 if (refcount_dec_and_test(&curr->refs)) in btrfs_readdir_delayed_dir_index()
1809 ctx->pos++; in btrfs_readdir_delayed_dir_index()
1822 btrfs_set_stack_inode_size(inode_item, BTRFS_I(inode)->disk_i_size); in fill_stack_inode_item()
1823 btrfs_set_stack_inode_mode(inode_item, inode->i_mode); in fill_stack_inode_item()
1824 btrfs_set_stack_inode_nlink(inode_item, inode->i_nlink); in fill_stack_inode_item()
1827 BTRFS_I(inode)->generation); in fill_stack_inode_item()
1830 btrfs_set_stack_inode_transid(inode_item, trans->transid); in fill_stack_inode_item()
1831 btrfs_set_stack_inode_rdev(inode_item, inode->i_rdev); in fill_stack_inode_item()
1832 flags = btrfs_inode_combine_flags(BTRFS_I(inode)->flags, in fill_stack_inode_item()
1833 BTRFS_I(inode)->ro_flags); in fill_stack_inode_item()
1837 btrfs_set_stack_timespec_sec(&inode_item->atime, in fill_stack_inode_item()
1838 inode->i_atime.tv_sec); in fill_stack_inode_item()
1839 btrfs_set_stack_timespec_nsec(&inode_item->atime, in fill_stack_inode_item()
1840 inode->i_atime.tv_nsec); in fill_stack_inode_item()
1842 btrfs_set_stack_timespec_sec(&inode_item->mtime, in fill_stack_inode_item()
1843 inode->i_mtime.tv_sec); in fill_stack_inode_item()
1844 btrfs_set_stack_timespec_nsec(&inode_item->mtime, in fill_stack_inode_item()
1845 inode->i_mtime.tv_nsec); in fill_stack_inode_item()
1847 btrfs_set_stack_timespec_sec(&inode_item->ctime, in fill_stack_inode_item()
1849 btrfs_set_stack_timespec_nsec(&inode_item->ctime, in fill_stack_inode_item()
1852 btrfs_set_stack_timespec_sec(&inode_item->otime, in fill_stack_inode_item()
1853 BTRFS_I(inode)->i_otime.tv_sec); in fill_stack_inode_item()
1854 btrfs_set_stack_timespec_nsec(&inode_item->otime, in fill_stack_inode_item()
1855 BTRFS_I(inode)->i_otime.tv_nsec); in fill_stack_inode_item()
1860 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; in btrfs_fill_inode()
1866 return -ENOENT; in btrfs_fill_inode()
1868 mutex_lock(&delayed_node->mutex); in btrfs_fill_inode()
1869 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { in btrfs_fill_inode()
1870 mutex_unlock(&delayed_node->mutex); in btrfs_fill_inode()
1872 return -ENOENT; in btrfs_fill_inode()
1875 inode_item = &delayed_node->inode_item; in btrfs_fill_inode()
1881 round_up(i_size_read(inode), fs_info->sectorsize)); in btrfs_fill_inode()
1882 inode->i_mode = btrfs_stack_inode_mode(inode_item); in btrfs_fill_inode()
1885 BTRFS_I(inode)->generation = btrfs_stack_inode_generation(inode_item); in btrfs_fill_inode()
1886 BTRFS_I(inode)->last_trans = btrfs_stack_inode_transid(inode_item); in btrfs_fill_inode()
1890 inode->i_rdev = 0; in btrfs_fill_inode()
1893 &BTRFS_I(inode)->flags, &BTRFS_I(inode)->ro_flags); in btrfs_fill_inode()
1895 inode->i_atime.tv_sec = btrfs_stack_timespec_sec(&inode_item->atime); in btrfs_fill_inode()
1896 inode->i_atime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->atime); in btrfs_fill_inode()
1898 inode->i_mtime.tv_sec = btrfs_stack_timespec_sec(&inode_item->mtime); in btrfs_fill_inode()
1899 inode->i_mtime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->mtime); in btrfs_fill_inode()
1901 inode_set_ctime(inode, btrfs_stack_timespec_sec(&inode_item->ctime), in btrfs_fill_inode()
1902 btrfs_stack_timespec_nsec(&inode_item->ctime)); in btrfs_fill_inode()
1904 BTRFS_I(inode)->i_otime.tv_sec = in btrfs_fill_inode()
1905 btrfs_stack_timespec_sec(&inode_item->otime); in btrfs_fill_inode()
1906 BTRFS_I(inode)->i_otime.tv_nsec = in btrfs_fill_inode()
1907 btrfs_stack_timespec_nsec(&inode_item->otime); in btrfs_fill_inode()
1909 inode->i_generation = BTRFS_I(inode)->generation; in btrfs_fill_inode()
1910 BTRFS_I(inode)->index_cnt = (u64)-1; in btrfs_fill_inode()
1912 mutex_unlock(&delayed_node->mutex); in btrfs_fill_inode()
1918 struct btrfs_root *root, in btrfs_delayed_update_inode() argument
1928 mutex_lock(&delayed_node->mutex); in btrfs_delayed_update_inode()
1929 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { in btrfs_delayed_update_inode()
1930 fill_stack_inode_item(trans, &delayed_node->inode_item, in btrfs_delayed_update_inode()
1931 &inode->vfs_inode); in btrfs_delayed_update_inode()
1935 ret = btrfs_delayed_inode_reserve_metadata(trans, root, delayed_node); in btrfs_delayed_update_inode()
1939 fill_stack_inode_item(trans, &delayed_node->inode_item, &inode->vfs_inode); in btrfs_delayed_update_inode()
1940 set_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags); in btrfs_delayed_update_inode()
1941 delayed_node->count++; in btrfs_delayed_update_inode()
1942 atomic_inc(&root->fs_info->delayed_root->items); in btrfs_delayed_update_inode()
1944 mutex_unlock(&delayed_node->mutex); in btrfs_delayed_update_inode()
1951 struct btrfs_fs_info *fs_info = inode->root->fs_info; in btrfs_delayed_delete_inode_ref()
1959 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) in btrfs_delayed_delete_inode_ref()
1960 return -EAGAIN; in btrfs_delayed_delete_inode_ref()
1968 * - We ONLY do async inode ref deletion for the inode who has only in btrfs_delayed_delete_inode_ref()
1974 * - If the inode ref and the inode item are not in the same leaf, in btrfs_delayed_delete_inode_ref()
1977 * - At the worst, we can steal some space from the global reservation. in btrfs_delayed_delete_inode_ref()
1980 mutex_lock(&delayed_node->mutex); in btrfs_delayed_delete_inode_ref()
1981 if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags)) in btrfs_delayed_delete_inode_ref()
1984 set_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags); in btrfs_delayed_delete_inode_ref()
1985 delayed_node->count++; in btrfs_delayed_delete_inode_ref()
1986 atomic_inc(&fs_info->delayed_root->items); in btrfs_delayed_delete_inode_ref()
1988 mutex_unlock(&delayed_node->mutex); in btrfs_delayed_delete_inode_ref()
1995 struct btrfs_root *root = delayed_node->root; in __btrfs_kill_delayed_node() local
1996 struct btrfs_fs_info *fs_info = root->fs_info; in __btrfs_kill_delayed_node()
1999 mutex_lock(&delayed_node->mutex); in __btrfs_kill_delayed_node()
2007 if (delayed_node->index_item_leaves > 0) { in __btrfs_kill_delayed_node()
2009 delayed_node->index_item_leaves); in __btrfs_kill_delayed_node()
2010 delayed_node->index_item_leaves = 0; in __btrfs_kill_delayed_node()
2015 btrfs_delayed_item_release_metadata(root, curr_item); in __btrfs_kill_delayed_node()
2023 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { in __btrfs_kill_delayed_node()
2027 mutex_unlock(&delayed_node->mutex); in __btrfs_kill_delayed_node()
2042 void btrfs_kill_all_delayed_nodes(struct btrfs_root *root) in btrfs_kill_all_delayed_nodes() argument
2049 spin_lock(&root->inode_lock); in btrfs_kill_all_delayed_nodes()
2050 n = radix_tree_gang_lookup(&root->delayed_nodes_tree, in btrfs_kill_all_delayed_nodes()
2054 spin_unlock(&root->inode_lock); in btrfs_kill_all_delayed_nodes()
2058 inode_id = delayed_nodes[n - 1]->inode_id + 1; in btrfs_kill_all_delayed_nodes()
2061 * Don't increase refs in case the node is dead and in btrfs_kill_all_delayed_nodes()
2064 if (!refcount_inc_not_zero(&delayed_nodes[i]->refs)) in btrfs_kill_all_delayed_nodes()
2067 spin_unlock(&root->inode_lock); in btrfs_kill_all_delayed_nodes()
2082 curr_node = btrfs_first_delayed_node(fs_info->delayed_root); in btrfs_destroy_delayed_inodes()
2096 struct btrfs_delayed_node *node; in btrfs_log_get_delayed_items() local
2099 node = btrfs_get_delayed_node(inode); in btrfs_log_get_delayed_items()
2100 if (!node) in btrfs_log_get_delayed_items()
2103 mutex_lock(&node->mutex); in btrfs_log_get_delayed_items()
2104 item = __btrfs_first_delayed_insertion_item(node); in btrfs_log_get_delayed_items()
2129 if (!item->logged && list_empty(&item->log_list)) { in btrfs_log_get_delayed_items()
2130 refcount_inc(&item->refs); in btrfs_log_get_delayed_items()
2131 list_add_tail(&item->log_list, ins_list); in btrfs_log_get_delayed_items()
2136 item = __btrfs_first_delayed_deletion_item(node); in btrfs_log_get_delayed_items()
2138 /* It may be non-empty, for the same reason mentioned above. */ in btrfs_log_get_delayed_items()
2139 if (!item->logged && list_empty(&item->log_list)) { in btrfs_log_get_delayed_items()
2140 refcount_inc(&item->refs); in btrfs_log_get_delayed_items()
2141 list_add_tail(&item->log_list, del_list); in btrfs_log_get_delayed_items()
2145 mutex_unlock(&node->mutex); in btrfs_log_get_delayed_items()
2156 ASSERT(refcount_read(&node->refs) > 1); in btrfs_log_get_delayed_items()
2157 refcount_dec(&node->refs); in btrfs_log_get_delayed_items()
2164 struct btrfs_delayed_node *node; in btrfs_log_put_delayed_items() local
2168 node = btrfs_get_delayed_node(inode); in btrfs_log_put_delayed_items()
2169 if (!node) in btrfs_log_put_delayed_items()
2172 mutex_lock(&node->mutex); in btrfs_log_put_delayed_items()
2175 item->logged = true; in btrfs_log_put_delayed_items()
2176 list_del_init(&item->log_list); in btrfs_log_put_delayed_items()
2177 if (refcount_dec_and_test(&item->refs)) in btrfs_log_put_delayed_items()
2182 item->logged = true; in btrfs_log_put_delayed_items()
2183 list_del_init(&item->log_list); in btrfs_log_put_delayed_items()
2184 if (refcount_dec_and_test(&item->refs)) in btrfs_log_put_delayed_items()
2188 mutex_unlock(&node->mutex); in btrfs_log_put_delayed_items()
2199 ASSERT(refcount_read(&node->refs) > 1); in btrfs_log_put_delayed_items()
2200 refcount_dec(&node->refs); in btrfs_log_put_delayed_items()