Loading...
1/*
2 * Copyright (C) 2007,2008 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19#include <linux/sched.h>
20#include <linux/slab.h>
21#include "ctree.h"
22#include "disk-io.h"
23#include "transaction.h"
24#include "print-tree.h"
25#include "locking.h"
26
27static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
28 *root, struct btrfs_path *path, int level);
29static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root
30 *root, struct btrfs_key *ins_key,
31 struct btrfs_path *path, int data_size, int extend);
32static int push_node_left(struct btrfs_trans_handle *trans,
33 struct btrfs_root *root, struct extent_buffer *dst,
34 struct extent_buffer *src, int empty);
35static int balance_node_right(struct btrfs_trans_handle *trans,
36 struct btrfs_root *root,
37 struct extent_buffer *dst_buf,
38 struct extent_buffer *src_buf);
39static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
40 struct btrfs_path *path, int level, int slot);
41
42struct btrfs_path *btrfs_alloc_path(void)
43{
44 struct btrfs_path *path;
45 path = kmem_cache_zalloc(btrfs_path_cachep, GFP_NOFS);
46 return path;
47}
48
49/*
50 * set all locked nodes in the path to blocking locks. This should
51 * be done before scheduling
52 */
53noinline void btrfs_set_path_blocking(struct btrfs_path *p)
54{
55 int i;
56 for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
57 if (!p->nodes[i] || !p->locks[i])
58 continue;
59 btrfs_set_lock_blocking_rw(p->nodes[i], p->locks[i]);
60 if (p->locks[i] == BTRFS_READ_LOCK)
61 p->locks[i] = BTRFS_READ_LOCK_BLOCKING;
62 else if (p->locks[i] == BTRFS_WRITE_LOCK)
63 p->locks[i] = BTRFS_WRITE_LOCK_BLOCKING;
64 }
65}
66
67/*
68 * reset all the locked nodes in the patch to spinning locks.
69 *
70 * held is used to keep lockdep happy, when lockdep is enabled
71 * we set held to a blocking lock before we go around and
72 * retake all the spinlocks in the path. You can safely use NULL
73 * for held
74 */
75noinline void btrfs_clear_path_blocking(struct btrfs_path *p,
76 struct extent_buffer *held, int held_rw)
77{
78 int i;
79
80#ifdef CONFIG_DEBUG_LOCK_ALLOC
81 /* lockdep really cares that we take all of these spinlocks
82 * in the right order. If any of the locks in the path are not
83 * currently blocking, it is going to complain. So, make really
84 * really sure by forcing the path to blocking before we clear
85 * the path blocking.
86 */
87 if (held) {
88 btrfs_set_lock_blocking_rw(held, held_rw);
89 if (held_rw == BTRFS_WRITE_LOCK)
90 held_rw = BTRFS_WRITE_LOCK_BLOCKING;
91 else if (held_rw == BTRFS_READ_LOCK)
92 held_rw = BTRFS_READ_LOCK_BLOCKING;
93 }
94 btrfs_set_path_blocking(p);
95#endif
96
97 for (i = BTRFS_MAX_LEVEL - 1; i >= 0; i--) {
98 if (p->nodes[i] && p->locks[i]) {
99 btrfs_clear_lock_blocking_rw(p->nodes[i], p->locks[i]);
100 if (p->locks[i] == BTRFS_WRITE_LOCK_BLOCKING)
101 p->locks[i] = BTRFS_WRITE_LOCK;
102 else if (p->locks[i] == BTRFS_READ_LOCK_BLOCKING)
103 p->locks[i] = BTRFS_READ_LOCK;
104 }
105 }
106
107#ifdef CONFIG_DEBUG_LOCK_ALLOC
108 if (held)
109 btrfs_clear_lock_blocking_rw(held, held_rw);
110#endif
111}
112
113/* this also releases the path */
114void btrfs_free_path(struct btrfs_path *p)
115{
116 if (!p)
117 return;
118 btrfs_release_path(p);
119 kmem_cache_free(btrfs_path_cachep, p);
120}
121
122/*
123 * path release drops references on the extent buffers in the path
124 * and it drops any locks held by this path
125 *
126 * It is safe to call this on paths that no locks or extent buffers held.
127 */
128noinline void btrfs_release_path(struct btrfs_path *p)
129{
130 int i;
131
132 for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
133 p->slots[i] = 0;
134 if (!p->nodes[i])
135 continue;
136 if (p->locks[i]) {
137 btrfs_tree_unlock_rw(p->nodes[i], p->locks[i]);
138 p->locks[i] = 0;
139 }
140 free_extent_buffer(p->nodes[i]);
141 p->nodes[i] = NULL;
142 }
143}
144
145/*
146 * safely gets a reference on the root node of a tree. A lock
147 * is not taken, so a concurrent writer may put a different node
148 * at the root of the tree. See btrfs_lock_root_node for the
149 * looping required.
150 *
151 * The extent buffer returned by this has a reference taken, so
152 * it won't disappear. It may stop being the root of the tree
153 * at any time because there are no locks held.
154 */
155struct extent_buffer *btrfs_root_node(struct btrfs_root *root)
156{
157 struct extent_buffer *eb;
158
159 rcu_read_lock();
160 eb = rcu_dereference(root->node);
161 extent_buffer_get(eb);
162 rcu_read_unlock();
163 return eb;
164}
165
166/* loop around taking references on and locking the root node of the
167 * tree until you end up with a lock on the root. A locked buffer
168 * is returned, with a reference held.
169 */
170struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root)
171{
172 struct extent_buffer *eb;
173
174 while (1) {
175 eb = btrfs_root_node(root);
176 btrfs_tree_lock(eb);
177 if (eb == root->node)
178 break;
179 btrfs_tree_unlock(eb);
180 free_extent_buffer(eb);
181 }
182 return eb;
183}
184
185/* loop around taking references on and locking the root node of the
186 * tree until you end up with a lock on the root. A locked buffer
187 * is returned, with a reference held.
188 */
189struct extent_buffer *btrfs_read_lock_root_node(struct btrfs_root *root)
190{
191 struct extent_buffer *eb;
192
193 while (1) {
194 eb = btrfs_root_node(root);
195 btrfs_tree_read_lock(eb);
196 if (eb == root->node)
197 break;
198 btrfs_tree_read_unlock(eb);
199 free_extent_buffer(eb);
200 }
201 return eb;
202}
203
204/* cowonly root (everything not a reference counted cow subvolume), just get
205 * put onto a simple dirty list. transaction.c walks this to make sure they
206 * get properly updated on disk.
207 */
208static void add_root_to_dirty_list(struct btrfs_root *root)
209{
210 if (root->track_dirty && list_empty(&root->dirty_list)) {
211 list_add(&root->dirty_list,
212 &root->fs_info->dirty_cowonly_roots);
213 }
214}
215
216/*
217 * used by snapshot creation to make a copy of a root for a tree with
218 * a given objectid. The buffer with the new root node is returned in
219 * cow_ret, and this func returns zero on success or a negative error code.
220 */
221int btrfs_copy_root(struct btrfs_trans_handle *trans,
222 struct btrfs_root *root,
223 struct extent_buffer *buf,
224 struct extent_buffer **cow_ret, u64 new_root_objectid)
225{
226 struct extent_buffer *cow;
227 int ret = 0;
228 int level;
229 struct btrfs_disk_key disk_key;
230
231 WARN_ON(root->ref_cows && trans->transid !=
232 root->fs_info->running_transaction->transid);
233 WARN_ON(root->ref_cows && trans->transid != root->last_trans);
234
235 level = btrfs_header_level(buf);
236 if (level == 0)
237 btrfs_item_key(buf, &disk_key, 0);
238 else
239 btrfs_node_key(buf, &disk_key, 0);
240
241 cow = btrfs_alloc_free_block(trans, root, buf->len, 0,
242 new_root_objectid, &disk_key, level,
243 buf->start, 0);
244 if (IS_ERR(cow))
245 return PTR_ERR(cow);
246
247 copy_extent_buffer(cow, buf, 0, 0, cow->len);
248 btrfs_set_header_bytenr(cow, cow->start);
249 btrfs_set_header_generation(cow, trans->transid);
250 btrfs_set_header_backref_rev(cow, BTRFS_MIXED_BACKREF_REV);
251 btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN |
252 BTRFS_HEADER_FLAG_RELOC);
253 if (new_root_objectid == BTRFS_TREE_RELOC_OBJECTID)
254 btrfs_set_header_flag(cow, BTRFS_HEADER_FLAG_RELOC);
255 else
256 btrfs_set_header_owner(cow, new_root_objectid);
257
258 write_extent_buffer(cow, root->fs_info->fsid,
259 (unsigned long)btrfs_header_fsid(cow),
260 BTRFS_FSID_SIZE);
261
262 WARN_ON(btrfs_header_generation(buf) > trans->transid);
263 if (new_root_objectid == BTRFS_TREE_RELOC_OBJECTID)
264 ret = btrfs_inc_ref(trans, root, cow, 1);
265 else
266 ret = btrfs_inc_ref(trans, root, cow, 0);
267
268 if (ret)
269 return ret;
270
271 btrfs_mark_buffer_dirty(cow);
272 *cow_ret = cow;
273 return 0;
274}
275
276/*
277 * check if the tree block can be shared by multiple trees
278 */
279int btrfs_block_can_be_shared(struct btrfs_root *root,
280 struct extent_buffer *buf)
281{
282 /*
283 * Tree blocks not in refernece counted trees and tree roots
284 * are never shared. If a block was allocated after the last
285 * snapshot and the block was not allocated by tree relocation,
286 * we know the block is not shared.
287 */
288 if (root->ref_cows &&
289 buf != root->node && buf != root->commit_root &&
290 (btrfs_header_generation(buf) <=
291 btrfs_root_last_snapshot(&root->root_item) ||
292 btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC)))
293 return 1;
294#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
295 if (root->ref_cows &&
296 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
297 return 1;
298#endif
299 return 0;
300}
301
302static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans,
303 struct btrfs_root *root,
304 struct extent_buffer *buf,
305 struct extent_buffer *cow,
306 int *last_ref)
307{
308 u64 refs;
309 u64 owner;
310 u64 flags;
311 u64 new_flags = 0;
312 int ret;
313
314 /*
315 * Backrefs update rules:
316 *
317 * Always use full backrefs for extent pointers in tree block
318 * allocated by tree relocation.
319 *
320 * If a shared tree block is no longer referenced by its owner
321 * tree (btrfs_header_owner(buf) == root->root_key.objectid),
322 * use full backrefs for extent pointers in tree block.
323 *
324 * If a tree block is been relocating
325 * (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID),
326 * use full backrefs for extent pointers in tree block.
327 * The reason for this is some operations (such as drop tree)
328 * are only allowed for blocks use full backrefs.
329 */
330
331 if (btrfs_block_can_be_shared(root, buf)) {
332 ret = btrfs_lookup_extent_info(trans, root, buf->start,
333 buf->len, &refs, &flags);
334 BUG_ON(ret);
335 BUG_ON(refs == 0);
336 } else {
337 refs = 1;
338 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
339 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
340 flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
341 else
342 flags = 0;
343 }
344
345 owner = btrfs_header_owner(buf);
346 BUG_ON(owner == BTRFS_TREE_RELOC_OBJECTID &&
347 !(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));
348
349 if (refs > 1) {
350 if ((owner == root->root_key.objectid ||
351 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) &&
352 !(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)) {
353 ret = btrfs_inc_ref(trans, root, buf, 1);
354 BUG_ON(ret);
355
356 if (root->root_key.objectid ==
357 BTRFS_TREE_RELOC_OBJECTID) {
358 ret = btrfs_dec_ref(trans, root, buf, 0);
359 BUG_ON(ret);
360 ret = btrfs_inc_ref(trans, root, cow, 1);
361 BUG_ON(ret);
362 }
363 new_flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
364 } else {
365
366 if (root->root_key.objectid ==
367 BTRFS_TREE_RELOC_OBJECTID)
368 ret = btrfs_inc_ref(trans, root, cow, 1);
369 else
370 ret = btrfs_inc_ref(trans, root, cow, 0);
371 BUG_ON(ret);
372 }
373 if (new_flags != 0) {
374 ret = btrfs_set_disk_extent_flags(trans, root,
375 buf->start,
376 buf->len,
377 new_flags, 0);
378 BUG_ON(ret);
379 }
380 } else {
381 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
382 if (root->root_key.objectid ==
383 BTRFS_TREE_RELOC_OBJECTID)
384 ret = btrfs_inc_ref(trans, root, cow, 1);
385 else
386 ret = btrfs_inc_ref(trans, root, cow, 0);
387 BUG_ON(ret);
388 ret = btrfs_dec_ref(trans, root, buf, 1);
389 BUG_ON(ret);
390 }
391 clean_tree_block(trans, root, buf);
392 *last_ref = 1;
393 }
394 return 0;
395}
396
397/*
398 * does the dirty work in cow of a single block. The parent block (if
399 * supplied) is updated to point to the new cow copy. The new buffer is marked
400 * dirty and returned locked. If you modify the block it needs to be marked
401 * dirty again.
402 *
403 * search_start -- an allocation hint for the new block
404 *
405 * empty_size -- a hint that you plan on doing more cow. This is the size in
406 * bytes the allocator should try to find free next to the block it returns.
407 * This is just a hint and may be ignored by the allocator.
408 */
409static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans,
410 struct btrfs_root *root,
411 struct extent_buffer *buf,
412 struct extent_buffer *parent, int parent_slot,
413 struct extent_buffer **cow_ret,
414 u64 search_start, u64 empty_size)
415{
416 struct btrfs_disk_key disk_key;
417 struct extent_buffer *cow;
418 int level;
419 int last_ref = 0;
420 int unlock_orig = 0;
421 u64 parent_start;
422
423 if (*cow_ret == buf)
424 unlock_orig = 1;
425
426 btrfs_assert_tree_locked(buf);
427
428 WARN_ON(root->ref_cows && trans->transid !=
429 root->fs_info->running_transaction->transid);
430 WARN_ON(root->ref_cows && trans->transid != root->last_trans);
431
432 level = btrfs_header_level(buf);
433
434 if (level == 0)
435 btrfs_item_key(buf, &disk_key, 0);
436 else
437 btrfs_node_key(buf, &disk_key, 0);
438
439 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
440 if (parent)
441 parent_start = parent->start;
442 else
443 parent_start = 0;
444 } else
445 parent_start = 0;
446
447 cow = btrfs_alloc_free_block(trans, root, buf->len, parent_start,
448 root->root_key.objectid, &disk_key,
449 level, search_start, empty_size);
450 if (IS_ERR(cow))
451 return PTR_ERR(cow);
452
453 /* cow is set to blocking by btrfs_init_new_buffer */
454
455 copy_extent_buffer(cow, buf, 0, 0, cow->len);
456 btrfs_set_header_bytenr(cow, cow->start);
457 btrfs_set_header_generation(cow, trans->transid);
458 btrfs_set_header_backref_rev(cow, BTRFS_MIXED_BACKREF_REV);
459 btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN |
460 BTRFS_HEADER_FLAG_RELOC);
461 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
462 btrfs_set_header_flag(cow, BTRFS_HEADER_FLAG_RELOC);
463 else
464 btrfs_set_header_owner(cow, root->root_key.objectid);
465
466 write_extent_buffer(cow, root->fs_info->fsid,
467 (unsigned long)btrfs_header_fsid(cow),
468 BTRFS_FSID_SIZE);
469
470 update_ref_for_cow(trans, root, buf, cow, &last_ref);
471
472 if (root->ref_cows)
473 btrfs_reloc_cow_block(trans, root, buf, cow);
474
475 if (buf == root->node) {
476 WARN_ON(parent && parent != buf);
477 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
478 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
479 parent_start = buf->start;
480 else
481 parent_start = 0;
482
483 extent_buffer_get(cow);
484 rcu_assign_pointer(root->node, cow);
485
486 btrfs_free_tree_block(trans, root, buf, parent_start,
487 last_ref);
488 free_extent_buffer(buf);
489 add_root_to_dirty_list(root);
490 } else {
491 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
492 parent_start = parent->start;
493 else
494 parent_start = 0;
495
496 WARN_ON(trans->transid != btrfs_header_generation(parent));
497 btrfs_set_node_blockptr(parent, parent_slot,
498 cow->start);
499 btrfs_set_node_ptr_generation(parent, parent_slot,
500 trans->transid);
501 btrfs_mark_buffer_dirty(parent);
502 btrfs_free_tree_block(trans, root, buf, parent_start,
503 last_ref);
504 }
505 if (unlock_orig)
506 btrfs_tree_unlock(buf);
507 free_extent_buffer(buf);
508 btrfs_mark_buffer_dirty(cow);
509 *cow_ret = cow;
510 return 0;
511}
512
513static inline int should_cow_block(struct btrfs_trans_handle *trans,
514 struct btrfs_root *root,
515 struct extent_buffer *buf)
516{
517 if (btrfs_header_generation(buf) == trans->transid &&
518 !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_WRITTEN) &&
519 !(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&
520 btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC)))
521 return 0;
522 return 1;
523}
524
525/*
526 * cows a single block, see __btrfs_cow_block for the real work.
527 * This version of it has extra checks so that a block isn't cow'd more than
528 * once per transaction, as long as it hasn't been written yet
529 */
530noinline int btrfs_cow_block(struct btrfs_trans_handle *trans,
531 struct btrfs_root *root, struct extent_buffer *buf,
532 struct extent_buffer *parent, int parent_slot,
533 struct extent_buffer **cow_ret)
534{
535 u64 search_start;
536 int ret;
537
538 if (trans->transaction != root->fs_info->running_transaction) {
539 printk(KERN_CRIT "trans %llu running %llu\n",
540 (unsigned long long)trans->transid,
541 (unsigned long long)
542 root->fs_info->running_transaction->transid);
543 WARN_ON(1);
544 }
545 if (trans->transid != root->fs_info->generation) {
546 printk(KERN_CRIT "trans %llu running %llu\n",
547 (unsigned long long)trans->transid,
548 (unsigned long long)root->fs_info->generation);
549 WARN_ON(1);
550 }
551
552 if (!should_cow_block(trans, root, buf)) {
553 *cow_ret = buf;
554 return 0;
555 }
556
557 search_start = buf->start & ~((u64)(1024 * 1024 * 1024) - 1);
558
559 if (parent)
560 btrfs_set_lock_blocking(parent);
561 btrfs_set_lock_blocking(buf);
562
563 ret = __btrfs_cow_block(trans, root, buf, parent,
564 parent_slot, cow_ret, search_start, 0);
565
566 trace_btrfs_cow_block(root, buf, *cow_ret);
567
568 return ret;
569}
570
571/*
572 * helper function for defrag to decide if two blocks pointed to by a
573 * node are actually close by
574 */
575static int close_blocks(u64 blocknr, u64 other, u32 blocksize)
576{
577 if (blocknr < other && other - (blocknr + blocksize) < 32768)
578 return 1;
579 if (blocknr > other && blocknr - (other + blocksize) < 32768)
580 return 1;
581 return 0;
582}
583
584/*
585 * compare two keys in a memcmp fashion
586 */
587static int comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
588{
589 struct btrfs_key k1;
590
591 btrfs_disk_key_to_cpu(&k1, disk);
592
593 return btrfs_comp_cpu_keys(&k1, k2);
594}
595
596/*
597 * same as comp_keys only with two btrfs_key's
598 */
599int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2)
600{
601 if (k1->objectid > k2->objectid)
602 return 1;
603 if (k1->objectid < k2->objectid)
604 return -1;
605 if (k1->type > k2->type)
606 return 1;
607 if (k1->type < k2->type)
608 return -1;
609 if (k1->offset > k2->offset)
610 return 1;
611 if (k1->offset < k2->offset)
612 return -1;
613 return 0;
614}
615
616/*
617 * this is used by the defrag code to go through all the
618 * leaves pointed to by a node and reallocate them so that
619 * disk order is close to key order
620 */
621int btrfs_realloc_node(struct btrfs_trans_handle *trans,
622 struct btrfs_root *root, struct extent_buffer *parent,
623 int start_slot, int cache_only, u64 *last_ret,
624 struct btrfs_key *progress)
625{
626 struct extent_buffer *cur;
627 u64 blocknr;
628 u64 gen;
629 u64 search_start = *last_ret;
630 u64 last_block = 0;
631 u64 other;
632 u32 parent_nritems;
633 int end_slot;
634 int i;
635 int err = 0;
636 int parent_level;
637 int uptodate;
638 u32 blocksize;
639 int progress_passed = 0;
640 struct btrfs_disk_key disk_key;
641
642 parent_level = btrfs_header_level(parent);
643 if (cache_only && parent_level != 1)
644 return 0;
645
646 if (trans->transaction != root->fs_info->running_transaction)
647 WARN_ON(1);
648 if (trans->transid != root->fs_info->generation)
649 WARN_ON(1);
650
651 parent_nritems = btrfs_header_nritems(parent);
652 blocksize = btrfs_level_size(root, parent_level - 1);
653 end_slot = parent_nritems;
654
655 if (parent_nritems == 1)
656 return 0;
657
658 btrfs_set_lock_blocking(parent);
659
660 for (i = start_slot; i < end_slot; i++) {
661 int close = 1;
662
663 btrfs_node_key(parent, &disk_key, i);
664 if (!progress_passed && comp_keys(&disk_key, progress) < 0)
665 continue;
666
667 progress_passed = 1;
668 blocknr = btrfs_node_blockptr(parent, i);
669 gen = btrfs_node_ptr_generation(parent, i);
670 if (last_block == 0)
671 last_block = blocknr;
672
673 if (i > 0) {
674 other = btrfs_node_blockptr(parent, i - 1);
675 close = close_blocks(blocknr, other, blocksize);
676 }
677 if (!close && i < end_slot - 2) {
678 other = btrfs_node_blockptr(parent, i + 1);
679 close = close_blocks(blocknr, other, blocksize);
680 }
681 if (close) {
682 last_block = blocknr;
683 continue;
684 }
685
686 cur = btrfs_find_tree_block(root, blocknr, blocksize);
687 if (cur)
688 uptodate = btrfs_buffer_uptodate(cur, gen);
689 else
690 uptodate = 0;
691 if (!cur || !uptodate) {
692 if (cache_only) {
693 free_extent_buffer(cur);
694 continue;
695 }
696 if (!cur) {
697 cur = read_tree_block(root, blocknr,
698 blocksize, gen);
699 if (!cur)
700 return -EIO;
701 } else if (!uptodate) {
702 btrfs_read_buffer(cur, gen);
703 }
704 }
705 if (search_start == 0)
706 search_start = last_block;
707
708 btrfs_tree_lock(cur);
709 btrfs_set_lock_blocking(cur);
710 err = __btrfs_cow_block(trans, root, cur, parent, i,
711 &cur, search_start,
712 min(16 * blocksize,
713 (end_slot - i) * blocksize));
714 if (err) {
715 btrfs_tree_unlock(cur);
716 free_extent_buffer(cur);
717 break;
718 }
719 search_start = cur->start;
720 last_block = cur->start;
721 *last_ret = search_start;
722 btrfs_tree_unlock(cur);
723 free_extent_buffer(cur);
724 }
725 return err;
726}
727
728/*
729 * The leaf data grows from end-to-front in the node.
730 * this returns the address of the start of the last item,
731 * which is the stop of the leaf data stack
732 */
733static inline unsigned int leaf_data_end(struct btrfs_root *root,
734 struct extent_buffer *leaf)
735{
736 u32 nr = btrfs_header_nritems(leaf);
737 if (nr == 0)
738 return BTRFS_LEAF_DATA_SIZE(root);
739 return btrfs_item_offset_nr(leaf, nr - 1);
740}
741
742
743/*
744 * search for key in the extent_buffer. The items start at offset p,
745 * and they are item_size apart. There are 'max' items in p.
746 *
747 * the slot in the array is returned via slot, and it points to
748 * the place where you would insert key if it is not found in
749 * the array.
750 *
751 * slot may point to max if the key is bigger than all of the keys
752 */
753static noinline int generic_bin_search(struct extent_buffer *eb,
754 unsigned long p,
755 int item_size, struct btrfs_key *key,
756 int max, int *slot)
757{
758 int low = 0;
759 int high = max;
760 int mid;
761 int ret;
762 struct btrfs_disk_key *tmp = NULL;
763 struct btrfs_disk_key unaligned;
764 unsigned long offset;
765 char *kaddr = NULL;
766 unsigned long map_start = 0;
767 unsigned long map_len = 0;
768 int err;
769
770 while (low < high) {
771 mid = (low + high) / 2;
772 offset = p + mid * item_size;
773
774 if (!kaddr || offset < map_start ||
775 (offset + sizeof(struct btrfs_disk_key)) >
776 map_start + map_len) {
777
778 err = map_private_extent_buffer(eb, offset,
779 sizeof(struct btrfs_disk_key),
780 &kaddr, &map_start, &map_len);
781
782 if (!err) {
783 tmp = (struct btrfs_disk_key *)(kaddr + offset -
784 map_start);
785 } else {
786 read_extent_buffer(eb, &unaligned,
787 offset, sizeof(unaligned));
788 tmp = &unaligned;
789 }
790
791 } else {
792 tmp = (struct btrfs_disk_key *)(kaddr + offset -
793 map_start);
794 }
795 ret = comp_keys(tmp, key);
796
797 if (ret < 0)
798 low = mid + 1;
799 else if (ret > 0)
800 high = mid;
801 else {
802 *slot = mid;
803 return 0;
804 }
805 }
806 *slot = low;
807 return 1;
808}
809
810/*
811 * simple bin_search frontend that does the right thing for
812 * leaves vs nodes
813 */
814static int bin_search(struct extent_buffer *eb, struct btrfs_key *key,
815 int level, int *slot)
816{
817 if (level == 0) {
818 return generic_bin_search(eb,
819 offsetof(struct btrfs_leaf, items),
820 sizeof(struct btrfs_item),
821 key, btrfs_header_nritems(eb),
822 slot);
823 } else {
824 return generic_bin_search(eb,
825 offsetof(struct btrfs_node, ptrs),
826 sizeof(struct btrfs_key_ptr),
827 key, btrfs_header_nritems(eb),
828 slot);
829 }
830 return -1;
831}
832
833int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
834 int level, int *slot)
835{
836 return bin_search(eb, key, level, slot);
837}
838
839static void root_add_used(struct btrfs_root *root, u32 size)
840{
841 spin_lock(&root->accounting_lock);
842 btrfs_set_root_used(&root->root_item,
843 btrfs_root_used(&root->root_item) + size);
844 spin_unlock(&root->accounting_lock);
845}
846
847static void root_sub_used(struct btrfs_root *root, u32 size)
848{
849 spin_lock(&root->accounting_lock);
850 btrfs_set_root_used(&root->root_item,
851 btrfs_root_used(&root->root_item) - size);
852 spin_unlock(&root->accounting_lock);
853}
854
855/* given a node and slot number, this reads the blocks it points to. The
856 * extent buffer is returned with a reference taken (but unlocked).
857 * NULL is returned on error.
858 */
859static noinline struct extent_buffer *read_node_slot(struct btrfs_root *root,
860 struct extent_buffer *parent, int slot)
861{
862 int level = btrfs_header_level(parent);
863 if (slot < 0)
864 return NULL;
865 if (slot >= btrfs_header_nritems(parent))
866 return NULL;
867
868 BUG_ON(level == 0);
869
870 return read_tree_block(root, btrfs_node_blockptr(parent, slot),
871 btrfs_level_size(root, level - 1),
872 btrfs_node_ptr_generation(parent, slot));
873}
874
875/*
876 * node level balancing, used to make sure nodes are in proper order for
877 * item deletion. We balance from the top down, so we have to make sure
878 * that a deletion won't leave an node completely empty later on.
879 */
880static noinline int balance_level(struct btrfs_trans_handle *trans,
881 struct btrfs_root *root,
882 struct btrfs_path *path, int level)
883{
884 struct extent_buffer *right = NULL;
885 struct extent_buffer *mid;
886 struct extent_buffer *left = NULL;
887 struct extent_buffer *parent = NULL;
888 int ret = 0;
889 int wret;
890 int pslot;
891 int orig_slot = path->slots[level];
892 u64 orig_ptr;
893
894 if (level == 0)
895 return 0;
896
897 mid = path->nodes[level];
898
899 WARN_ON(path->locks[level] != BTRFS_WRITE_LOCK &&
900 path->locks[level] != BTRFS_WRITE_LOCK_BLOCKING);
901 WARN_ON(btrfs_header_generation(mid) != trans->transid);
902
903 orig_ptr = btrfs_node_blockptr(mid, orig_slot);
904
905 if (level < BTRFS_MAX_LEVEL - 1)
906 parent = path->nodes[level + 1];
907 pslot = path->slots[level + 1];
908
909 /*
910 * deal with the case where there is only one pointer in the root
911 * by promoting the node below to a root
912 */
913 if (!parent) {
914 struct extent_buffer *child;
915
916 if (btrfs_header_nritems(mid) != 1)
917 return 0;
918
919 /* promote the child to a root */
920 child = read_node_slot(root, mid, 0);
921 BUG_ON(!child);
922 btrfs_tree_lock(child);
923 btrfs_set_lock_blocking(child);
924 ret = btrfs_cow_block(trans, root, child, mid, 0, &child);
925 if (ret) {
926 btrfs_tree_unlock(child);
927 free_extent_buffer(child);
928 goto enospc;
929 }
930
931 rcu_assign_pointer(root->node, child);
932
933 add_root_to_dirty_list(root);
934 btrfs_tree_unlock(child);
935
936 path->locks[level] = 0;
937 path->nodes[level] = NULL;
938 clean_tree_block(trans, root, mid);
939 btrfs_tree_unlock(mid);
940 /* once for the path */
941 free_extent_buffer(mid);
942
943 root_sub_used(root, mid->len);
944 btrfs_free_tree_block(trans, root, mid, 0, 1);
945 /* once for the root ptr */
946 free_extent_buffer(mid);
947 return 0;
948 }
949 if (btrfs_header_nritems(mid) >
950 BTRFS_NODEPTRS_PER_BLOCK(root) / 4)
951 return 0;
952
953 btrfs_header_nritems(mid);
954
955 left = read_node_slot(root, parent, pslot - 1);
956 if (left) {
957 btrfs_tree_lock(left);
958 btrfs_set_lock_blocking(left);
959 wret = btrfs_cow_block(trans, root, left,
960 parent, pslot - 1, &left);
961 if (wret) {
962 ret = wret;
963 goto enospc;
964 }
965 }
966 right = read_node_slot(root, parent, pslot + 1);
967 if (right) {
968 btrfs_tree_lock(right);
969 btrfs_set_lock_blocking(right);
970 wret = btrfs_cow_block(trans, root, right,
971 parent, pslot + 1, &right);
972 if (wret) {
973 ret = wret;
974 goto enospc;
975 }
976 }
977
978 /* first, try to make some room in the middle buffer */
979 if (left) {
980 orig_slot += btrfs_header_nritems(left);
981 wret = push_node_left(trans, root, left, mid, 1);
982 if (wret < 0)
983 ret = wret;
984 btrfs_header_nritems(mid);
985 }
986
987 /*
988 * then try to empty the right most buffer into the middle
989 */
990 if (right) {
991 wret = push_node_left(trans, root, mid, right, 1);
992 if (wret < 0 && wret != -ENOSPC)
993 ret = wret;
994 if (btrfs_header_nritems(right) == 0) {
995 clean_tree_block(trans, root, right);
996 btrfs_tree_unlock(right);
997 wret = del_ptr(trans, root, path, level + 1, pslot +
998 1);
999 if (wret)
1000 ret = wret;
1001 root_sub_used(root, right->len);
1002 btrfs_free_tree_block(trans, root, right, 0, 1);
1003 free_extent_buffer(right);
1004 right = NULL;
1005 } else {
1006 struct btrfs_disk_key right_key;
1007 btrfs_node_key(right, &right_key, 0);
1008 btrfs_set_node_key(parent, &right_key, pslot + 1);
1009 btrfs_mark_buffer_dirty(parent);
1010 }
1011 }
1012 if (btrfs_header_nritems(mid) == 1) {
1013 /*
1014 * we're not allowed to leave a node with one item in the
1015 * tree during a delete. A deletion from lower in the tree
1016 * could try to delete the only pointer in this node.
1017 * So, pull some keys from the left.
1018 * There has to be a left pointer at this point because
1019 * otherwise we would have pulled some pointers from the
1020 * right
1021 */
1022 BUG_ON(!left);
1023 wret = balance_node_right(trans, root, mid, left);
1024 if (wret < 0) {
1025 ret = wret;
1026 goto enospc;
1027 }
1028 if (wret == 1) {
1029 wret = push_node_left(trans, root, left, mid, 1);
1030 if (wret < 0)
1031 ret = wret;
1032 }
1033 BUG_ON(wret == 1);
1034 }
1035 if (btrfs_header_nritems(mid) == 0) {
1036 clean_tree_block(trans, root, mid);
1037 btrfs_tree_unlock(mid);
1038 wret = del_ptr(trans, root, path, level + 1, pslot);
1039 if (wret)
1040 ret = wret;
1041 root_sub_used(root, mid->len);
1042 btrfs_free_tree_block(trans, root, mid, 0, 1);
1043 free_extent_buffer(mid);
1044 mid = NULL;
1045 } else {
1046 /* update the parent key to reflect our changes */
1047 struct btrfs_disk_key mid_key;
1048 btrfs_node_key(mid, &mid_key, 0);
1049 btrfs_set_node_key(parent, &mid_key, pslot);
1050 btrfs_mark_buffer_dirty(parent);
1051 }
1052
1053 /* update the path */
1054 if (left) {
1055 if (btrfs_header_nritems(left) > orig_slot) {
1056 extent_buffer_get(left);
1057 /* left was locked after cow */
1058 path->nodes[level] = left;
1059 path->slots[level + 1] -= 1;
1060 path->slots[level] = orig_slot;
1061 if (mid) {
1062 btrfs_tree_unlock(mid);
1063 free_extent_buffer(mid);
1064 }
1065 } else {
1066 orig_slot -= btrfs_header_nritems(left);
1067 path->slots[level] = orig_slot;
1068 }
1069 }
1070 /* double check we haven't messed things up */
1071 if (orig_ptr !=
1072 btrfs_node_blockptr(path->nodes[level], path->slots[level]))
1073 BUG();
1074enospc:
1075 if (right) {
1076 btrfs_tree_unlock(right);
1077 free_extent_buffer(right);
1078 }
1079 if (left) {
1080 if (path->nodes[level] != left)
1081 btrfs_tree_unlock(left);
1082 free_extent_buffer(left);
1083 }
1084 return ret;
1085}
1086
1087/* Node balancing for insertion. Here we only split or push nodes around
1088 * when they are completely full. This is also done top down, so we
1089 * have to be pessimistic.
1090 */
1091static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans,
1092 struct btrfs_root *root,
1093 struct btrfs_path *path, int level)
1094{
1095 struct extent_buffer *right = NULL;
1096 struct extent_buffer *mid;
1097 struct extent_buffer *left = NULL;
1098 struct extent_buffer *parent = NULL;
1099 int ret = 0;
1100 int wret;
1101 int pslot;
1102 int orig_slot = path->slots[level];
1103
1104 if (level == 0)
1105 return 1;
1106
1107 mid = path->nodes[level];
1108 WARN_ON(btrfs_header_generation(mid) != trans->transid);
1109
1110 if (level < BTRFS_MAX_LEVEL - 1)
1111 parent = path->nodes[level + 1];
1112 pslot = path->slots[level + 1];
1113
1114 if (!parent)
1115 return 1;
1116
1117 left = read_node_slot(root, parent, pslot - 1);
1118
1119 /* first, try to make some room in the middle buffer */
1120 if (left) {
1121 u32 left_nr;
1122
1123 btrfs_tree_lock(left);
1124 btrfs_set_lock_blocking(left);
1125
1126 left_nr = btrfs_header_nritems(left);
1127 if (left_nr >= BTRFS_NODEPTRS_PER_BLOCK(root) - 1) {
1128 wret = 1;
1129 } else {
1130 ret = btrfs_cow_block(trans, root, left, parent,
1131 pslot - 1, &left);
1132 if (ret)
1133 wret = 1;
1134 else {
1135 wret = push_node_left(trans, root,
1136 left, mid, 0);
1137 }
1138 }
1139 if (wret < 0)
1140 ret = wret;
1141 if (wret == 0) {
1142 struct btrfs_disk_key disk_key;
1143 orig_slot += left_nr;
1144 btrfs_node_key(mid, &disk_key, 0);
1145 btrfs_set_node_key(parent, &disk_key, pslot);
1146 btrfs_mark_buffer_dirty(parent);
1147 if (btrfs_header_nritems(left) > orig_slot) {
1148 path->nodes[level] = left;
1149 path->slots[level + 1] -= 1;
1150 path->slots[level] = orig_slot;
1151 btrfs_tree_unlock(mid);
1152 free_extent_buffer(mid);
1153 } else {
1154 orig_slot -=
1155 btrfs_header_nritems(left);
1156 path->slots[level] = orig_slot;
1157 btrfs_tree_unlock(left);
1158 free_extent_buffer(left);
1159 }
1160 return 0;
1161 }
1162 btrfs_tree_unlock(left);
1163 free_extent_buffer(left);
1164 }
1165 right = read_node_slot(root, parent, pslot + 1);
1166
1167 /*
1168 * then try to empty the right most buffer into the middle
1169 */
1170 if (right) {
1171 u32 right_nr;
1172
1173 btrfs_tree_lock(right);
1174 btrfs_set_lock_blocking(right);
1175
1176 right_nr = btrfs_header_nritems(right);
1177 if (right_nr >= BTRFS_NODEPTRS_PER_BLOCK(root) - 1) {
1178 wret = 1;
1179 } else {
1180 ret = btrfs_cow_block(trans, root, right,
1181 parent, pslot + 1,
1182 &right);
1183 if (ret)
1184 wret = 1;
1185 else {
1186 wret = balance_node_right(trans, root,
1187 right, mid);
1188 }
1189 }
1190 if (wret < 0)
1191 ret = wret;
1192 if (wret == 0) {
1193 struct btrfs_disk_key disk_key;
1194
1195 btrfs_node_key(right, &disk_key, 0);
1196 btrfs_set_node_key(parent, &disk_key, pslot + 1);
1197 btrfs_mark_buffer_dirty(parent);
1198
1199 if (btrfs_header_nritems(mid) <= orig_slot) {
1200 path->nodes[level] = right;
1201 path->slots[level + 1] += 1;
1202 path->slots[level] = orig_slot -
1203 btrfs_header_nritems(mid);
1204 btrfs_tree_unlock(mid);
1205 free_extent_buffer(mid);
1206 } else {
1207 btrfs_tree_unlock(right);
1208 free_extent_buffer(right);
1209 }
1210 return 0;
1211 }
1212 btrfs_tree_unlock(right);
1213 free_extent_buffer(right);
1214 }
1215 return 1;
1216}
1217
1218/*
1219 * readahead one full node of leaves, finding things that are close
1220 * to the block in 'slot', and triggering ra on them.
1221 */
1222static void reada_for_search(struct btrfs_root *root,
1223 struct btrfs_path *path,
1224 int level, int slot, u64 objectid)
1225{
1226 struct extent_buffer *node;
1227 struct btrfs_disk_key disk_key;
1228 u32 nritems;
1229 u64 search;
1230 u64 target;
1231 u64 nread = 0;
1232 u64 gen;
1233 int direction = path->reada;
1234 struct extent_buffer *eb;
1235 u32 nr;
1236 u32 blocksize;
1237 u32 nscan = 0;
1238
1239 if (level != 1)
1240 return;
1241
1242 if (!path->nodes[level])
1243 return;
1244
1245 node = path->nodes[level];
1246
1247 search = btrfs_node_blockptr(node, slot);
1248 blocksize = btrfs_level_size(root, level - 1);
1249 eb = btrfs_find_tree_block(root, search, blocksize);
1250 if (eb) {
1251 free_extent_buffer(eb);
1252 return;
1253 }
1254
1255 target = search;
1256
1257 nritems = btrfs_header_nritems(node);
1258 nr = slot;
1259
1260 while (1) {
1261 if (direction < 0) {
1262 if (nr == 0)
1263 break;
1264 nr--;
1265 } else if (direction > 0) {
1266 nr++;
1267 if (nr >= nritems)
1268 break;
1269 }
1270 if (path->reada < 0 && objectid) {
1271 btrfs_node_key(node, &disk_key, nr);
1272 if (btrfs_disk_key_objectid(&disk_key) != objectid)
1273 break;
1274 }
1275 search = btrfs_node_blockptr(node, nr);
1276 if ((search <= target && target - search <= 65536) ||
1277 (search > target && search - target <= 65536)) {
1278 gen = btrfs_node_ptr_generation(node, nr);
1279 readahead_tree_block(root, search, blocksize, gen);
1280 nread += blocksize;
1281 }
1282 nscan++;
1283 if ((nread > 65536 || nscan > 32))
1284 break;
1285 }
1286}
1287
1288/*
1289 * returns -EAGAIN if it had to drop the path, or zero if everything was in
1290 * cache
1291 */
1292static noinline int reada_for_balance(struct btrfs_root *root,
1293 struct btrfs_path *path, int level)
1294{
1295 int slot;
1296 int nritems;
1297 struct extent_buffer *parent;
1298 struct extent_buffer *eb;
1299 u64 gen;
1300 u64 block1 = 0;
1301 u64 block2 = 0;
1302 int ret = 0;
1303 int blocksize;
1304
1305 parent = path->nodes[level + 1];
1306 if (!parent)
1307 return 0;
1308
1309 nritems = btrfs_header_nritems(parent);
1310 slot = path->slots[level + 1];
1311 blocksize = btrfs_level_size(root, level);
1312
1313 if (slot > 0) {
1314 block1 = btrfs_node_blockptr(parent, slot - 1);
1315 gen = btrfs_node_ptr_generation(parent, slot - 1);
1316 eb = btrfs_find_tree_block(root, block1, blocksize);
1317 if (eb && btrfs_buffer_uptodate(eb, gen))
1318 block1 = 0;
1319 free_extent_buffer(eb);
1320 }
1321 if (slot + 1 < nritems) {
1322 block2 = btrfs_node_blockptr(parent, slot + 1);
1323 gen = btrfs_node_ptr_generation(parent, slot + 1);
1324 eb = btrfs_find_tree_block(root, block2, blocksize);
1325 if (eb && btrfs_buffer_uptodate(eb, gen))
1326 block2 = 0;
1327 free_extent_buffer(eb);
1328 }
1329 if (block1 || block2) {
1330 ret = -EAGAIN;
1331
1332 /* release the whole path */
1333 btrfs_release_path(path);
1334
1335 /* read the blocks */
1336 if (block1)
1337 readahead_tree_block(root, block1, blocksize, 0);
1338 if (block2)
1339 readahead_tree_block(root, block2, blocksize, 0);
1340
1341 if (block1) {
1342 eb = read_tree_block(root, block1, blocksize, 0);
1343 free_extent_buffer(eb);
1344 }
1345 if (block2) {
1346 eb = read_tree_block(root, block2, blocksize, 0);
1347 free_extent_buffer(eb);
1348 }
1349 }
1350 return ret;
1351}
1352
1353
1354/*
1355 * when we walk down the tree, it is usually safe to unlock the higher layers
1356 * in the tree. The exceptions are when our path goes through slot 0, because
1357 * operations on the tree might require changing key pointers higher up in the
1358 * tree.
1359 *
1360 * callers might also have set path->keep_locks, which tells this code to keep
1361 * the lock if the path points to the last slot in the block. This is part of
1362 * walking through the tree, and selecting the next slot in the higher block.
1363 *
1364 * lowest_unlock sets the lowest level in the tree we're allowed to unlock. so
1365 * if lowest_unlock is 1, level 0 won't be unlocked
1366 */
1367static noinline void unlock_up(struct btrfs_path *path, int level,
1368 int lowest_unlock)
1369{
1370 int i;
1371 int skip_level = level;
1372 int no_skips = 0;
1373 struct extent_buffer *t;
1374
1375 for (i = level; i < BTRFS_MAX_LEVEL; i++) {
1376 if (!path->nodes[i])
1377 break;
1378 if (!path->locks[i])
1379 break;
1380 if (!no_skips && path->slots[i] == 0) {
1381 skip_level = i + 1;
1382 continue;
1383 }
1384 if (!no_skips && path->keep_locks) {
1385 u32 nritems;
1386 t = path->nodes[i];
1387 nritems = btrfs_header_nritems(t);
1388 if (nritems < 1 || path->slots[i] >= nritems - 1) {
1389 skip_level = i + 1;
1390 continue;
1391 }
1392 }
1393 if (skip_level < i && i >= lowest_unlock)
1394 no_skips = 1;
1395
1396 t = path->nodes[i];
1397 if (i >= lowest_unlock && i > skip_level && path->locks[i]) {
1398 btrfs_tree_unlock_rw(t, path->locks[i]);
1399 path->locks[i] = 0;
1400 }
1401 }
1402}
1403
1404/*
1405 * This releases any locks held in the path starting at level and
1406 * going all the way up to the root.
1407 *
1408 * btrfs_search_slot will keep the lock held on higher nodes in a few
1409 * corner cases, such as COW of the block at slot zero in the node. This
1410 * ignores those rules, and it should only be called when there are no
1411 * more updates to be done higher up in the tree.
1412 */
1413noinline void btrfs_unlock_up_safe(struct btrfs_path *path, int level)
1414{
1415 int i;
1416
1417 if (path->keep_locks)
1418 return;
1419
1420 for (i = level; i < BTRFS_MAX_LEVEL; i++) {
1421 if (!path->nodes[i])
1422 continue;
1423 if (!path->locks[i])
1424 continue;
1425 btrfs_tree_unlock_rw(path->nodes[i], path->locks[i]);
1426 path->locks[i] = 0;
1427 }
1428}
1429
1430/*
1431 * helper function for btrfs_search_slot. The goal is to find a block
1432 * in cache without setting the path to blocking. If we find the block
1433 * we return zero and the path is unchanged.
1434 *
1435 * If we can't find the block, we set the path blocking and do some
1436 * reada. -EAGAIN is returned and the search must be repeated.
1437 */
1438static int
1439read_block_for_search(struct btrfs_trans_handle *trans,
1440 struct btrfs_root *root, struct btrfs_path *p,
1441 struct extent_buffer **eb_ret, int level, int slot,
1442 struct btrfs_key *key)
1443{
1444 u64 blocknr;
1445 u64 gen;
1446 u32 blocksize;
1447 struct extent_buffer *b = *eb_ret;
1448 struct extent_buffer *tmp;
1449 int ret;
1450
1451 blocknr = btrfs_node_blockptr(b, slot);
1452 gen = btrfs_node_ptr_generation(b, slot);
1453 blocksize = btrfs_level_size(root, level - 1);
1454
1455 tmp = btrfs_find_tree_block(root, blocknr, blocksize);
1456 if (tmp) {
1457 if (btrfs_buffer_uptodate(tmp, 0)) {
1458 if (btrfs_buffer_uptodate(tmp, gen)) {
1459 /*
1460 * we found an up to date block without
1461 * sleeping, return
1462 * right away
1463 */
1464 *eb_ret = tmp;
1465 return 0;
1466 }
1467 /* the pages were up to date, but we failed
1468 * the generation number check. Do a full
1469 * read for the generation number that is correct.
1470 * We must do this without dropping locks so
1471 * we can trust our generation number
1472 */
1473 free_extent_buffer(tmp);
1474 btrfs_set_path_blocking(p);
1475
1476 tmp = read_tree_block(root, blocknr, blocksize, gen);
1477 if (tmp && btrfs_buffer_uptodate(tmp, gen)) {
1478 *eb_ret = tmp;
1479 return 0;
1480 }
1481 free_extent_buffer(tmp);
1482 btrfs_release_path(p);
1483 return -EIO;
1484 }
1485 }
1486
1487 /*
1488 * reduce lock contention at high levels
1489 * of the btree by dropping locks before
1490 * we read. Don't release the lock on the current
1491 * level because we need to walk this node to figure
1492 * out which blocks to read.
1493 */
1494 btrfs_unlock_up_safe(p, level + 1);
1495 btrfs_set_path_blocking(p);
1496
1497 free_extent_buffer(tmp);
1498 if (p->reada)
1499 reada_for_search(root, p, level, slot, key->objectid);
1500
1501 btrfs_release_path(p);
1502
1503 ret = -EAGAIN;
1504 tmp = read_tree_block(root, blocknr, blocksize, 0);
1505 if (tmp) {
1506 /*
1507 * If the read above didn't mark this buffer up to date,
1508 * it will never end up being up to date. Set ret to EIO now
1509 * and give up so that our caller doesn't loop forever
1510 * on our EAGAINs.
1511 */
1512 if (!btrfs_buffer_uptodate(tmp, 0))
1513 ret = -EIO;
1514 free_extent_buffer(tmp);
1515 }
1516 return ret;
1517}
1518
1519/*
1520 * helper function for btrfs_search_slot. This does all of the checks
1521 * for node-level blocks and does any balancing required based on
1522 * the ins_len.
1523 *
1524 * If no extra work was required, zero is returned. If we had to
1525 * drop the path, -EAGAIN is returned and btrfs_search_slot must
1526 * start over
1527 */
1528static int
1529setup_nodes_for_search(struct btrfs_trans_handle *trans,
1530 struct btrfs_root *root, struct btrfs_path *p,
1531 struct extent_buffer *b, int level, int ins_len,
1532 int *write_lock_level)
1533{
1534 int ret;
1535 if ((p->search_for_split || ins_len > 0) && btrfs_header_nritems(b) >=
1536 BTRFS_NODEPTRS_PER_BLOCK(root) - 3) {
1537 int sret;
1538
1539 if (*write_lock_level < level + 1) {
1540 *write_lock_level = level + 1;
1541 btrfs_release_path(p);
1542 goto again;
1543 }
1544
1545 sret = reada_for_balance(root, p, level);
1546 if (sret)
1547 goto again;
1548
1549 btrfs_set_path_blocking(p);
1550 sret = split_node(trans, root, p, level);
1551 btrfs_clear_path_blocking(p, NULL, 0);
1552
1553 BUG_ON(sret > 0);
1554 if (sret) {
1555 ret = sret;
1556 goto done;
1557 }
1558 b = p->nodes[level];
1559 } else if (ins_len < 0 && btrfs_header_nritems(b) <
1560 BTRFS_NODEPTRS_PER_BLOCK(root) / 2) {
1561 int sret;
1562
1563 if (*write_lock_level < level + 1) {
1564 *write_lock_level = level + 1;
1565 btrfs_release_path(p);
1566 goto again;
1567 }
1568
1569 sret = reada_for_balance(root, p, level);
1570 if (sret)
1571 goto again;
1572
1573 btrfs_set_path_blocking(p);
1574 sret = balance_level(trans, root, p, level);
1575 btrfs_clear_path_blocking(p, NULL, 0);
1576
1577 if (sret) {
1578 ret = sret;
1579 goto done;
1580 }
1581 b = p->nodes[level];
1582 if (!b) {
1583 btrfs_release_path(p);
1584 goto again;
1585 }
1586 BUG_ON(btrfs_header_nritems(b) == 1);
1587 }
1588 return 0;
1589
1590again:
1591 ret = -EAGAIN;
1592done:
1593 return ret;
1594}
1595
1596/*
1597 * look for key in the tree. path is filled in with nodes along the way
1598 * if key is found, we return zero and you can find the item in the leaf
1599 * level of the path (level 0)
1600 *
1601 * If the key isn't found, the path points to the slot where it should
1602 * be inserted, and 1 is returned. If there are other errors during the
1603 * search a negative error number is returned.
1604 *
1605 * if ins_len > 0, nodes and leaves will be split as we walk down the
1606 * tree. if ins_len < 0, nodes will be merged as we walk down the tree (if
1607 * possible)
1608 */
1609int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
1610 *root, struct btrfs_key *key, struct btrfs_path *p, int
1611 ins_len, int cow)
1612{
1613 struct extent_buffer *b;
1614 int slot;
1615 int ret;
1616 int err;
1617 int level;
1618 int lowest_unlock = 1;
1619 int root_lock;
1620 /* everything at write_lock_level or lower must be write locked */
1621 int write_lock_level = 0;
1622 u8 lowest_level = 0;
1623
1624 lowest_level = p->lowest_level;
1625 WARN_ON(lowest_level && ins_len > 0);
1626 WARN_ON(p->nodes[0] != NULL);
1627
1628 if (ins_len < 0) {
1629 lowest_unlock = 2;
1630
1631 /* when we are removing items, we might have to go up to level
1632 * two as we update tree pointers Make sure we keep write
1633 * for those levels as well
1634 */
1635 write_lock_level = 2;
1636 } else if (ins_len > 0) {
1637 /*
1638 * for inserting items, make sure we have a write lock on
1639 * level 1 so we can update keys
1640 */
1641 write_lock_level = 1;
1642 }
1643
1644 if (!cow)
1645 write_lock_level = -1;
1646
1647 if (cow && (p->keep_locks || p->lowest_level))
1648 write_lock_level = BTRFS_MAX_LEVEL;
1649
1650again:
1651 /*
1652 * we try very hard to do read locks on the root
1653 */
1654 root_lock = BTRFS_READ_LOCK;
1655 level = 0;
1656 if (p->search_commit_root) {
1657 /*
1658 * the commit roots are read only
1659 * so we always do read locks
1660 */
1661 b = root->commit_root;
1662 extent_buffer_get(b);
1663 level = btrfs_header_level(b);
1664 if (!p->skip_locking)
1665 btrfs_tree_read_lock(b);
1666 } else {
1667 if (p->skip_locking) {
1668 b = btrfs_root_node(root);
1669 level = btrfs_header_level(b);
1670 } else {
1671 /* we don't know the level of the root node
1672 * until we actually have it read locked
1673 */
1674 b = btrfs_read_lock_root_node(root);
1675 level = btrfs_header_level(b);
1676 if (level <= write_lock_level) {
1677 /* whoops, must trade for write lock */
1678 btrfs_tree_read_unlock(b);
1679 free_extent_buffer(b);
1680 b = btrfs_lock_root_node(root);
1681 root_lock = BTRFS_WRITE_LOCK;
1682
1683 /* the level might have changed, check again */
1684 level = btrfs_header_level(b);
1685 }
1686 }
1687 }
1688 p->nodes[level] = b;
1689 if (!p->skip_locking)
1690 p->locks[level] = root_lock;
1691
1692 while (b) {
1693 level = btrfs_header_level(b);
1694
1695 /*
1696 * setup the path here so we can release it under lock
1697 * contention with the cow code
1698 */
1699 if (cow) {
1700 /*
1701 * if we don't really need to cow this block
1702 * then we don't want to set the path blocking,
1703 * so we test it here
1704 */
1705 if (!should_cow_block(trans, root, b))
1706 goto cow_done;
1707
1708 btrfs_set_path_blocking(p);
1709
1710 /*
1711 * must have write locks on this node and the
1712 * parent
1713 */
1714 if (level + 1 > write_lock_level) {
1715 write_lock_level = level + 1;
1716 btrfs_release_path(p);
1717 goto again;
1718 }
1719
1720 err = btrfs_cow_block(trans, root, b,
1721 p->nodes[level + 1],
1722 p->slots[level + 1], &b);
1723 if (err) {
1724 ret = err;
1725 goto done;
1726 }
1727 }
1728cow_done:
1729 BUG_ON(!cow && ins_len);
1730
1731 p->nodes[level] = b;
1732 btrfs_clear_path_blocking(p, NULL, 0);
1733
1734 /*
1735 * we have a lock on b and as long as we aren't changing
1736 * the tree, there is no way to for the items in b to change.
1737 * It is safe to drop the lock on our parent before we
1738 * go through the expensive btree search on b.
1739 *
1740 * If cow is true, then we might be changing slot zero,
1741 * which may require changing the parent. So, we can't
1742 * drop the lock until after we know which slot we're
1743 * operating on.
1744 */
1745 if (!cow)
1746 btrfs_unlock_up_safe(p, level + 1);
1747
1748 ret = bin_search(b, key, level, &slot);
1749
1750 if (level != 0) {
1751 int dec = 0;
1752 if (ret && slot > 0) {
1753 dec = 1;
1754 slot -= 1;
1755 }
1756 p->slots[level] = slot;
1757 err = setup_nodes_for_search(trans, root, p, b, level,
1758 ins_len, &write_lock_level);
1759 if (err == -EAGAIN)
1760 goto again;
1761 if (err) {
1762 ret = err;
1763 goto done;
1764 }
1765 b = p->nodes[level];
1766 slot = p->slots[level];
1767
1768 /*
1769 * slot 0 is special, if we change the key
1770 * we have to update the parent pointer
1771 * which means we must have a write lock
1772 * on the parent
1773 */
1774 if (slot == 0 && cow &&
1775 write_lock_level < level + 1) {
1776 write_lock_level = level + 1;
1777 btrfs_release_path(p);
1778 goto again;
1779 }
1780
1781 unlock_up(p, level, lowest_unlock);
1782
1783 if (level == lowest_level) {
1784 if (dec)
1785 p->slots[level]++;
1786 goto done;
1787 }
1788
1789 err = read_block_for_search(trans, root, p,
1790 &b, level, slot, key);
1791 if (err == -EAGAIN)
1792 goto again;
1793 if (err) {
1794 ret = err;
1795 goto done;
1796 }
1797
1798 if (!p->skip_locking) {
1799 level = btrfs_header_level(b);
1800 if (level <= write_lock_level) {
1801 err = btrfs_try_tree_write_lock(b);
1802 if (!err) {
1803 btrfs_set_path_blocking(p);
1804 btrfs_tree_lock(b);
1805 btrfs_clear_path_blocking(p, b,
1806 BTRFS_WRITE_LOCK);
1807 }
1808 p->locks[level] = BTRFS_WRITE_LOCK;
1809 } else {
1810 err = btrfs_try_tree_read_lock(b);
1811 if (!err) {
1812 btrfs_set_path_blocking(p);
1813 btrfs_tree_read_lock(b);
1814 btrfs_clear_path_blocking(p, b,
1815 BTRFS_READ_LOCK);
1816 }
1817 p->locks[level] = BTRFS_READ_LOCK;
1818 }
1819 p->nodes[level] = b;
1820 }
1821 } else {
1822 p->slots[level] = slot;
1823 if (ins_len > 0 &&
1824 btrfs_leaf_free_space(root, b) < ins_len) {
1825 if (write_lock_level < 1) {
1826 write_lock_level = 1;
1827 btrfs_release_path(p);
1828 goto again;
1829 }
1830
1831 btrfs_set_path_blocking(p);
1832 err = split_leaf(trans, root, key,
1833 p, ins_len, ret == 0);
1834 btrfs_clear_path_blocking(p, NULL, 0);
1835
1836 BUG_ON(err > 0);
1837 if (err) {
1838 ret = err;
1839 goto done;
1840 }
1841 }
1842 if (!p->search_for_split)
1843 unlock_up(p, level, lowest_unlock);
1844 goto done;
1845 }
1846 }
1847 ret = 1;
1848done:
1849 /*
1850 * we don't really know what they plan on doing with the path
1851 * from here on, so for now just mark it as blocking
1852 */
1853 if (!p->leave_spinning)
1854 btrfs_set_path_blocking(p);
1855 if (ret < 0)
1856 btrfs_release_path(p);
1857 return ret;
1858}
1859
1860/*
1861 * adjust the pointers going up the tree, starting at level
1862 * making sure the right key of each node is points to 'key'.
1863 * This is used after shifting pointers to the left, so it stops
1864 * fixing up pointers when a given leaf/node is not in slot 0 of the
1865 * higher levels
1866 *
1867 * If this fails to write a tree block, it returns -1, but continues
1868 * fixing up the blocks in ram so the tree is consistent.
1869 */
1870static int fixup_low_keys(struct btrfs_trans_handle *trans,
1871 struct btrfs_root *root, struct btrfs_path *path,
1872 struct btrfs_disk_key *key, int level)
1873{
1874 int i;
1875 int ret = 0;
1876 struct extent_buffer *t;
1877
1878 for (i = level; i < BTRFS_MAX_LEVEL; i++) {
1879 int tslot = path->slots[i];
1880 if (!path->nodes[i])
1881 break;
1882 t = path->nodes[i];
1883 btrfs_set_node_key(t, key, tslot);
1884 btrfs_mark_buffer_dirty(path->nodes[i]);
1885 if (tslot != 0)
1886 break;
1887 }
1888 return ret;
1889}
1890
1891/*
1892 * update item key.
1893 *
1894 * This function isn't completely safe. It's the caller's responsibility
1895 * that the new key won't break the order
1896 */
1897int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans,
1898 struct btrfs_root *root, struct btrfs_path *path,
1899 struct btrfs_key *new_key)
1900{
1901 struct btrfs_disk_key disk_key;
1902 struct extent_buffer *eb;
1903 int slot;
1904
1905 eb = path->nodes[0];
1906 slot = path->slots[0];
1907 if (slot > 0) {
1908 btrfs_item_key(eb, &disk_key, slot - 1);
1909 if (comp_keys(&disk_key, new_key) >= 0)
1910 return -1;
1911 }
1912 if (slot < btrfs_header_nritems(eb) - 1) {
1913 btrfs_item_key(eb, &disk_key, slot + 1);
1914 if (comp_keys(&disk_key, new_key) <= 0)
1915 return -1;
1916 }
1917
1918 btrfs_cpu_key_to_disk(&disk_key, new_key);
1919 btrfs_set_item_key(eb, &disk_key, slot);
1920 btrfs_mark_buffer_dirty(eb);
1921 if (slot == 0)
1922 fixup_low_keys(trans, root, path, &disk_key, 1);
1923 return 0;
1924}
1925
1926/*
1927 * try to push data from one node into the next node left in the
1928 * tree.
1929 *
1930 * returns 0 if some ptrs were pushed left, < 0 if there was some horrible
1931 * error, and > 0 if there was no room in the left hand block.
1932 */
1933static int push_node_left(struct btrfs_trans_handle *trans,
1934 struct btrfs_root *root, struct extent_buffer *dst,
1935 struct extent_buffer *src, int empty)
1936{
1937 int push_items = 0;
1938 int src_nritems;
1939 int dst_nritems;
1940 int ret = 0;
1941
1942 src_nritems = btrfs_header_nritems(src);
1943 dst_nritems = btrfs_header_nritems(dst);
1944 push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
1945 WARN_ON(btrfs_header_generation(src) != trans->transid);
1946 WARN_ON(btrfs_header_generation(dst) != trans->transid);
1947
1948 if (!empty && src_nritems <= 8)
1949 return 1;
1950
1951 if (push_items <= 0)
1952 return 1;
1953
1954 if (empty) {
1955 push_items = min(src_nritems, push_items);
1956 if (push_items < src_nritems) {
1957 /* leave at least 8 pointers in the node if
1958 * we aren't going to empty it
1959 */
1960 if (src_nritems - push_items < 8) {
1961 if (push_items <= 8)
1962 return 1;
1963 push_items -= 8;
1964 }
1965 }
1966 } else
1967 push_items = min(src_nritems - 8, push_items);
1968
1969 copy_extent_buffer(dst, src,
1970 btrfs_node_key_ptr_offset(dst_nritems),
1971 btrfs_node_key_ptr_offset(0),
1972 push_items * sizeof(struct btrfs_key_ptr));
1973
1974 if (push_items < src_nritems) {
1975 memmove_extent_buffer(src, btrfs_node_key_ptr_offset(0),
1976 btrfs_node_key_ptr_offset(push_items),
1977 (src_nritems - push_items) *
1978 sizeof(struct btrfs_key_ptr));
1979 }
1980 btrfs_set_header_nritems(src, src_nritems - push_items);
1981 btrfs_set_header_nritems(dst, dst_nritems + push_items);
1982 btrfs_mark_buffer_dirty(src);
1983 btrfs_mark_buffer_dirty(dst);
1984
1985 return ret;
1986}
1987
1988/*
1989 * try to push data from one node into the next node right in the
1990 * tree.
1991 *
1992 * returns 0 if some ptrs were pushed, < 0 if there was some horrible
1993 * error, and > 0 if there was no room in the right hand block.
1994 *
1995 * this will only push up to 1/2 the contents of the left node over
1996 */
1997static int balance_node_right(struct btrfs_trans_handle *trans,
1998 struct btrfs_root *root,
1999 struct extent_buffer *dst,
2000 struct extent_buffer *src)
2001{
2002 int push_items = 0;
2003 int max_push;
2004 int src_nritems;
2005 int dst_nritems;
2006 int ret = 0;
2007
2008 WARN_ON(btrfs_header_generation(src) != trans->transid);
2009 WARN_ON(btrfs_header_generation(dst) != trans->transid);
2010
2011 src_nritems = btrfs_header_nritems(src);
2012 dst_nritems = btrfs_header_nritems(dst);
2013 push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
2014 if (push_items <= 0)
2015 return 1;
2016
2017 if (src_nritems < 4)
2018 return 1;
2019
2020 max_push = src_nritems / 2 + 1;
2021 /* don't try to empty the node */
2022 if (max_push >= src_nritems)
2023 return 1;
2024
2025 if (max_push < push_items)
2026 push_items = max_push;
2027
2028 memmove_extent_buffer(dst, btrfs_node_key_ptr_offset(push_items),
2029 btrfs_node_key_ptr_offset(0),
2030 (dst_nritems) *
2031 sizeof(struct btrfs_key_ptr));
2032
2033 copy_extent_buffer(dst, src,
2034 btrfs_node_key_ptr_offset(0),
2035 btrfs_node_key_ptr_offset(src_nritems - push_items),
2036 push_items * sizeof(struct btrfs_key_ptr));
2037
2038 btrfs_set_header_nritems(src, src_nritems - push_items);
2039 btrfs_set_header_nritems(dst, dst_nritems + push_items);
2040
2041 btrfs_mark_buffer_dirty(src);
2042 btrfs_mark_buffer_dirty(dst);
2043
2044 return ret;
2045}
2046
2047/*
2048 * helper function to insert a new root level in the tree.
2049 * A new node is allocated, and a single item is inserted to
2050 * point to the existing root
2051 *
2052 * returns zero on success or < 0 on failure.
2053 */
2054static noinline int insert_new_root(struct btrfs_trans_handle *trans,
2055 struct btrfs_root *root,
2056 struct btrfs_path *path, int level)
2057{
2058 u64 lower_gen;
2059 struct extent_buffer *lower;
2060 struct extent_buffer *c;
2061 struct extent_buffer *old;
2062 struct btrfs_disk_key lower_key;
2063
2064 BUG_ON(path->nodes[level]);
2065 BUG_ON(path->nodes[level-1] != root->node);
2066
2067 lower = path->nodes[level-1];
2068 if (level == 1)
2069 btrfs_item_key(lower, &lower_key, 0);
2070 else
2071 btrfs_node_key(lower, &lower_key, 0);
2072
2073 c = btrfs_alloc_free_block(trans, root, root->nodesize, 0,
2074 root->root_key.objectid, &lower_key,
2075 level, root->node->start, 0);
2076 if (IS_ERR(c))
2077 return PTR_ERR(c);
2078
2079 root_add_used(root, root->nodesize);
2080
2081 memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
2082 btrfs_set_header_nritems(c, 1);
2083 btrfs_set_header_level(c, level);
2084 btrfs_set_header_bytenr(c, c->start);
2085 btrfs_set_header_generation(c, trans->transid);
2086 btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
2087 btrfs_set_header_owner(c, root->root_key.objectid);
2088
2089 write_extent_buffer(c, root->fs_info->fsid,
2090 (unsigned long)btrfs_header_fsid(c),
2091 BTRFS_FSID_SIZE);
2092
2093 write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
2094 (unsigned long)btrfs_header_chunk_tree_uuid(c),
2095 BTRFS_UUID_SIZE);
2096
2097 btrfs_set_node_key(c, &lower_key, 0);
2098 btrfs_set_node_blockptr(c, 0, lower->start);
2099 lower_gen = btrfs_header_generation(lower);
2100 WARN_ON(lower_gen != trans->transid);
2101
2102 btrfs_set_node_ptr_generation(c, 0, lower_gen);
2103
2104 btrfs_mark_buffer_dirty(c);
2105
2106 old = root->node;
2107 rcu_assign_pointer(root->node, c);
2108
2109 /* the super has an extra ref to root->node */
2110 free_extent_buffer(old);
2111
2112 add_root_to_dirty_list(root);
2113 extent_buffer_get(c);
2114 path->nodes[level] = c;
2115 path->locks[level] = BTRFS_WRITE_LOCK;
2116 path->slots[level] = 0;
2117 return 0;
2118}
2119
2120/*
2121 * worker function to insert a single pointer in a node.
2122 * the node should have enough room for the pointer already
2123 *
2124 * slot and level indicate where you want the key to go, and
2125 * blocknr is the block the key points to.
2126 *
2127 * returns zero on success and < 0 on any error
2128 */
2129static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root
2130 *root, struct btrfs_path *path, struct btrfs_disk_key
2131 *key, u64 bytenr, int slot, int level)
2132{
2133 struct extent_buffer *lower;
2134 int nritems;
2135
2136 BUG_ON(!path->nodes[level]);
2137 btrfs_assert_tree_locked(path->nodes[level]);
2138 lower = path->nodes[level];
2139 nritems = btrfs_header_nritems(lower);
2140 BUG_ON(slot > nritems);
2141 if (nritems == BTRFS_NODEPTRS_PER_BLOCK(root))
2142 BUG();
2143 if (slot != nritems) {
2144 memmove_extent_buffer(lower,
2145 btrfs_node_key_ptr_offset(slot + 1),
2146 btrfs_node_key_ptr_offset(slot),
2147 (nritems - slot) * sizeof(struct btrfs_key_ptr));
2148 }
2149 btrfs_set_node_key(lower, key, slot);
2150 btrfs_set_node_blockptr(lower, slot, bytenr);
2151 WARN_ON(trans->transid == 0);
2152 btrfs_set_node_ptr_generation(lower, slot, trans->transid);
2153 btrfs_set_header_nritems(lower, nritems + 1);
2154 btrfs_mark_buffer_dirty(lower);
2155 return 0;
2156}
2157
2158/*
2159 * split the node at the specified level in path in two.
2160 * The path is corrected to point to the appropriate node after the split
2161 *
2162 * Before splitting this tries to make some room in the node by pushing
2163 * left and right, if either one works, it returns right away.
2164 *
2165 * returns 0 on success and < 0 on failure
2166 */
2167static noinline int split_node(struct btrfs_trans_handle *trans,
2168 struct btrfs_root *root,
2169 struct btrfs_path *path, int level)
2170{
2171 struct extent_buffer *c;
2172 struct extent_buffer *split;
2173 struct btrfs_disk_key disk_key;
2174 int mid;
2175 int ret;
2176 int wret;
2177 u32 c_nritems;
2178
2179 c = path->nodes[level];
2180 WARN_ON(btrfs_header_generation(c) != trans->transid);
2181 if (c == root->node) {
2182 /* trying to split the root, lets make a new one */
2183 ret = insert_new_root(trans, root, path, level + 1);
2184 if (ret)
2185 return ret;
2186 } else {
2187 ret = push_nodes_for_insert(trans, root, path, level);
2188 c = path->nodes[level];
2189 if (!ret && btrfs_header_nritems(c) <
2190 BTRFS_NODEPTRS_PER_BLOCK(root) - 3)
2191 return 0;
2192 if (ret < 0)
2193 return ret;
2194 }
2195
2196 c_nritems = btrfs_header_nritems(c);
2197 mid = (c_nritems + 1) / 2;
2198 btrfs_node_key(c, &disk_key, mid);
2199
2200 split = btrfs_alloc_free_block(trans, root, root->nodesize, 0,
2201 root->root_key.objectid,
2202 &disk_key, level, c->start, 0);
2203 if (IS_ERR(split))
2204 return PTR_ERR(split);
2205
2206 root_add_used(root, root->nodesize);
2207
2208 memset_extent_buffer(split, 0, 0, sizeof(struct btrfs_header));
2209 btrfs_set_header_level(split, btrfs_header_level(c));
2210 btrfs_set_header_bytenr(split, split->start);
2211 btrfs_set_header_generation(split, trans->transid);
2212 btrfs_set_header_backref_rev(split, BTRFS_MIXED_BACKREF_REV);
2213 btrfs_set_header_owner(split, root->root_key.objectid);
2214 write_extent_buffer(split, root->fs_info->fsid,
2215 (unsigned long)btrfs_header_fsid(split),
2216 BTRFS_FSID_SIZE);
2217 write_extent_buffer(split, root->fs_info->chunk_tree_uuid,
2218 (unsigned long)btrfs_header_chunk_tree_uuid(split),
2219 BTRFS_UUID_SIZE);
2220
2221
2222 copy_extent_buffer(split, c,
2223 btrfs_node_key_ptr_offset(0),
2224 btrfs_node_key_ptr_offset(mid),
2225 (c_nritems - mid) * sizeof(struct btrfs_key_ptr));
2226 btrfs_set_header_nritems(split, c_nritems - mid);
2227 btrfs_set_header_nritems(c, mid);
2228 ret = 0;
2229
2230 btrfs_mark_buffer_dirty(c);
2231 btrfs_mark_buffer_dirty(split);
2232
2233 wret = insert_ptr(trans, root, path, &disk_key, split->start,
2234 path->slots[level + 1] + 1,
2235 level + 1);
2236 if (wret)
2237 ret = wret;
2238
2239 if (path->slots[level] >= mid) {
2240 path->slots[level] -= mid;
2241 btrfs_tree_unlock(c);
2242 free_extent_buffer(c);
2243 path->nodes[level] = split;
2244 path->slots[level + 1] += 1;
2245 } else {
2246 btrfs_tree_unlock(split);
2247 free_extent_buffer(split);
2248 }
2249 return ret;
2250}
2251
2252/*
2253 * how many bytes are required to store the items in a leaf. start
2254 * and nr indicate which items in the leaf to check. This totals up the
2255 * space used both by the item structs and the item data
2256 */
2257static int leaf_space_used(struct extent_buffer *l, int start, int nr)
2258{
2259 int data_len;
2260 int nritems = btrfs_header_nritems(l);
2261 int end = min(nritems, start + nr) - 1;
2262
2263 if (!nr)
2264 return 0;
2265 data_len = btrfs_item_end_nr(l, start);
2266 data_len = data_len - btrfs_item_offset_nr(l, end);
2267 data_len += sizeof(struct btrfs_item) * nr;
2268 WARN_ON(data_len < 0);
2269 return data_len;
2270}
2271
2272/*
2273 * The space between the end of the leaf items and
2274 * the start of the leaf data. IOW, how much room
2275 * the leaf has left for both items and data
2276 */
2277noinline int btrfs_leaf_free_space(struct btrfs_root *root,
2278 struct extent_buffer *leaf)
2279{
2280 int nritems = btrfs_header_nritems(leaf);
2281 int ret;
2282 ret = BTRFS_LEAF_DATA_SIZE(root) - leaf_space_used(leaf, 0, nritems);
2283 if (ret < 0) {
2284 printk(KERN_CRIT "leaf free space ret %d, leaf data size %lu, "
2285 "used %d nritems %d\n",
2286 ret, (unsigned long) BTRFS_LEAF_DATA_SIZE(root),
2287 leaf_space_used(leaf, 0, nritems), nritems);
2288 }
2289 return ret;
2290}
2291
2292/*
2293 * min slot controls the lowest index we're willing to push to the
2294 * right. We'll push up to and including min_slot, but no lower
2295 */
2296static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
2297 struct btrfs_root *root,
2298 struct btrfs_path *path,
2299 int data_size, int empty,
2300 struct extent_buffer *right,
2301 int free_space, u32 left_nritems,
2302 u32 min_slot)
2303{
2304 struct extent_buffer *left = path->nodes[0];
2305 struct extent_buffer *upper = path->nodes[1];
2306 struct btrfs_disk_key disk_key;
2307 int slot;
2308 u32 i;
2309 int push_space = 0;
2310 int push_items = 0;
2311 struct btrfs_item *item;
2312 u32 nr;
2313 u32 right_nritems;
2314 u32 data_end;
2315 u32 this_item_size;
2316
2317 if (empty)
2318 nr = 0;
2319 else
2320 nr = max_t(u32, 1, min_slot);
2321
2322 if (path->slots[0] >= left_nritems)
2323 push_space += data_size;
2324
2325 slot = path->slots[1];
2326 i = left_nritems - 1;
2327 while (i >= nr) {
2328 item = btrfs_item_nr(left, i);
2329
2330 if (!empty && push_items > 0) {
2331 if (path->slots[0] > i)
2332 break;
2333 if (path->slots[0] == i) {
2334 int space = btrfs_leaf_free_space(root, left);
2335 if (space + push_space * 2 > free_space)
2336 break;
2337 }
2338 }
2339
2340 if (path->slots[0] == i)
2341 push_space += data_size;
2342
2343 this_item_size = btrfs_item_size(left, item);
2344 if (this_item_size + sizeof(*item) + push_space > free_space)
2345 break;
2346
2347 push_items++;
2348 push_space += this_item_size + sizeof(*item);
2349 if (i == 0)
2350 break;
2351 i--;
2352 }
2353
2354 if (push_items == 0)
2355 goto out_unlock;
2356
2357 if (!empty && push_items == left_nritems)
2358 WARN_ON(1);
2359
2360 /* push left to right */
2361 right_nritems = btrfs_header_nritems(right);
2362
2363 push_space = btrfs_item_end_nr(left, left_nritems - push_items);
2364 push_space -= leaf_data_end(root, left);
2365
2366 /* make room in the right data area */
2367 data_end = leaf_data_end(root, right);
2368 memmove_extent_buffer(right,
2369 btrfs_leaf_data(right) + data_end - push_space,
2370 btrfs_leaf_data(right) + data_end,
2371 BTRFS_LEAF_DATA_SIZE(root) - data_end);
2372
2373 /* copy from the left data area */
2374 copy_extent_buffer(right, left, btrfs_leaf_data(right) +
2375 BTRFS_LEAF_DATA_SIZE(root) - push_space,
2376 btrfs_leaf_data(left) + leaf_data_end(root, left),
2377 push_space);
2378
2379 memmove_extent_buffer(right, btrfs_item_nr_offset(push_items),
2380 btrfs_item_nr_offset(0),
2381 right_nritems * sizeof(struct btrfs_item));
2382
2383 /* copy the items from left to right */
2384 copy_extent_buffer(right, left, btrfs_item_nr_offset(0),
2385 btrfs_item_nr_offset(left_nritems - push_items),
2386 push_items * sizeof(struct btrfs_item));
2387
2388 /* update the item pointers */
2389 right_nritems += push_items;
2390 btrfs_set_header_nritems(right, right_nritems);
2391 push_space = BTRFS_LEAF_DATA_SIZE(root);
2392 for (i = 0; i < right_nritems; i++) {
2393 item = btrfs_item_nr(right, i);
2394 push_space -= btrfs_item_size(right, item);
2395 btrfs_set_item_offset(right, item, push_space);
2396 }
2397
2398 left_nritems -= push_items;
2399 btrfs_set_header_nritems(left, left_nritems);
2400
2401 if (left_nritems)
2402 btrfs_mark_buffer_dirty(left);
2403 else
2404 clean_tree_block(trans, root, left);
2405
2406 btrfs_mark_buffer_dirty(right);
2407
2408 btrfs_item_key(right, &disk_key, 0);
2409 btrfs_set_node_key(upper, &disk_key, slot + 1);
2410 btrfs_mark_buffer_dirty(upper);
2411
2412 /* then fixup the leaf pointer in the path */
2413 if (path->slots[0] >= left_nritems) {
2414 path->slots[0] -= left_nritems;
2415 if (btrfs_header_nritems(path->nodes[0]) == 0)
2416 clean_tree_block(trans, root, path->nodes[0]);
2417 btrfs_tree_unlock(path->nodes[0]);
2418 free_extent_buffer(path->nodes[0]);
2419 path->nodes[0] = right;
2420 path->slots[1] += 1;
2421 } else {
2422 btrfs_tree_unlock(right);
2423 free_extent_buffer(right);
2424 }
2425 return 0;
2426
2427out_unlock:
2428 btrfs_tree_unlock(right);
2429 free_extent_buffer(right);
2430 return 1;
2431}
2432
2433/*
2434 * push some data in the path leaf to the right, trying to free up at
2435 * least data_size bytes. returns zero if the push worked, nonzero otherwise
2436 *
2437 * returns 1 if the push failed because the other node didn't have enough
2438 * room, 0 if everything worked out and < 0 if there were major errors.
2439 *
2440 * this will push starting from min_slot to the end of the leaf. It won't
2441 * push any slot lower than min_slot
2442 */
2443static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
2444 *root, struct btrfs_path *path,
2445 int min_data_size, int data_size,
2446 int empty, u32 min_slot)
2447{
2448 struct extent_buffer *left = path->nodes[0];
2449 struct extent_buffer *right;
2450 struct extent_buffer *upper;
2451 int slot;
2452 int free_space;
2453 u32 left_nritems;
2454 int ret;
2455
2456 if (!path->nodes[1])
2457 return 1;
2458
2459 slot = path->slots[1];
2460 upper = path->nodes[1];
2461 if (slot >= btrfs_header_nritems(upper) - 1)
2462 return 1;
2463
2464 btrfs_assert_tree_locked(path->nodes[1]);
2465
2466 right = read_node_slot(root, upper, slot + 1);
2467 if (right == NULL)
2468 return 1;
2469
2470 btrfs_tree_lock(right);
2471 btrfs_set_lock_blocking(right);
2472
2473 free_space = btrfs_leaf_free_space(root, right);
2474 if (free_space < data_size)
2475 goto out_unlock;
2476
2477 /* cow and double check */
2478 ret = btrfs_cow_block(trans, root, right, upper,
2479 slot + 1, &right);
2480 if (ret)
2481 goto out_unlock;
2482
2483 free_space = btrfs_leaf_free_space(root, right);
2484 if (free_space < data_size)
2485 goto out_unlock;
2486
2487 left_nritems = btrfs_header_nritems(left);
2488 if (left_nritems == 0)
2489 goto out_unlock;
2490
2491 return __push_leaf_right(trans, root, path, min_data_size, empty,
2492 right, free_space, left_nritems, min_slot);
2493out_unlock:
2494 btrfs_tree_unlock(right);
2495 free_extent_buffer(right);
2496 return 1;
2497}
2498
2499/*
2500 * push some data in the path leaf to the left, trying to free up at
2501 * least data_size bytes. returns zero if the push worked, nonzero otherwise
2502 *
2503 * max_slot can put a limit on how far into the leaf we'll push items. The
2504 * item at 'max_slot' won't be touched. Use (u32)-1 to make us do all the
2505 * items
2506 */
2507static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
2508 struct btrfs_root *root,
2509 struct btrfs_path *path, int data_size,
2510 int empty, struct extent_buffer *left,
2511 int free_space, u32 right_nritems,
2512 u32 max_slot)
2513{
2514 struct btrfs_disk_key disk_key;
2515 struct extent_buffer *right = path->nodes[0];
2516 int i;
2517 int push_space = 0;
2518 int push_items = 0;
2519 struct btrfs_item *item;
2520 u32 old_left_nritems;
2521 u32 nr;
2522 int ret = 0;
2523 int wret;
2524 u32 this_item_size;
2525 u32 old_left_item_size;
2526
2527 if (empty)
2528 nr = min(right_nritems, max_slot);
2529 else
2530 nr = min(right_nritems - 1, max_slot);
2531
2532 for (i = 0; i < nr; i++) {
2533 item = btrfs_item_nr(right, i);
2534
2535 if (!empty && push_items > 0) {
2536 if (path->slots[0] < i)
2537 break;
2538 if (path->slots[0] == i) {
2539 int space = btrfs_leaf_free_space(root, right);
2540 if (space + push_space * 2 > free_space)
2541 break;
2542 }
2543 }
2544
2545 if (path->slots[0] == i)
2546 push_space += data_size;
2547
2548 this_item_size = btrfs_item_size(right, item);
2549 if (this_item_size + sizeof(*item) + push_space > free_space)
2550 break;
2551
2552 push_items++;
2553 push_space += this_item_size + sizeof(*item);
2554 }
2555
2556 if (push_items == 0) {
2557 ret = 1;
2558 goto out;
2559 }
2560 if (!empty && push_items == btrfs_header_nritems(right))
2561 WARN_ON(1);
2562
2563 /* push data from right to left */
2564 copy_extent_buffer(left, right,
2565 btrfs_item_nr_offset(btrfs_header_nritems(left)),
2566 btrfs_item_nr_offset(0),
2567 push_items * sizeof(struct btrfs_item));
2568
2569 push_space = BTRFS_LEAF_DATA_SIZE(root) -
2570 btrfs_item_offset_nr(right, push_items - 1);
2571
2572 copy_extent_buffer(left, right, btrfs_leaf_data(left) +
2573 leaf_data_end(root, left) - push_space,
2574 btrfs_leaf_data(right) +
2575 btrfs_item_offset_nr(right, push_items - 1),
2576 push_space);
2577 old_left_nritems = btrfs_header_nritems(left);
2578 BUG_ON(old_left_nritems <= 0);
2579
2580 old_left_item_size = btrfs_item_offset_nr(left, old_left_nritems - 1);
2581 for (i = old_left_nritems; i < old_left_nritems + push_items; i++) {
2582 u32 ioff;
2583
2584 item = btrfs_item_nr(left, i);
2585
2586 ioff = btrfs_item_offset(left, item);
2587 btrfs_set_item_offset(left, item,
2588 ioff - (BTRFS_LEAF_DATA_SIZE(root) - old_left_item_size));
2589 }
2590 btrfs_set_header_nritems(left, old_left_nritems + push_items);
2591
2592 /* fixup right node */
2593 if (push_items > right_nritems) {
2594 printk(KERN_CRIT "push items %d nr %u\n", push_items,
2595 right_nritems);
2596 WARN_ON(1);
2597 }
2598
2599 if (push_items < right_nritems) {
2600 push_space = btrfs_item_offset_nr(right, push_items - 1) -
2601 leaf_data_end(root, right);
2602 memmove_extent_buffer(right, btrfs_leaf_data(right) +
2603 BTRFS_LEAF_DATA_SIZE(root) - push_space,
2604 btrfs_leaf_data(right) +
2605 leaf_data_end(root, right), push_space);
2606
2607 memmove_extent_buffer(right, btrfs_item_nr_offset(0),
2608 btrfs_item_nr_offset(push_items),
2609 (btrfs_header_nritems(right) - push_items) *
2610 sizeof(struct btrfs_item));
2611 }
2612 right_nritems -= push_items;
2613 btrfs_set_header_nritems(right, right_nritems);
2614 push_space = BTRFS_LEAF_DATA_SIZE(root);
2615 for (i = 0; i < right_nritems; i++) {
2616 item = btrfs_item_nr(right, i);
2617
2618 push_space = push_space - btrfs_item_size(right, item);
2619 btrfs_set_item_offset(right, item, push_space);
2620 }
2621
2622 btrfs_mark_buffer_dirty(left);
2623 if (right_nritems)
2624 btrfs_mark_buffer_dirty(right);
2625 else
2626 clean_tree_block(trans, root, right);
2627
2628 btrfs_item_key(right, &disk_key, 0);
2629 wret = fixup_low_keys(trans, root, path, &disk_key, 1);
2630 if (wret)
2631 ret = wret;
2632
2633 /* then fixup the leaf pointer in the path */
2634 if (path->slots[0] < push_items) {
2635 path->slots[0] += old_left_nritems;
2636 btrfs_tree_unlock(path->nodes[0]);
2637 free_extent_buffer(path->nodes[0]);
2638 path->nodes[0] = left;
2639 path->slots[1] -= 1;
2640 } else {
2641 btrfs_tree_unlock(left);
2642 free_extent_buffer(left);
2643 path->slots[0] -= push_items;
2644 }
2645 BUG_ON(path->slots[0] < 0);
2646 return ret;
2647out:
2648 btrfs_tree_unlock(left);
2649 free_extent_buffer(left);
2650 return ret;
2651}
2652
2653/*
2654 * push some data in the path leaf to the left, trying to free up at
2655 * least data_size bytes. returns zero if the push worked, nonzero otherwise
2656 *
2657 * max_slot can put a limit on how far into the leaf we'll push items. The
2658 * item at 'max_slot' won't be touched. Use (u32)-1 to make us push all the
2659 * items
2660 */
2661static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
2662 *root, struct btrfs_path *path, int min_data_size,
2663 int data_size, int empty, u32 max_slot)
2664{
2665 struct extent_buffer *right = path->nodes[0];
2666 struct extent_buffer *left;
2667 int slot;
2668 int free_space;
2669 u32 right_nritems;
2670 int ret = 0;
2671
2672 slot = path->slots[1];
2673 if (slot == 0)
2674 return 1;
2675 if (!path->nodes[1])
2676 return 1;
2677
2678 right_nritems = btrfs_header_nritems(right);
2679 if (right_nritems == 0)
2680 return 1;
2681
2682 btrfs_assert_tree_locked(path->nodes[1]);
2683
2684 left = read_node_slot(root, path->nodes[1], slot - 1);
2685 if (left == NULL)
2686 return 1;
2687
2688 btrfs_tree_lock(left);
2689 btrfs_set_lock_blocking(left);
2690
2691 free_space = btrfs_leaf_free_space(root, left);
2692 if (free_space < data_size) {
2693 ret = 1;
2694 goto out;
2695 }
2696
2697 /* cow and double check */
2698 ret = btrfs_cow_block(trans, root, left,
2699 path->nodes[1], slot - 1, &left);
2700 if (ret) {
2701 /* we hit -ENOSPC, but it isn't fatal here */
2702 ret = 1;
2703 goto out;
2704 }
2705
2706 free_space = btrfs_leaf_free_space(root, left);
2707 if (free_space < data_size) {
2708 ret = 1;
2709 goto out;
2710 }
2711
2712 return __push_leaf_left(trans, root, path, min_data_size,
2713 empty, left, free_space, right_nritems,
2714 max_slot);
2715out:
2716 btrfs_tree_unlock(left);
2717 free_extent_buffer(left);
2718 return ret;
2719}
2720
2721/*
2722 * split the path's leaf in two, making sure there is at least data_size
2723 * available for the resulting leaf level of the path.
2724 *
2725 * returns 0 if all went well and < 0 on failure.
2726 */
2727static noinline int copy_for_split(struct btrfs_trans_handle *trans,
2728 struct btrfs_root *root,
2729 struct btrfs_path *path,
2730 struct extent_buffer *l,
2731 struct extent_buffer *right,
2732 int slot, int mid, int nritems)
2733{
2734 int data_copy_size;
2735 int rt_data_off;
2736 int i;
2737 int ret = 0;
2738 int wret;
2739 struct btrfs_disk_key disk_key;
2740
2741 nritems = nritems - mid;
2742 btrfs_set_header_nritems(right, nritems);
2743 data_copy_size = btrfs_item_end_nr(l, mid) - leaf_data_end(root, l);
2744
2745 copy_extent_buffer(right, l, btrfs_item_nr_offset(0),
2746 btrfs_item_nr_offset(mid),
2747 nritems * sizeof(struct btrfs_item));
2748
2749 copy_extent_buffer(right, l,
2750 btrfs_leaf_data(right) + BTRFS_LEAF_DATA_SIZE(root) -
2751 data_copy_size, btrfs_leaf_data(l) +
2752 leaf_data_end(root, l), data_copy_size);
2753
2754 rt_data_off = BTRFS_LEAF_DATA_SIZE(root) -
2755 btrfs_item_end_nr(l, mid);
2756
2757 for (i = 0; i < nritems; i++) {
2758 struct btrfs_item *item = btrfs_item_nr(right, i);
2759 u32 ioff;
2760
2761 ioff = btrfs_item_offset(right, item);
2762 btrfs_set_item_offset(right, item, ioff + rt_data_off);
2763 }
2764
2765 btrfs_set_header_nritems(l, mid);
2766 ret = 0;
2767 btrfs_item_key(right, &disk_key, 0);
2768 wret = insert_ptr(trans, root, path, &disk_key, right->start,
2769 path->slots[1] + 1, 1);
2770 if (wret)
2771 ret = wret;
2772
2773 btrfs_mark_buffer_dirty(right);
2774 btrfs_mark_buffer_dirty(l);
2775 BUG_ON(path->slots[0] != slot);
2776
2777 if (mid <= slot) {
2778 btrfs_tree_unlock(path->nodes[0]);
2779 free_extent_buffer(path->nodes[0]);
2780 path->nodes[0] = right;
2781 path->slots[0] -= mid;
2782 path->slots[1] += 1;
2783 } else {
2784 btrfs_tree_unlock(right);
2785 free_extent_buffer(right);
2786 }
2787
2788 BUG_ON(path->slots[0] < 0);
2789
2790 return ret;
2791}
2792
2793/*
2794 * double splits happen when we need to insert a big item in the middle
2795 * of a leaf. A double split can leave us with 3 mostly empty leaves:
2796 * leaf: [ slots 0 - N] [ our target ] [ N + 1 - total in leaf ]
2797 * A B C
2798 *
2799 * We avoid this by trying to push the items on either side of our target
2800 * into the adjacent leaves. If all goes well we can avoid the double split
2801 * completely.
2802 */
2803static noinline int push_for_double_split(struct btrfs_trans_handle *trans,
2804 struct btrfs_root *root,
2805 struct btrfs_path *path,
2806 int data_size)
2807{
2808 int ret;
2809 int progress = 0;
2810 int slot;
2811 u32 nritems;
2812
2813 slot = path->slots[0];
2814
2815 /*
2816 * try to push all the items after our slot into the
2817 * right leaf
2818 */
2819 ret = push_leaf_right(trans, root, path, 1, data_size, 0, slot);
2820 if (ret < 0)
2821 return ret;
2822
2823 if (ret == 0)
2824 progress++;
2825
2826 nritems = btrfs_header_nritems(path->nodes[0]);
2827 /*
2828 * our goal is to get our slot at the start or end of a leaf. If
2829 * we've done so we're done
2830 */
2831 if (path->slots[0] == 0 || path->slots[0] == nritems)
2832 return 0;
2833
2834 if (btrfs_leaf_free_space(root, path->nodes[0]) >= data_size)
2835 return 0;
2836
2837 /* try to push all the items before our slot into the next leaf */
2838 slot = path->slots[0];
2839 ret = push_leaf_left(trans, root, path, 1, data_size, 0, slot);
2840 if (ret < 0)
2841 return ret;
2842
2843 if (ret == 0)
2844 progress++;
2845
2846 if (progress)
2847 return 0;
2848 return 1;
2849}
2850
2851/*
2852 * split the path's leaf in two, making sure there is at least data_size
2853 * available for the resulting leaf level of the path.
2854 *
2855 * returns 0 if all went well and < 0 on failure.
2856 */
2857static noinline int split_leaf(struct btrfs_trans_handle *trans,
2858 struct btrfs_root *root,
2859 struct btrfs_key *ins_key,
2860 struct btrfs_path *path, int data_size,
2861 int extend)
2862{
2863 struct btrfs_disk_key disk_key;
2864 struct extent_buffer *l;
2865 u32 nritems;
2866 int mid;
2867 int slot;
2868 struct extent_buffer *right;
2869 int ret = 0;
2870 int wret;
2871 int split;
2872 int num_doubles = 0;
2873 int tried_avoid_double = 0;
2874
2875 l = path->nodes[0];
2876 slot = path->slots[0];
2877 if (extend && data_size + btrfs_item_size_nr(l, slot) +
2878 sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root))
2879 return -EOVERFLOW;
2880
2881 /* first try to make some room by pushing left and right */
2882 if (data_size) {
2883 wret = push_leaf_right(trans, root, path, data_size,
2884 data_size, 0, 0);
2885 if (wret < 0)
2886 return wret;
2887 if (wret) {
2888 wret = push_leaf_left(trans, root, path, data_size,
2889 data_size, 0, (u32)-1);
2890 if (wret < 0)
2891 return wret;
2892 }
2893 l = path->nodes[0];
2894
2895 /* did the pushes work? */
2896 if (btrfs_leaf_free_space(root, l) >= data_size)
2897 return 0;
2898 }
2899
2900 if (!path->nodes[1]) {
2901 ret = insert_new_root(trans, root, path, 1);
2902 if (ret)
2903 return ret;
2904 }
2905again:
2906 split = 1;
2907 l = path->nodes[0];
2908 slot = path->slots[0];
2909 nritems = btrfs_header_nritems(l);
2910 mid = (nritems + 1) / 2;
2911
2912 if (mid <= slot) {
2913 if (nritems == 1 ||
2914 leaf_space_used(l, mid, nritems - mid) + data_size >
2915 BTRFS_LEAF_DATA_SIZE(root)) {
2916 if (slot >= nritems) {
2917 split = 0;
2918 } else {
2919 mid = slot;
2920 if (mid != nritems &&
2921 leaf_space_used(l, mid, nritems - mid) +
2922 data_size > BTRFS_LEAF_DATA_SIZE(root)) {
2923 if (data_size && !tried_avoid_double)
2924 goto push_for_double;
2925 split = 2;
2926 }
2927 }
2928 }
2929 } else {
2930 if (leaf_space_used(l, 0, mid) + data_size >
2931 BTRFS_LEAF_DATA_SIZE(root)) {
2932 if (!extend && data_size && slot == 0) {
2933 split = 0;
2934 } else if ((extend || !data_size) && slot == 0) {
2935 mid = 1;
2936 } else {
2937 mid = slot;
2938 if (mid != nritems &&
2939 leaf_space_used(l, mid, nritems - mid) +
2940 data_size > BTRFS_LEAF_DATA_SIZE(root)) {
2941 if (data_size && !tried_avoid_double)
2942 goto push_for_double;
2943 split = 2 ;
2944 }
2945 }
2946 }
2947 }
2948
2949 if (split == 0)
2950 btrfs_cpu_key_to_disk(&disk_key, ins_key);
2951 else
2952 btrfs_item_key(l, &disk_key, mid);
2953
2954 right = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
2955 root->root_key.objectid,
2956 &disk_key, 0, l->start, 0);
2957 if (IS_ERR(right))
2958 return PTR_ERR(right);
2959
2960 root_add_used(root, root->leafsize);
2961
2962 memset_extent_buffer(right, 0, 0, sizeof(struct btrfs_header));
2963 btrfs_set_header_bytenr(right, right->start);
2964 btrfs_set_header_generation(right, trans->transid);
2965 btrfs_set_header_backref_rev(right, BTRFS_MIXED_BACKREF_REV);
2966 btrfs_set_header_owner(right, root->root_key.objectid);
2967 btrfs_set_header_level(right, 0);
2968 write_extent_buffer(right, root->fs_info->fsid,
2969 (unsigned long)btrfs_header_fsid(right),
2970 BTRFS_FSID_SIZE);
2971
2972 write_extent_buffer(right, root->fs_info->chunk_tree_uuid,
2973 (unsigned long)btrfs_header_chunk_tree_uuid(right),
2974 BTRFS_UUID_SIZE);
2975
2976 if (split == 0) {
2977 if (mid <= slot) {
2978 btrfs_set_header_nritems(right, 0);
2979 wret = insert_ptr(trans, root, path,
2980 &disk_key, right->start,
2981 path->slots[1] + 1, 1);
2982 if (wret)
2983 ret = wret;
2984
2985 btrfs_tree_unlock(path->nodes[0]);
2986 free_extent_buffer(path->nodes[0]);
2987 path->nodes[0] = right;
2988 path->slots[0] = 0;
2989 path->slots[1] += 1;
2990 } else {
2991 btrfs_set_header_nritems(right, 0);
2992 wret = insert_ptr(trans, root, path,
2993 &disk_key,
2994 right->start,
2995 path->slots[1], 1);
2996 if (wret)
2997 ret = wret;
2998 btrfs_tree_unlock(path->nodes[0]);
2999 free_extent_buffer(path->nodes[0]);
3000 path->nodes[0] = right;
3001 path->slots[0] = 0;
3002 if (path->slots[1] == 0) {
3003 wret = fixup_low_keys(trans, root,
3004 path, &disk_key, 1);
3005 if (wret)
3006 ret = wret;
3007 }
3008 }
3009 btrfs_mark_buffer_dirty(right);
3010 return ret;
3011 }
3012
3013 ret = copy_for_split(trans, root, path, l, right, slot, mid, nritems);
3014 BUG_ON(ret);
3015
3016 if (split == 2) {
3017 BUG_ON(num_doubles != 0);
3018 num_doubles++;
3019 goto again;
3020 }
3021
3022 return ret;
3023
3024push_for_double:
3025 push_for_double_split(trans, root, path, data_size);
3026 tried_avoid_double = 1;
3027 if (btrfs_leaf_free_space(root, path->nodes[0]) >= data_size)
3028 return 0;
3029 goto again;
3030}
3031
3032static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans,
3033 struct btrfs_root *root,
3034 struct btrfs_path *path, int ins_len)
3035{
3036 struct btrfs_key key;
3037 struct extent_buffer *leaf;
3038 struct btrfs_file_extent_item *fi;
3039 u64 extent_len = 0;
3040 u32 item_size;
3041 int ret;
3042
3043 leaf = path->nodes[0];
3044 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
3045
3046 BUG_ON(key.type != BTRFS_EXTENT_DATA_KEY &&
3047 key.type != BTRFS_EXTENT_CSUM_KEY);
3048
3049 if (btrfs_leaf_free_space(root, leaf) >= ins_len)
3050 return 0;
3051
3052 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
3053 if (key.type == BTRFS_EXTENT_DATA_KEY) {
3054 fi = btrfs_item_ptr(leaf, path->slots[0],
3055 struct btrfs_file_extent_item);
3056 extent_len = btrfs_file_extent_num_bytes(leaf, fi);
3057 }
3058 btrfs_release_path(path);
3059
3060 path->keep_locks = 1;
3061 path->search_for_split = 1;
3062 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
3063 path->search_for_split = 0;
3064 if (ret < 0)
3065 goto err;
3066
3067 ret = -EAGAIN;
3068 leaf = path->nodes[0];
3069 /* if our item isn't there or got smaller, return now */
3070 if (ret > 0 || item_size != btrfs_item_size_nr(leaf, path->slots[0]))
3071 goto err;
3072
3073 /* the leaf has changed, it now has room. return now */
3074 if (btrfs_leaf_free_space(root, path->nodes[0]) >= ins_len)
3075 goto err;
3076
3077 if (key.type == BTRFS_EXTENT_DATA_KEY) {
3078 fi = btrfs_item_ptr(leaf, path->slots[0],
3079 struct btrfs_file_extent_item);
3080 if (extent_len != btrfs_file_extent_num_bytes(leaf, fi))
3081 goto err;
3082 }
3083
3084 btrfs_set_path_blocking(path);
3085 ret = split_leaf(trans, root, &key, path, ins_len, 1);
3086 if (ret)
3087 goto err;
3088
3089 path->keep_locks = 0;
3090 btrfs_unlock_up_safe(path, 1);
3091 return 0;
3092err:
3093 path->keep_locks = 0;
3094 return ret;
3095}
3096
3097static noinline int split_item(struct btrfs_trans_handle *trans,
3098 struct btrfs_root *root,
3099 struct btrfs_path *path,
3100 struct btrfs_key *new_key,
3101 unsigned long split_offset)
3102{
3103 struct extent_buffer *leaf;
3104 struct btrfs_item *item;
3105 struct btrfs_item *new_item;
3106 int slot;
3107 char *buf;
3108 u32 nritems;
3109 u32 item_size;
3110 u32 orig_offset;
3111 struct btrfs_disk_key disk_key;
3112
3113 leaf = path->nodes[0];
3114 BUG_ON(btrfs_leaf_free_space(root, leaf) < sizeof(struct btrfs_item));
3115
3116 btrfs_set_path_blocking(path);
3117
3118 item = btrfs_item_nr(leaf, path->slots[0]);
3119 orig_offset = btrfs_item_offset(leaf, item);
3120 item_size = btrfs_item_size(leaf, item);
3121
3122 buf = kmalloc(item_size, GFP_NOFS);
3123 if (!buf)
3124 return -ENOMEM;
3125
3126 read_extent_buffer(leaf, buf, btrfs_item_ptr_offset(leaf,
3127 path->slots[0]), item_size);
3128
3129 slot = path->slots[0] + 1;
3130 nritems = btrfs_header_nritems(leaf);
3131 if (slot != nritems) {
3132 /* shift the items */
3133 memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + 1),
3134 btrfs_item_nr_offset(slot),
3135 (nritems - slot) * sizeof(struct btrfs_item));
3136 }
3137
3138 btrfs_cpu_key_to_disk(&disk_key, new_key);
3139 btrfs_set_item_key(leaf, &disk_key, slot);
3140
3141 new_item = btrfs_item_nr(leaf, slot);
3142
3143 btrfs_set_item_offset(leaf, new_item, orig_offset);
3144 btrfs_set_item_size(leaf, new_item, item_size - split_offset);
3145
3146 btrfs_set_item_offset(leaf, item,
3147 orig_offset + item_size - split_offset);
3148 btrfs_set_item_size(leaf, item, split_offset);
3149
3150 btrfs_set_header_nritems(leaf, nritems + 1);
3151
3152 /* write the data for the start of the original item */
3153 write_extent_buffer(leaf, buf,
3154 btrfs_item_ptr_offset(leaf, path->slots[0]),
3155 split_offset);
3156
3157 /* write the data for the new item */
3158 write_extent_buffer(leaf, buf + split_offset,
3159 btrfs_item_ptr_offset(leaf, slot),
3160 item_size - split_offset);
3161 btrfs_mark_buffer_dirty(leaf);
3162
3163 BUG_ON(btrfs_leaf_free_space(root, leaf) < 0);
3164 kfree(buf);
3165 return 0;
3166}
3167
3168/*
3169 * This function splits a single item into two items,
3170 * giving 'new_key' to the new item and splitting the
3171 * old one at split_offset (from the start of the item).
3172 *
3173 * The path may be released by this operation. After
3174 * the split, the path is pointing to the old item. The
3175 * new item is going to be in the same node as the old one.
3176 *
3177 * Note, the item being split must be smaller enough to live alone on
3178 * a tree block with room for one extra struct btrfs_item
3179 *
3180 * This allows us to split the item in place, keeping a lock on the
3181 * leaf the entire time.
3182 */
3183int btrfs_split_item(struct btrfs_trans_handle *trans,
3184 struct btrfs_root *root,
3185 struct btrfs_path *path,
3186 struct btrfs_key *new_key,
3187 unsigned long split_offset)
3188{
3189 int ret;
3190 ret = setup_leaf_for_split(trans, root, path,
3191 sizeof(struct btrfs_item));
3192 if (ret)
3193 return ret;
3194
3195 ret = split_item(trans, root, path, new_key, split_offset);
3196 return ret;
3197}
3198
3199/*
3200 * This function duplicate a item, giving 'new_key' to the new item.
3201 * It guarantees both items live in the same tree leaf and the new item
3202 * is contiguous with the original item.
3203 *
3204 * This allows us to split file extent in place, keeping a lock on the
3205 * leaf the entire time.
3206 */
3207int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
3208 struct btrfs_root *root,
3209 struct btrfs_path *path,
3210 struct btrfs_key *new_key)
3211{
3212 struct extent_buffer *leaf;
3213 int ret;
3214 u32 item_size;
3215
3216 leaf = path->nodes[0];
3217 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
3218 ret = setup_leaf_for_split(trans, root, path,
3219 item_size + sizeof(struct btrfs_item));
3220 if (ret)
3221 return ret;
3222
3223 path->slots[0]++;
3224 ret = setup_items_for_insert(trans, root, path, new_key, &item_size,
3225 item_size, item_size +
3226 sizeof(struct btrfs_item), 1);
3227 BUG_ON(ret);
3228
3229 leaf = path->nodes[0];
3230 memcpy_extent_buffer(leaf,
3231 btrfs_item_ptr_offset(leaf, path->slots[0]),
3232 btrfs_item_ptr_offset(leaf, path->slots[0] - 1),
3233 item_size);
3234 return 0;
3235}
3236
3237/*
3238 * make the item pointed to by the path smaller. new_size indicates
3239 * how small to make it, and from_end tells us if we just chop bytes
3240 * off the end of the item or if we shift the item to chop bytes off
3241 * the front.
3242 */
3243int btrfs_truncate_item(struct btrfs_trans_handle *trans,
3244 struct btrfs_root *root,
3245 struct btrfs_path *path,
3246 u32 new_size, int from_end)
3247{
3248 int slot;
3249 struct extent_buffer *leaf;
3250 struct btrfs_item *item;
3251 u32 nritems;
3252 unsigned int data_end;
3253 unsigned int old_data_start;
3254 unsigned int old_size;
3255 unsigned int size_diff;
3256 int i;
3257
3258 leaf = path->nodes[0];
3259 slot = path->slots[0];
3260
3261 old_size = btrfs_item_size_nr(leaf, slot);
3262 if (old_size == new_size)
3263 return 0;
3264
3265 nritems = btrfs_header_nritems(leaf);
3266 data_end = leaf_data_end(root, leaf);
3267
3268 old_data_start = btrfs_item_offset_nr(leaf, slot);
3269
3270 size_diff = old_size - new_size;
3271
3272 BUG_ON(slot < 0);
3273 BUG_ON(slot >= nritems);
3274
3275 /*
3276 * item0..itemN ... dataN.offset..dataN.size .. data0.size
3277 */
3278 /* first correct the data pointers */
3279 for (i = slot; i < nritems; i++) {
3280 u32 ioff;
3281 item = btrfs_item_nr(leaf, i);
3282
3283 ioff = btrfs_item_offset(leaf, item);
3284 btrfs_set_item_offset(leaf, item, ioff + size_diff);
3285 }
3286
3287 /* shift the data */
3288 if (from_end) {
3289 memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
3290 data_end + size_diff, btrfs_leaf_data(leaf) +
3291 data_end, old_data_start + new_size - data_end);
3292 } else {
3293 struct btrfs_disk_key disk_key;
3294 u64 offset;
3295
3296 btrfs_item_key(leaf, &disk_key, slot);
3297
3298 if (btrfs_disk_key_type(&disk_key) == BTRFS_EXTENT_DATA_KEY) {
3299 unsigned long ptr;
3300 struct btrfs_file_extent_item *fi;
3301
3302 fi = btrfs_item_ptr(leaf, slot,
3303 struct btrfs_file_extent_item);
3304 fi = (struct btrfs_file_extent_item *)(
3305 (unsigned long)fi - size_diff);
3306
3307 if (btrfs_file_extent_type(leaf, fi) ==
3308 BTRFS_FILE_EXTENT_INLINE) {
3309 ptr = btrfs_item_ptr_offset(leaf, slot);
3310 memmove_extent_buffer(leaf, ptr,
3311 (unsigned long)fi,
3312 offsetof(struct btrfs_file_extent_item,
3313 disk_bytenr));
3314 }
3315 }
3316
3317 memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
3318 data_end + size_diff, btrfs_leaf_data(leaf) +
3319 data_end, old_data_start - data_end);
3320
3321 offset = btrfs_disk_key_offset(&disk_key);
3322 btrfs_set_disk_key_offset(&disk_key, offset + size_diff);
3323 btrfs_set_item_key(leaf, &disk_key, slot);
3324 if (slot == 0)
3325 fixup_low_keys(trans, root, path, &disk_key, 1);
3326 }
3327
3328 item = btrfs_item_nr(leaf, slot);
3329 btrfs_set_item_size(leaf, item, new_size);
3330 btrfs_mark_buffer_dirty(leaf);
3331
3332 if (btrfs_leaf_free_space(root, leaf) < 0) {
3333 btrfs_print_leaf(root, leaf);
3334 BUG();
3335 }
3336 return 0;
3337}
3338
3339/*
3340 * make the item pointed to by the path bigger, data_size is the new size.
3341 */
3342int btrfs_extend_item(struct btrfs_trans_handle *trans,
3343 struct btrfs_root *root, struct btrfs_path *path,
3344 u32 data_size)
3345{
3346 int slot;
3347 struct extent_buffer *leaf;
3348 struct btrfs_item *item;
3349 u32 nritems;
3350 unsigned int data_end;
3351 unsigned int old_data;
3352 unsigned int old_size;
3353 int i;
3354
3355 leaf = path->nodes[0];
3356
3357 nritems = btrfs_header_nritems(leaf);
3358 data_end = leaf_data_end(root, leaf);
3359
3360 if (btrfs_leaf_free_space(root, leaf) < data_size) {
3361 btrfs_print_leaf(root, leaf);
3362 BUG();
3363 }
3364 slot = path->slots[0];
3365 old_data = btrfs_item_end_nr(leaf, slot);
3366
3367 BUG_ON(slot < 0);
3368 if (slot >= nritems) {
3369 btrfs_print_leaf(root, leaf);
3370 printk(KERN_CRIT "slot %d too large, nritems %d\n",
3371 slot, nritems);
3372 BUG_ON(1);
3373 }
3374
3375 /*
3376 * item0..itemN ... dataN.offset..dataN.size .. data0.size
3377 */
3378 /* first correct the data pointers */
3379 for (i = slot; i < nritems; i++) {
3380 u32 ioff;
3381 item = btrfs_item_nr(leaf, i);
3382
3383 ioff = btrfs_item_offset(leaf, item);
3384 btrfs_set_item_offset(leaf, item, ioff - data_size);
3385 }
3386
3387 /* shift the data */
3388 memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
3389 data_end - data_size, btrfs_leaf_data(leaf) +
3390 data_end, old_data - data_end);
3391
3392 data_end = old_data;
3393 old_size = btrfs_item_size_nr(leaf, slot);
3394 item = btrfs_item_nr(leaf, slot);
3395 btrfs_set_item_size(leaf, item, old_size + data_size);
3396 btrfs_mark_buffer_dirty(leaf);
3397
3398 if (btrfs_leaf_free_space(root, leaf) < 0) {
3399 btrfs_print_leaf(root, leaf);
3400 BUG();
3401 }
3402 return 0;
3403}
3404
3405/*
3406 * Given a key and some data, insert items into the tree.
3407 * This does all the path init required, making room in the tree if needed.
3408 * Returns the number of keys that were inserted.
3409 */
3410int btrfs_insert_some_items(struct btrfs_trans_handle *trans,
3411 struct btrfs_root *root,
3412 struct btrfs_path *path,
3413 struct btrfs_key *cpu_key, u32 *data_size,
3414 int nr)
3415{
3416 struct extent_buffer *leaf;
3417 struct btrfs_item *item;
3418 int ret = 0;
3419 int slot;
3420 int i;
3421 u32 nritems;
3422 u32 total_data = 0;
3423 u32 total_size = 0;
3424 unsigned int data_end;
3425 struct btrfs_disk_key disk_key;
3426 struct btrfs_key found_key;
3427
3428 for (i = 0; i < nr; i++) {
3429 if (total_size + data_size[i] + sizeof(struct btrfs_item) >
3430 BTRFS_LEAF_DATA_SIZE(root)) {
3431 break;
3432 nr = i;
3433 }
3434 total_data += data_size[i];
3435 total_size += data_size[i] + sizeof(struct btrfs_item);
3436 }
3437 BUG_ON(nr == 0);
3438
3439 ret = btrfs_search_slot(trans, root, cpu_key, path, total_size, 1);
3440 if (ret == 0)
3441 return -EEXIST;
3442 if (ret < 0)
3443 goto out;
3444
3445 leaf = path->nodes[0];
3446
3447 nritems = btrfs_header_nritems(leaf);
3448 data_end = leaf_data_end(root, leaf);
3449
3450 if (btrfs_leaf_free_space(root, leaf) < total_size) {
3451 for (i = nr; i >= 0; i--) {
3452 total_data -= data_size[i];
3453 total_size -= data_size[i] + sizeof(struct btrfs_item);
3454 if (total_size < btrfs_leaf_free_space(root, leaf))
3455 break;
3456 }
3457 nr = i;
3458 }
3459
3460 slot = path->slots[0];
3461 BUG_ON(slot < 0);
3462
3463 if (slot != nritems) {
3464 unsigned int old_data = btrfs_item_end_nr(leaf, slot);
3465
3466 item = btrfs_item_nr(leaf, slot);
3467 btrfs_item_key_to_cpu(leaf, &found_key, slot);
3468
3469 /* figure out how many keys we can insert in here */
3470 total_data = data_size[0];
3471 for (i = 1; i < nr; i++) {
3472 if (btrfs_comp_cpu_keys(&found_key, cpu_key + i) <= 0)
3473 break;
3474 total_data += data_size[i];
3475 }
3476 nr = i;
3477
3478 if (old_data < data_end) {
3479 btrfs_print_leaf(root, leaf);
3480 printk(KERN_CRIT "slot %d old_data %d data_end %d\n",
3481 slot, old_data, data_end);
3482 BUG_ON(1);
3483 }
3484 /*
3485 * item0..itemN ... dataN.offset..dataN.size .. data0.size
3486 */
3487 /* first correct the data pointers */
3488 for (i = slot; i < nritems; i++) {
3489 u32 ioff;
3490
3491 item = btrfs_item_nr(leaf, i);
3492 ioff = btrfs_item_offset(leaf, item);
3493 btrfs_set_item_offset(leaf, item, ioff - total_data);
3494 }
3495 /* shift the items */
3496 memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr),
3497 btrfs_item_nr_offset(slot),
3498 (nritems - slot) * sizeof(struct btrfs_item));
3499
3500 /* shift the data */
3501 memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
3502 data_end - total_data, btrfs_leaf_data(leaf) +
3503 data_end, old_data - data_end);
3504 data_end = old_data;
3505 } else {
3506 /*
3507 * this sucks but it has to be done, if we are inserting at
3508 * the end of the leaf only insert 1 of the items, since we
3509 * have no way of knowing whats on the next leaf and we'd have
3510 * to drop our current locks to figure it out
3511 */
3512 nr = 1;
3513 }
3514
3515 /* setup the item for the new data */
3516 for (i = 0; i < nr; i++) {
3517 btrfs_cpu_key_to_disk(&disk_key, cpu_key + i);
3518 btrfs_set_item_key(leaf, &disk_key, slot + i);
3519 item = btrfs_item_nr(leaf, slot + i);
3520 btrfs_set_item_offset(leaf, item, data_end - data_size[i]);
3521 data_end -= data_size[i];
3522 btrfs_set_item_size(leaf, item, data_size[i]);
3523 }
3524 btrfs_set_header_nritems(leaf, nritems + nr);
3525 btrfs_mark_buffer_dirty(leaf);
3526
3527 ret = 0;
3528 if (slot == 0) {
3529 btrfs_cpu_key_to_disk(&disk_key, cpu_key);
3530 ret = fixup_low_keys(trans, root, path, &disk_key, 1);
3531 }
3532
3533 if (btrfs_leaf_free_space(root, leaf) < 0) {
3534 btrfs_print_leaf(root, leaf);
3535 BUG();
3536 }
3537out:
3538 if (!ret)
3539 ret = nr;
3540 return ret;
3541}
3542
3543/*
3544 * this is a helper for btrfs_insert_empty_items, the main goal here is
3545 * to save stack depth by doing the bulk of the work in a function
3546 * that doesn't call btrfs_search_slot
3547 */
3548int setup_items_for_insert(struct btrfs_trans_handle *trans,
3549 struct btrfs_root *root, struct btrfs_path *path,
3550 struct btrfs_key *cpu_key, u32 *data_size,
3551 u32 total_data, u32 total_size, int nr)
3552{
3553 struct btrfs_item *item;
3554 int i;
3555 u32 nritems;
3556 unsigned int data_end;
3557 struct btrfs_disk_key disk_key;
3558 int ret;
3559 struct extent_buffer *leaf;
3560 int slot;
3561
3562 leaf = path->nodes[0];
3563 slot = path->slots[0];
3564
3565 nritems = btrfs_header_nritems(leaf);
3566 data_end = leaf_data_end(root, leaf);
3567
3568 if (btrfs_leaf_free_space(root, leaf) < total_size) {
3569 btrfs_print_leaf(root, leaf);
3570 printk(KERN_CRIT "not enough freespace need %u have %d\n",
3571 total_size, btrfs_leaf_free_space(root, leaf));
3572 BUG();
3573 }
3574
3575 if (slot != nritems) {
3576 unsigned int old_data = btrfs_item_end_nr(leaf, slot);
3577
3578 if (old_data < data_end) {
3579 btrfs_print_leaf(root, leaf);
3580 printk(KERN_CRIT "slot %d old_data %d data_end %d\n",
3581 slot, old_data, data_end);
3582 BUG_ON(1);
3583 }
3584 /*
3585 * item0..itemN ... dataN.offset..dataN.size .. data0.size
3586 */
3587 /* first correct the data pointers */
3588 for (i = slot; i < nritems; i++) {
3589 u32 ioff;
3590
3591 item = btrfs_item_nr(leaf, i);
3592 ioff = btrfs_item_offset(leaf, item);
3593 btrfs_set_item_offset(leaf, item, ioff - total_data);
3594 }
3595 /* shift the items */
3596 memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr),
3597 btrfs_item_nr_offset(slot),
3598 (nritems - slot) * sizeof(struct btrfs_item));
3599
3600 /* shift the data */
3601 memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
3602 data_end - total_data, btrfs_leaf_data(leaf) +
3603 data_end, old_data - data_end);
3604 data_end = old_data;
3605 }
3606
3607 /* setup the item for the new data */
3608 for (i = 0; i < nr; i++) {
3609 btrfs_cpu_key_to_disk(&disk_key, cpu_key + i);
3610 btrfs_set_item_key(leaf, &disk_key, slot + i);
3611 item = btrfs_item_nr(leaf, slot + i);
3612 btrfs_set_item_offset(leaf, item, data_end - data_size[i]);
3613 data_end -= data_size[i];
3614 btrfs_set_item_size(leaf, item, data_size[i]);
3615 }
3616
3617 btrfs_set_header_nritems(leaf, nritems + nr);
3618
3619 ret = 0;
3620 if (slot == 0) {
3621 btrfs_cpu_key_to_disk(&disk_key, cpu_key);
3622 ret = fixup_low_keys(trans, root, path, &disk_key, 1);
3623 }
3624 btrfs_unlock_up_safe(path, 1);
3625 btrfs_mark_buffer_dirty(leaf);
3626
3627 if (btrfs_leaf_free_space(root, leaf) < 0) {
3628 btrfs_print_leaf(root, leaf);
3629 BUG();
3630 }
3631 return ret;
3632}
3633
3634/*
3635 * Given a key and some data, insert items into the tree.
3636 * This does all the path init required, making room in the tree if needed.
3637 */
3638int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
3639 struct btrfs_root *root,
3640 struct btrfs_path *path,
3641 struct btrfs_key *cpu_key, u32 *data_size,
3642 int nr)
3643{
3644 int ret = 0;
3645 int slot;
3646 int i;
3647 u32 total_size = 0;
3648 u32 total_data = 0;
3649
3650 for (i = 0; i < nr; i++)
3651 total_data += data_size[i];
3652
3653 total_size = total_data + (nr * sizeof(struct btrfs_item));
3654 ret = btrfs_search_slot(trans, root, cpu_key, path, total_size, 1);
3655 if (ret == 0)
3656 return -EEXIST;
3657 if (ret < 0)
3658 goto out;
3659
3660 slot = path->slots[0];
3661 BUG_ON(slot < 0);
3662
3663 ret = setup_items_for_insert(trans, root, path, cpu_key, data_size,
3664 total_data, total_size, nr);
3665
3666out:
3667 return ret;
3668}
3669
3670/*
3671 * Given a key and some data, insert an item into the tree.
3672 * This does all the path init required, making room in the tree if needed.
3673 */
3674int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
3675 *root, struct btrfs_key *cpu_key, void *data, u32
3676 data_size)
3677{
3678 int ret = 0;
3679 struct btrfs_path *path;
3680 struct extent_buffer *leaf;
3681 unsigned long ptr;
3682
3683 path = btrfs_alloc_path();
3684 if (!path)
3685 return -ENOMEM;
3686 ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
3687 if (!ret) {
3688 leaf = path->nodes[0];
3689 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
3690 write_extent_buffer(leaf, data, ptr, data_size);
3691 btrfs_mark_buffer_dirty(leaf);
3692 }
3693 btrfs_free_path(path);
3694 return ret;
3695}
3696
3697/*
3698 * delete the pointer from a given node.
3699 *
3700 * the tree should have been previously balanced so the deletion does not
3701 * empty a node.
3702 */
3703static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3704 struct btrfs_path *path, int level, int slot)
3705{
3706 struct extent_buffer *parent = path->nodes[level];
3707 u32 nritems;
3708 int ret = 0;
3709 int wret;
3710
3711 nritems = btrfs_header_nritems(parent);
3712 if (slot != nritems - 1) {
3713 memmove_extent_buffer(parent,
3714 btrfs_node_key_ptr_offset(slot),
3715 btrfs_node_key_ptr_offset(slot + 1),
3716 sizeof(struct btrfs_key_ptr) *
3717 (nritems - slot - 1));
3718 }
3719 nritems--;
3720 btrfs_set_header_nritems(parent, nritems);
3721 if (nritems == 0 && parent == root->node) {
3722 BUG_ON(btrfs_header_level(root->node) != 1);
3723 /* just turn the root into a leaf and break */
3724 btrfs_set_header_level(root->node, 0);
3725 } else if (slot == 0) {
3726 struct btrfs_disk_key disk_key;
3727
3728 btrfs_node_key(parent, &disk_key, 0);
3729 wret = fixup_low_keys(trans, root, path, &disk_key, level + 1);
3730 if (wret)
3731 ret = wret;
3732 }
3733 btrfs_mark_buffer_dirty(parent);
3734 return ret;
3735}
3736
3737/*
3738 * a helper function to delete the leaf pointed to by path->slots[1] and
3739 * path->nodes[1].
3740 *
3741 * This deletes the pointer in path->nodes[1] and frees the leaf
3742 * block extent. zero is returned if it all worked out, < 0 otherwise.
3743 *
3744 * The path must have already been setup for deleting the leaf, including
3745 * all the proper balancing. path->nodes[1] must be locked.
3746 */
3747static noinline int btrfs_del_leaf(struct btrfs_trans_handle *trans,
3748 struct btrfs_root *root,
3749 struct btrfs_path *path,
3750 struct extent_buffer *leaf)
3751{
3752 int ret;
3753
3754 WARN_ON(btrfs_header_generation(leaf) != trans->transid);
3755 ret = del_ptr(trans, root, path, 1, path->slots[1]);
3756 if (ret)
3757 return ret;
3758
3759 /*
3760 * btrfs_free_extent is expensive, we want to make sure we
3761 * aren't holding any locks when we call it
3762 */
3763 btrfs_unlock_up_safe(path, 0);
3764
3765 root_sub_used(root, leaf->len);
3766
3767 btrfs_free_tree_block(trans, root, leaf, 0, 1);
3768 return 0;
3769}
3770/*
3771 * delete the item at the leaf level in path. If that empties
3772 * the leaf, remove it from the tree
3773 */
3774int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3775 struct btrfs_path *path, int slot, int nr)
3776{
3777 struct extent_buffer *leaf;
3778 struct btrfs_item *item;
3779 int last_off;
3780 int dsize = 0;
3781 int ret = 0;
3782 int wret;
3783 int i;
3784 u32 nritems;
3785
3786 leaf = path->nodes[0];
3787 last_off = btrfs_item_offset_nr(leaf, slot + nr - 1);
3788
3789 for (i = 0; i < nr; i++)
3790 dsize += btrfs_item_size_nr(leaf, slot + i);
3791
3792 nritems = btrfs_header_nritems(leaf);
3793
3794 if (slot + nr != nritems) {
3795 int data_end = leaf_data_end(root, leaf);
3796
3797 memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
3798 data_end + dsize,
3799 btrfs_leaf_data(leaf) + data_end,
3800 last_off - data_end);
3801
3802 for (i = slot + nr; i < nritems; i++) {
3803 u32 ioff;
3804
3805 item = btrfs_item_nr(leaf, i);
3806 ioff = btrfs_item_offset(leaf, item);
3807 btrfs_set_item_offset(leaf, item, ioff + dsize);
3808 }
3809
3810 memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot),
3811 btrfs_item_nr_offset(slot + nr),
3812 sizeof(struct btrfs_item) *
3813 (nritems - slot - nr));
3814 }
3815 btrfs_set_header_nritems(leaf, nritems - nr);
3816 nritems -= nr;
3817
3818 /* delete the leaf if we've emptied it */
3819 if (nritems == 0) {
3820 if (leaf == root->node) {
3821 btrfs_set_header_level(leaf, 0);
3822 } else {
3823 btrfs_set_path_blocking(path);
3824 clean_tree_block(trans, root, leaf);
3825 ret = btrfs_del_leaf(trans, root, path, leaf);
3826 BUG_ON(ret);
3827 }
3828 } else {
3829 int used = leaf_space_used(leaf, 0, nritems);
3830 if (slot == 0) {
3831 struct btrfs_disk_key disk_key;
3832
3833 btrfs_item_key(leaf, &disk_key, 0);
3834 wret = fixup_low_keys(trans, root, path,
3835 &disk_key, 1);
3836 if (wret)
3837 ret = wret;
3838 }
3839
3840 /* delete the leaf if it is mostly empty */
3841 if (used < BTRFS_LEAF_DATA_SIZE(root) / 3) {
3842 /* push_leaf_left fixes the path.
3843 * make sure the path still points to our leaf
3844 * for possible call to del_ptr below
3845 */
3846 slot = path->slots[1];
3847 extent_buffer_get(leaf);
3848
3849 btrfs_set_path_blocking(path);
3850 wret = push_leaf_left(trans, root, path, 1, 1,
3851 1, (u32)-1);
3852 if (wret < 0 && wret != -ENOSPC)
3853 ret = wret;
3854
3855 if (path->nodes[0] == leaf &&
3856 btrfs_header_nritems(leaf)) {
3857 wret = push_leaf_right(trans, root, path, 1,
3858 1, 1, 0);
3859 if (wret < 0 && wret != -ENOSPC)
3860 ret = wret;
3861 }
3862
3863 if (btrfs_header_nritems(leaf) == 0) {
3864 path->slots[1] = slot;
3865 ret = btrfs_del_leaf(trans, root, path, leaf);
3866 BUG_ON(ret);
3867 free_extent_buffer(leaf);
3868 } else {
3869 /* if we're still in the path, make sure
3870 * we're dirty. Otherwise, one of the
3871 * push_leaf functions must have already
3872 * dirtied this buffer
3873 */
3874 if (path->nodes[0] == leaf)
3875 btrfs_mark_buffer_dirty(leaf);
3876 free_extent_buffer(leaf);
3877 }
3878 } else {
3879 btrfs_mark_buffer_dirty(leaf);
3880 }
3881 }
3882 return ret;
3883}
3884
3885/*
3886 * search the tree again to find a leaf with lesser keys
3887 * returns 0 if it found something or 1 if there are no lesser leaves.
3888 * returns < 0 on io errors.
3889 *
3890 * This may release the path, and so you may lose any locks held at the
3891 * time you call it.
3892 */
3893int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path)
3894{
3895 struct btrfs_key key;
3896 struct btrfs_disk_key found_key;
3897 int ret;
3898
3899 btrfs_item_key_to_cpu(path->nodes[0], &key, 0);
3900
3901 if (key.offset > 0)
3902 key.offset--;
3903 else if (key.type > 0)
3904 key.type--;
3905 else if (key.objectid > 0)
3906 key.objectid--;
3907 else
3908 return 1;
3909
3910 btrfs_release_path(path);
3911 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
3912 if (ret < 0)
3913 return ret;
3914 btrfs_item_key(path->nodes[0], &found_key, 0);
3915 ret = comp_keys(&found_key, &key);
3916 if (ret < 0)
3917 return 0;
3918 return 1;
3919}
3920
3921/*
3922 * A helper function to walk down the tree starting at min_key, and looking
3923 * for nodes or leaves that are either in cache or have a minimum
3924 * transaction id. This is used by the btree defrag code, and tree logging
3925 *
3926 * This does not cow, but it does stuff the starting key it finds back
3927 * into min_key, so you can call btrfs_search_slot with cow=1 on the
3928 * key and get a writable path.
3929 *
3930 * This does lock as it descends, and path->keep_locks should be set
3931 * to 1 by the caller.
3932 *
3933 * This honors path->lowest_level to prevent descent past a given level
3934 * of the tree.
3935 *
3936 * min_trans indicates the oldest transaction that you are interested
3937 * in walking through. Any nodes or leaves older than min_trans are
3938 * skipped over (without reading them).
3939 *
3940 * returns zero if something useful was found, < 0 on error and 1 if there
3941 * was nothing in the tree that matched the search criteria.
3942 */
3943int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
3944 struct btrfs_key *max_key,
3945 struct btrfs_path *path, int cache_only,
3946 u64 min_trans)
3947{
3948 struct extent_buffer *cur;
3949 struct btrfs_key found_key;
3950 int slot;
3951 int sret;
3952 u32 nritems;
3953 int level;
3954 int ret = 1;
3955
3956 WARN_ON(!path->keep_locks);
3957again:
3958 cur = btrfs_read_lock_root_node(root);
3959 level = btrfs_header_level(cur);
3960 WARN_ON(path->nodes[level]);
3961 path->nodes[level] = cur;
3962 path->locks[level] = BTRFS_READ_LOCK;
3963
3964 if (btrfs_header_generation(cur) < min_trans) {
3965 ret = 1;
3966 goto out;
3967 }
3968 while (1) {
3969 nritems = btrfs_header_nritems(cur);
3970 level = btrfs_header_level(cur);
3971 sret = bin_search(cur, min_key, level, &slot);
3972
3973 /* at the lowest level, we're done, setup the path and exit */
3974 if (level == path->lowest_level) {
3975 if (slot >= nritems)
3976 goto find_next_key;
3977 ret = 0;
3978 path->slots[level] = slot;
3979 btrfs_item_key_to_cpu(cur, &found_key, slot);
3980 goto out;
3981 }
3982 if (sret && slot > 0)
3983 slot--;
3984 /*
3985 * check this node pointer against the cache_only and
3986 * min_trans parameters. If it isn't in cache or is too
3987 * old, skip to the next one.
3988 */
3989 while (slot < nritems) {
3990 u64 blockptr;
3991 u64 gen;
3992 struct extent_buffer *tmp;
3993 struct btrfs_disk_key disk_key;
3994
3995 blockptr = btrfs_node_blockptr(cur, slot);
3996 gen = btrfs_node_ptr_generation(cur, slot);
3997 if (gen < min_trans) {
3998 slot++;
3999 continue;
4000 }
4001 if (!cache_only)
4002 break;
4003
4004 if (max_key) {
4005 btrfs_node_key(cur, &disk_key, slot);
4006 if (comp_keys(&disk_key, max_key) >= 0) {
4007 ret = 1;
4008 goto out;
4009 }
4010 }
4011
4012 tmp = btrfs_find_tree_block(root, blockptr,
4013 btrfs_level_size(root, level - 1));
4014
4015 if (tmp && btrfs_buffer_uptodate(tmp, gen)) {
4016 free_extent_buffer(tmp);
4017 break;
4018 }
4019 if (tmp)
4020 free_extent_buffer(tmp);
4021 slot++;
4022 }
4023find_next_key:
4024 /*
4025 * we didn't find a candidate key in this node, walk forward
4026 * and find another one
4027 */
4028 if (slot >= nritems) {
4029 path->slots[level] = slot;
4030 btrfs_set_path_blocking(path);
4031 sret = btrfs_find_next_key(root, path, min_key, level,
4032 cache_only, min_trans);
4033 if (sret == 0) {
4034 btrfs_release_path(path);
4035 goto again;
4036 } else {
4037 goto out;
4038 }
4039 }
4040 /* save our key for returning back */
4041 btrfs_node_key_to_cpu(cur, &found_key, slot);
4042 path->slots[level] = slot;
4043 if (level == path->lowest_level) {
4044 ret = 0;
4045 unlock_up(path, level, 1);
4046 goto out;
4047 }
4048 btrfs_set_path_blocking(path);
4049 cur = read_node_slot(root, cur, slot);
4050 BUG_ON(!cur);
4051
4052 btrfs_tree_read_lock(cur);
4053
4054 path->locks[level - 1] = BTRFS_READ_LOCK;
4055 path->nodes[level - 1] = cur;
4056 unlock_up(path, level, 1);
4057 btrfs_clear_path_blocking(path, NULL, 0);
4058 }
4059out:
4060 if (ret == 0)
4061 memcpy(min_key, &found_key, sizeof(found_key));
4062 btrfs_set_path_blocking(path);
4063 return ret;
4064}
4065
4066/*
4067 * this is similar to btrfs_next_leaf, but does not try to preserve
4068 * and fixup the path. It looks for and returns the next key in the
4069 * tree based on the current path and the cache_only and min_trans
4070 * parameters.
4071 *
4072 * 0 is returned if another key is found, < 0 if there are any errors
4073 * and 1 is returned if there are no higher keys in the tree
4074 *
4075 * path->keep_locks should be set to 1 on the search made before
4076 * calling this function.
4077 */
4078int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
4079 struct btrfs_key *key, int level,
4080 int cache_only, u64 min_trans)
4081{
4082 int slot;
4083 struct extent_buffer *c;
4084
4085 WARN_ON(!path->keep_locks);
4086 while (level < BTRFS_MAX_LEVEL) {
4087 if (!path->nodes[level])
4088 return 1;
4089
4090 slot = path->slots[level] + 1;
4091 c = path->nodes[level];
4092next:
4093 if (slot >= btrfs_header_nritems(c)) {
4094 int ret;
4095 int orig_lowest;
4096 struct btrfs_key cur_key;
4097 if (level + 1 >= BTRFS_MAX_LEVEL ||
4098 !path->nodes[level + 1])
4099 return 1;
4100
4101 if (path->locks[level + 1]) {
4102 level++;
4103 continue;
4104 }
4105
4106 slot = btrfs_header_nritems(c) - 1;
4107 if (level == 0)
4108 btrfs_item_key_to_cpu(c, &cur_key, slot);
4109 else
4110 btrfs_node_key_to_cpu(c, &cur_key, slot);
4111
4112 orig_lowest = path->lowest_level;
4113 btrfs_release_path(path);
4114 path->lowest_level = level;
4115 ret = btrfs_search_slot(NULL, root, &cur_key, path,
4116 0, 0);
4117 path->lowest_level = orig_lowest;
4118 if (ret < 0)
4119 return ret;
4120
4121 c = path->nodes[level];
4122 slot = path->slots[level];
4123 if (ret == 0)
4124 slot++;
4125 goto next;
4126 }
4127
4128 if (level == 0)
4129 btrfs_item_key_to_cpu(c, key, slot);
4130 else {
4131 u64 blockptr = btrfs_node_blockptr(c, slot);
4132 u64 gen = btrfs_node_ptr_generation(c, slot);
4133
4134 if (cache_only) {
4135 struct extent_buffer *cur;
4136 cur = btrfs_find_tree_block(root, blockptr,
4137 btrfs_level_size(root, level - 1));
4138 if (!cur || !btrfs_buffer_uptodate(cur, gen)) {
4139 slot++;
4140 if (cur)
4141 free_extent_buffer(cur);
4142 goto next;
4143 }
4144 free_extent_buffer(cur);
4145 }
4146 if (gen < min_trans) {
4147 slot++;
4148 goto next;
4149 }
4150 btrfs_node_key_to_cpu(c, key, slot);
4151 }
4152 return 0;
4153 }
4154 return 1;
4155}
4156
4157/*
4158 * search the tree again to find a leaf with greater keys
4159 * returns 0 if it found something or 1 if there are no greater leaves.
4160 * returns < 0 on io errors.
4161 */
4162int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
4163{
4164 int slot;
4165 int level;
4166 struct extent_buffer *c;
4167 struct extent_buffer *next;
4168 struct btrfs_key key;
4169 u32 nritems;
4170 int ret;
4171 int old_spinning = path->leave_spinning;
4172 int next_rw_lock = 0;
4173
4174 nritems = btrfs_header_nritems(path->nodes[0]);
4175 if (nritems == 0)
4176 return 1;
4177
4178 btrfs_item_key_to_cpu(path->nodes[0], &key, nritems - 1);
4179again:
4180 level = 1;
4181 next = NULL;
4182 next_rw_lock = 0;
4183 btrfs_release_path(path);
4184
4185 path->keep_locks = 1;
4186 path->leave_spinning = 1;
4187
4188 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4189 path->keep_locks = 0;
4190
4191 if (ret < 0)
4192 return ret;
4193
4194 nritems = btrfs_header_nritems(path->nodes[0]);
4195 /*
4196 * by releasing the path above we dropped all our locks. A balance
4197 * could have added more items next to the key that used to be
4198 * at the very end of the block. So, check again here and
4199 * advance the path if there are now more items available.
4200 */
4201 if (nritems > 0 && path->slots[0] < nritems - 1) {
4202 if (ret == 0)
4203 path->slots[0]++;
4204 ret = 0;
4205 goto done;
4206 }
4207
4208 while (level < BTRFS_MAX_LEVEL) {
4209 if (!path->nodes[level]) {
4210 ret = 1;
4211 goto done;
4212 }
4213
4214 slot = path->slots[level] + 1;
4215 c = path->nodes[level];
4216 if (slot >= btrfs_header_nritems(c)) {
4217 level++;
4218 if (level == BTRFS_MAX_LEVEL) {
4219 ret = 1;
4220 goto done;
4221 }
4222 continue;
4223 }
4224
4225 if (next) {
4226 btrfs_tree_unlock_rw(next, next_rw_lock);
4227 free_extent_buffer(next);
4228 }
4229
4230 next = c;
4231 next_rw_lock = path->locks[level];
4232 ret = read_block_for_search(NULL, root, path, &next, level,
4233 slot, &key);
4234 if (ret == -EAGAIN)
4235 goto again;
4236
4237 if (ret < 0) {
4238 btrfs_release_path(path);
4239 goto done;
4240 }
4241
4242 if (!path->skip_locking) {
4243 ret = btrfs_try_tree_read_lock(next);
4244 if (!ret) {
4245 btrfs_set_path_blocking(path);
4246 btrfs_tree_read_lock(next);
4247 btrfs_clear_path_blocking(path, next,
4248 BTRFS_READ_LOCK);
4249 }
4250 next_rw_lock = BTRFS_READ_LOCK;
4251 }
4252 break;
4253 }
4254 path->slots[level] = slot;
4255 while (1) {
4256 level--;
4257 c = path->nodes[level];
4258 if (path->locks[level])
4259 btrfs_tree_unlock_rw(c, path->locks[level]);
4260
4261 free_extent_buffer(c);
4262 path->nodes[level] = next;
4263 path->slots[level] = 0;
4264 if (!path->skip_locking)
4265 path->locks[level] = next_rw_lock;
4266 if (!level)
4267 break;
4268
4269 ret = read_block_for_search(NULL, root, path, &next, level,
4270 0, &key);
4271 if (ret == -EAGAIN)
4272 goto again;
4273
4274 if (ret < 0) {
4275 btrfs_release_path(path);
4276 goto done;
4277 }
4278
4279 if (!path->skip_locking) {
4280 ret = btrfs_try_tree_read_lock(next);
4281 if (!ret) {
4282 btrfs_set_path_blocking(path);
4283 btrfs_tree_read_lock(next);
4284 btrfs_clear_path_blocking(path, next,
4285 BTRFS_READ_LOCK);
4286 }
4287 next_rw_lock = BTRFS_READ_LOCK;
4288 }
4289 }
4290 ret = 0;
4291done:
4292 unlock_up(path, 0, 1);
4293 path->leave_spinning = old_spinning;
4294 if (!old_spinning)
4295 btrfs_set_path_blocking(path);
4296
4297 return ret;
4298}
4299
4300/*
4301 * this uses btrfs_prev_leaf to walk backwards in the tree, and keeps
4302 * searching until it gets past min_objectid or finds an item of 'type'
4303 *
4304 * returns 0 if something is found, 1 if nothing was found and < 0 on error
4305 */
4306int btrfs_previous_item(struct btrfs_root *root,
4307 struct btrfs_path *path, u64 min_objectid,
4308 int type)
4309{
4310 struct btrfs_key found_key;
4311 struct extent_buffer *leaf;
4312 u32 nritems;
4313 int ret;
4314
4315 while (1) {
4316 if (path->slots[0] == 0) {
4317 btrfs_set_path_blocking(path);
4318 ret = btrfs_prev_leaf(root, path);
4319 if (ret != 0)
4320 return ret;
4321 } else {
4322 path->slots[0]--;
4323 }
4324 leaf = path->nodes[0];
4325 nritems = btrfs_header_nritems(leaf);
4326 if (nritems == 0)
4327 return 1;
4328 if (path->slots[0] == nritems)
4329 path->slots[0]--;
4330
4331 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
4332 if (found_key.objectid < min_objectid)
4333 break;
4334 if (found_key.type == type)
4335 return 0;
4336 if (found_key.objectid == min_objectid &&
4337 found_key.type < type)
4338 break;
4339 }
4340 return 1;
4341}
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2007,2008 Oracle. All rights reserved.
4 */
5
6#include <linux/sched.h>
7#include <linux/slab.h>
8#include <linux/rbtree.h>
9#include <linux/mm.h>
10#include <linux/error-injection.h>
11#include "messages.h"
12#include "ctree.h"
13#include "disk-io.h"
14#include "transaction.h"
15#include "print-tree.h"
16#include "locking.h"
17#include "volumes.h"
18#include "qgroup.h"
19#include "tree-mod-log.h"
20#include "tree-checker.h"
21#include "fs.h"
22#include "accessors.h"
23#include "extent-tree.h"
24#include "relocation.h"
25#include "file-item.h"
26
27static struct kmem_cache *btrfs_path_cachep;
28
29static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root
30 *root, struct btrfs_path *path, int level);
31static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root *root,
32 const struct btrfs_key *ins_key, struct btrfs_path *path,
33 int data_size, int extend);
34static int push_node_left(struct btrfs_trans_handle *trans,
35 struct extent_buffer *dst,
36 struct extent_buffer *src, int empty);
37static int balance_node_right(struct btrfs_trans_handle *trans,
38 struct extent_buffer *dst_buf,
39 struct extent_buffer *src_buf);
40
41static const struct btrfs_csums {
42 u16 size;
43 const char name[10];
44 const char driver[12];
45} btrfs_csums[] = {
46 [BTRFS_CSUM_TYPE_CRC32] = { .size = 4, .name = "crc32c" },
47 [BTRFS_CSUM_TYPE_XXHASH] = { .size = 8, .name = "xxhash64" },
48 [BTRFS_CSUM_TYPE_SHA256] = { .size = 32, .name = "sha256" },
49 [BTRFS_CSUM_TYPE_BLAKE2] = { .size = 32, .name = "blake2b",
50 .driver = "blake2b-256" },
51};
52
53/*
54 * The leaf data grows from end-to-front in the node. this returns the address
55 * of the start of the last item, which is the stop of the leaf data stack.
56 */
57static unsigned int leaf_data_end(const struct extent_buffer *leaf)
58{
59 u32 nr = btrfs_header_nritems(leaf);
60
61 if (nr == 0)
62 return BTRFS_LEAF_DATA_SIZE(leaf->fs_info);
63 return btrfs_item_offset(leaf, nr - 1);
64}
65
66/*
67 * Move data in a @leaf (using memmove, safe for overlapping ranges).
68 *
69 * @leaf: leaf that we're doing a memmove on
70 * @dst_offset: item data offset we're moving to
71 * @src_offset: item data offset were' moving from
72 * @len: length of the data we're moving
73 *
74 * Wrapper around memmove_extent_buffer() that takes into account the header on
75 * the leaf. The btrfs_item offset's start directly after the header, so we
76 * have to adjust any offsets to account for the header in the leaf. This
77 * handles that math to simplify the callers.
78 */
79static inline void memmove_leaf_data(const struct extent_buffer *leaf,
80 unsigned long dst_offset,
81 unsigned long src_offset,
82 unsigned long len)
83{
84 memmove_extent_buffer(leaf, btrfs_item_nr_offset(leaf, 0) + dst_offset,
85 btrfs_item_nr_offset(leaf, 0) + src_offset, len);
86}
87
88/*
89 * Copy item data from @src into @dst at the given @offset.
90 *
91 * @dst: destination leaf that we're copying into
92 * @src: source leaf that we're copying from
93 * @dst_offset: item data offset we're copying to
94 * @src_offset: item data offset were' copying from
95 * @len: length of the data we're copying
96 *
97 * Wrapper around copy_extent_buffer() that takes into account the header on
98 * the leaf. The btrfs_item offset's start directly after the header, so we
99 * have to adjust any offsets to account for the header in the leaf. This
100 * handles that math to simplify the callers.
101 */
102static inline void copy_leaf_data(const struct extent_buffer *dst,
103 const struct extent_buffer *src,
104 unsigned long dst_offset,
105 unsigned long src_offset, unsigned long len)
106{
107 copy_extent_buffer(dst, src, btrfs_item_nr_offset(dst, 0) + dst_offset,
108 btrfs_item_nr_offset(src, 0) + src_offset, len);
109}
110
111/*
112 * Move items in a @leaf (using memmove).
113 *
114 * @dst: destination leaf for the items
115 * @dst_item: the item nr we're copying into
116 * @src_item: the item nr we're copying from
117 * @nr_items: the number of items to copy
118 *
119 * Wrapper around memmove_extent_buffer() that does the math to get the
120 * appropriate offsets into the leaf from the item numbers.
121 */
122static inline void memmove_leaf_items(const struct extent_buffer *leaf,
123 int dst_item, int src_item, int nr_items)
124{
125 memmove_extent_buffer(leaf, btrfs_item_nr_offset(leaf, dst_item),
126 btrfs_item_nr_offset(leaf, src_item),
127 nr_items * sizeof(struct btrfs_item));
128}
129
130/*
131 * Copy items from @src into @dst at the given @offset.
132 *
133 * @dst: destination leaf for the items
134 * @src: source leaf for the items
135 * @dst_item: the item nr we're copying into
136 * @src_item: the item nr we're copying from
137 * @nr_items: the number of items to copy
138 *
139 * Wrapper around copy_extent_buffer() that does the math to get the
140 * appropriate offsets into the leaf from the item numbers.
141 */
142static inline void copy_leaf_items(const struct extent_buffer *dst,
143 const struct extent_buffer *src,
144 int dst_item, int src_item, int nr_items)
145{
146 copy_extent_buffer(dst, src, btrfs_item_nr_offset(dst, dst_item),
147 btrfs_item_nr_offset(src, src_item),
148 nr_items * sizeof(struct btrfs_item));
149}
150
151/* This exists for btrfs-progs usages. */
152u16 btrfs_csum_type_size(u16 type)
153{
154 return btrfs_csums[type].size;
155}
156
157int btrfs_super_csum_size(const struct btrfs_super_block *s)
158{
159 u16 t = btrfs_super_csum_type(s);
160 /*
161 * csum type is validated at mount time
162 */
163 return btrfs_csum_type_size(t);
164}
165
166const char *btrfs_super_csum_name(u16 csum_type)
167{
168 /* csum type is validated at mount time */
169 return btrfs_csums[csum_type].name;
170}
171
172/*
173 * Return driver name if defined, otherwise the name that's also a valid driver
174 * name
175 */
176const char *btrfs_super_csum_driver(u16 csum_type)
177{
178 /* csum type is validated at mount time */
179 return btrfs_csums[csum_type].driver[0] ?
180 btrfs_csums[csum_type].driver :
181 btrfs_csums[csum_type].name;
182}
183
184size_t __attribute_const__ btrfs_get_num_csums(void)
185{
186 return ARRAY_SIZE(btrfs_csums);
187}
188
189struct btrfs_path *btrfs_alloc_path(void)
190{
191 might_sleep();
192
193 return kmem_cache_zalloc(btrfs_path_cachep, GFP_NOFS);
194}
195
196/* this also releases the path */
197void btrfs_free_path(struct btrfs_path *p)
198{
199 if (!p)
200 return;
201 btrfs_release_path(p);
202 kmem_cache_free(btrfs_path_cachep, p);
203}
204
205/*
206 * path release drops references on the extent buffers in the path
207 * and it drops any locks held by this path
208 *
209 * It is safe to call this on paths that no locks or extent buffers held.
210 */
211noinline void btrfs_release_path(struct btrfs_path *p)
212{
213 int i;
214
215 for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
216 p->slots[i] = 0;
217 if (!p->nodes[i])
218 continue;
219 if (p->locks[i]) {
220 btrfs_tree_unlock_rw(p->nodes[i], p->locks[i]);
221 p->locks[i] = 0;
222 }
223 free_extent_buffer(p->nodes[i]);
224 p->nodes[i] = NULL;
225 }
226}
227
228/*
229 * We want the transaction abort to print stack trace only for errors where the
230 * cause could be a bug, eg. due to ENOSPC, and not for common errors that are
231 * caused by external factors.
232 */
233bool __cold abort_should_print_stack(int error)
234{
235 switch (error) {
236 case -EIO:
237 case -EROFS:
238 case -ENOMEM:
239 return false;
240 }
241 return true;
242}
243
244/*
245 * safely gets a reference on the root node of a tree. A lock
246 * is not taken, so a concurrent writer may put a different node
247 * at the root of the tree. See btrfs_lock_root_node for the
248 * looping required.
249 *
250 * The extent buffer returned by this has a reference taken, so
251 * it won't disappear. It may stop being the root of the tree
252 * at any time because there are no locks held.
253 */
254struct extent_buffer *btrfs_root_node(struct btrfs_root *root)
255{
256 struct extent_buffer *eb;
257
258 while (1) {
259 rcu_read_lock();
260 eb = rcu_dereference(root->node);
261
262 /*
263 * RCU really hurts here, we could free up the root node because
264 * it was COWed but we may not get the new root node yet so do
265 * the inc_not_zero dance and if it doesn't work then
266 * synchronize_rcu and try again.
267 */
268 if (atomic_inc_not_zero(&eb->refs)) {
269 rcu_read_unlock();
270 break;
271 }
272 rcu_read_unlock();
273 synchronize_rcu();
274 }
275 return eb;
276}
277
278/*
279 * Cowonly root (not-shareable trees, everything not subvolume or reloc roots),
280 * just get put onto a simple dirty list. Transaction walks this list to make
281 * sure they get properly updated on disk.
282 */
283static void add_root_to_dirty_list(struct btrfs_root *root)
284{
285 struct btrfs_fs_info *fs_info = root->fs_info;
286
287 if (test_bit(BTRFS_ROOT_DIRTY, &root->state) ||
288 !test_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state))
289 return;
290
291 spin_lock(&fs_info->trans_lock);
292 if (!test_and_set_bit(BTRFS_ROOT_DIRTY, &root->state)) {
293 /* Want the extent tree to be the last on the list */
294 if (root->root_key.objectid == BTRFS_EXTENT_TREE_OBJECTID)
295 list_move_tail(&root->dirty_list,
296 &fs_info->dirty_cowonly_roots);
297 else
298 list_move(&root->dirty_list,
299 &fs_info->dirty_cowonly_roots);
300 }
301 spin_unlock(&fs_info->trans_lock);
302}
303
304/*
305 * used by snapshot creation to make a copy of a root for a tree with
306 * a given objectid. The buffer with the new root node is returned in
307 * cow_ret, and this func returns zero on success or a negative error code.
308 */
309int btrfs_copy_root(struct btrfs_trans_handle *trans,
310 struct btrfs_root *root,
311 struct extent_buffer *buf,
312 struct extent_buffer **cow_ret, u64 new_root_objectid)
313{
314 struct btrfs_fs_info *fs_info = root->fs_info;
315 struct extent_buffer *cow;
316 int ret = 0;
317 int level;
318 struct btrfs_disk_key disk_key;
319 u64 reloc_src_root = 0;
320
321 WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
322 trans->transid != fs_info->running_transaction->transid);
323 WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
324 trans->transid != root->last_trans);
325
326 level = btrfs_header_level(buf);
327 if (level == 0)
328 btrfs_item_key(buf, &disk_key, 0);
329 else
330 btrfs_node_key(buf, &disk_key, 0);
331
332 if (new_root_objectid == BTRFS_TREE_RELOC_OBJECTID)
333 reloc_src_root = btrfs_header_owner(buf);
334 cow = btrfs_alloc_tree_block(trans, root, 0, new_root_objectid,
335 &disk_key, level, buf->start, 0,
336 reloc_src_root, BTRFS_NESTING_NEW_ROOT);
337 if (IS_ERR(cow))
338 return PTR_ERR(cow);
339
340 copy_extent_buffer_full(cow, buf);
341 btrfs_set_header_bytenr(cow, cow->start);
342 btrfs_set_header_generation(cow, trans->transid);
343 btrfs_set_header_backref_rev(cow, BTRFS_MIXED_BACKREF_REV);
344 btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN |
345 BTRFS_HEADER_FLAG_RELOC);
346 if (new_root_objectid == BTRFS_TREE_RELOC_OBJECTID)
347 btrfs_set_header_flag(cow, BTRFS_HEADER_FLAG_RELOC);
348 else
349 btrfs_set_header_owner(cow, new_root_objectid);
350
351 write_extent_buffer_fsid(cow, fs_info->fs_devices->metadata_uuid);
352
353 WARN_ON(btrfs_header_generation(buf) > trans->transid);
354 if (new_root_objectid == BTRFS_TREE_RELOC_OBJECTID)
355 ret = btrfs_inc_ref(trans, root, cow, 1);
356 else
357 ret = btrfs_inc_ref(trans, root, cow, 0);
358 if (ret) {
359 btrfs_tree_unlock(cow);
360 free_extent_buffer(cow);
361 btrfs_abort_transaction(trans, ret);
362 return ret;
363 }
364
365 btrfs_mark_buffer_dirty(trans, cow);
366 *cow_ret = cow;
367 return 0;
368}
369
370/*
371 * check if the tree block can be shared by multiple trees
372 */
373bool btrfs_block_can_be_shared(struct btrfs_trans_handle *trans,
374 struct btrfs_root *root,
375 struct extent_buffer *buf)
376{
377 const u64 buf_gen = btrfs_header_generation(buf);
378
379 /*
380 * Tree blocks not in shareable trees and tree roots are never shared.
381 * If a block was allocated after the last snapshot and the block was
382 * not allocated by tree relocation, we know the block is not shared.
383 */
384
385 if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
386 return false;
387
388 if (buf == root->node)
389 return false;
390
391 if (buf_gen > btrfs_root_last_snapshot(&root->root_item) &&
392 !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
393 return false;
394
395 if (buf != root->commit_root)
396 return true;
397
398 /*
399 * An extent buffer that used to be the commit root may still be shared
400 * because the tree height may have increased and it became a child of a
401 * higher level root. This can happen when snapshotting a subvolume
402 * created in the current transaction.
403 */
404 if (buf_gen == trans->transid)
405 return true;
406
407 return false;
408}
409
410static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans,
411 struct btrfs_root *root,
412 struct extent_buffer *buf,
413 struct extent_buffer *cow,
414 int *last_ref)
415{
416 struct btrfs_fs_info *fs_info = root->fs_info;
417 u64 refs;
418 u64 owner;
419 u64 flags;
420 u64 new_flags = 0;
421 int ret;
422
423 /*
424 * Backrefs update rules:
425 *
426 * Always use full backrefs for extent pointers in tree block
427 * allocated by tree relocation.
428 *
429 * If a shared tree block is no longer referenced by its owner
430 * tree (btrfs_header_owner(buf) == root->root_key.objectid),
431 * use full backrefs for extent pointers in tree block.
432 *
433 * If a tree block is been relocating
434 * (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID),
435 * use full backrefs for extent pointers in tree block.
436 * The reason for this is some operations (such as drop tree)
437 * are only allowed for blocks use full backrefs.
438 */
439
440 if (btrfs_block_can_be_shared(trans, root, buf)) {
441 ret = btrfs_lookup_extent_info(trans, fs_info, buf->start,
442 btrfs_header_level(buf), 1,
443 &refs, &flags, NULL);
444 if (ret)
445 return ret;
446 if (unlikely(refs == 0)) {
447 btrfs_crit(fs_info,
448 "found 0 references for tree block at bytenr %llu level %d root %llu",
449 buf->start, btrfs_header_level(buf),
450 btrfs_root_id(root));
451 ret = -EUCLEAN;
452 btrfs_abort_transaction(trans, ret);
453 return ret;
454 }
455 } else {
456 refs = 1;
457 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
458 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
459 flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
460 else
461 flags = 0;
462 }
463
464 owner = btrfs_header_owner(buf);
465 BUG_ON(owner == BTRFS_TREE_RELOC_OBJECTID &&
466 !(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));
467
468 if (refs > 1) {
469 if ((owner == root->root_key.objectid ||
470 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) &&
471 !(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)) {
472 ret = btrfs_inc_ref(trans, root, buf, 1);
473 if (ret)
474 return ret;
475
476 if (root->root_key.objectid ==
477 BTRFS_TREE_RELOC_OBJECTID) {
478 ret = btrfs_dec_ref(trans, root, buf, 0);
479 if (ret)
480 return ret;
481 ret = btrfs_inc_ref(trans, root, cow, 1);
482 if (ret)
483 return ret;
484 }
485 new_flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
486 } else {
487
488 if (root->root_key.objectid ==
489 BTRFS_TREE_RELOC_OBJECTID)
490 ret = btrfs_inc_ref(trans, root, cow, 1);
491 else
492 ret = btrfs_inc_ref(trans, root, cow, 0);
493 if (ret)
494 return ret;
495 }
496 if (new_flags != 0) {
497 ret = btrfs_set_disk_extent_flags(trans, buf, new_flags);
498 if (ret)
499 return ret;
500 }
501 } else {
502 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
503 if (root->root_key.objectid ==
504 BTRFS_TREE_RELOC_OBJECTID)
505 ret = btrfs_inc_ref(trans, root, cow, 1);
506 else
507 ret = btrfs_inc_ref(trans, root, cow, 0);
508 if (ret)
509 return ret;
510 ret = btrfs_dec_ref(trans, root, buf, 1);
511 if (ret)
512 return ret;
513 }
514 btrfs_clear_buffer_dirty(trans, buf);
515 *last_ref = 1;
516 }
517 return 0;
518}
519
520/*
521 * does the dirty work in cow of a single block. The parent block (if
522 * supplied) is updated to point to the new cow copy. The new buffer is marked
523 * dirty and returned locked. If you modify the block it needs to be marked
524 * dirty again.
525 *
526 * search_start -- an allocation hint for the new block
527 *
528 * empty_size -- a hint that you plan on doing more cow. This is the size in
529 * bytes the allocator should try to find free next to the block it returns.
530 * This is just a hint and may be ignored by the allocator.
531 */
532int btrfs_force_cow_block(struct btrfs_trans_handle *trans,
533 struct btrfs_root *root,
534 struct extent_buffer *buf,
535 struct extent_buffer *parent, int parent_slot,
536 struct extent_buffer **cow_ret,
537 u64 search_start, u64 empty_size,
538 enum btrfs_lock_nesting nest)
539{
540 struct btrfs_fs_info *fs_info = root->fs_info;
541 struct btrfs_disk_key disk_key;
542 struct extent_buffer *cow;
543 int level, ret;
544 int last_ref = 0;
545 int unlock_orig = 0;
546 u64 parent_start = 0;
547 u64 reloc_src_root = 0;
548
549 if (*cow_ret == buf)
550 unlock_orig = 1;
551
552 btrfs_assert_tree_write_locked(buf);
553
554 WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
555 trans->transid != fs_info->running_transaction->transid);
556 WARN_ON(test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
557 trans->transid != root->last_trans);
558
559 level = btrfs_header_level(buf);
560
561 if (level == 0)
562 btrfs_item_key(buf, &disk_key, 0);
563 else
564 btrfs_node_key(buf, &disk_key, 0);
565
566 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
567 if (parent)
568 parent_start = parent->start;
569 reloc_src_root = btrfs_header_owner(buf);
570 }
571 cow = btrfs_alloc_tree_block(trans, root, parent_start,
572 root->root_key.objectid, &disk_key, level,
573 search_start, empty_size, reloc_src_root, nest);
574 if (IS_ERR(cow))
575 return PTR_ERR(cow);
576
577 /* cow is set to blocking by btrfs_init_new_buffer */
578
579 copy_extent_buffer_full(cow, buf);
580 btrfs_set_header_bytenr(cow, cow->start);
581 btrfs_set_header_generation(cow, trans->transid);
582 btrfs_set_header_backref_rev(cow, BTRFS_MIXED_BACKREF_REV);
583 btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN |
584 BTRFS_HEADER_FLAG_RELOC);
585 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
586 btrfs_set_header_flag(cow, BTRFS_HEADER_FLAG_RELOC);
587 else
588 btrfs_set_header_owner(cow, root->root_key.objectid);
589
590 write_extent_buffer_fsid(cow, fs_info->fs_devices->metadata_uuid);
591
592 ret = update_ref_for_cow(trans, root, buf, cow, &last_ref);
593 if (ret) {
594 btrfs_tree_unlock(cow);
595 free_extent_buffer(cow);
596 btrfs_abort_transaction(trans, ret);
597 return ret;
598 }
599
600 if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) {
601 ret = btrfs_reloc_cow_block(trans, root, buf, cow);
602 if (ret) {
603 btrfs_tree_unlock(cow);
604 free_extent_buffer(cow);
605 btrfs_abort_transaction(trans, ret);
606 return ret;
607 }
608 }
609
610 if (buf == root->node) {
611 WARN_ON(parent && parent != buf);
612 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
613 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
614 parent_start = buf->start;
615
616 ret = btrfs_tree_mod_log_insert_root(root->node, cow, true);
617 if (ret < 0) {
618 btrfs_tree_unlock(cow);
619 free_extent_buffer(cow);
620 btrfs_abort_transaction(trans, ret);
621 return ret;
622 }
623 atomic_inc(&cow->refs);
624 rcu_assign_pointer(root->node, cow);
625
626 btrfs_free_tree_block(trans, btrfs_root_id(root), buf,
627 parent_start, last_ref);
628 free_extent_buffer(buf);
629 add_root_to_dirty_list(root);
630 } else {
631 WARN_ON(trans->transid != btrfs_header_generation(parent));
632 ret = btrfs_tree_mod_log_insert_key(parent, parent_slot,
633 BTRFS_MOD_LOG_KEY_REPLACE);
634 if (ret) {
635 btrfs_tree_unlock(cow);
636 free_extent_buffer(cow);
637 btrfs_abort_transaction(trans, ret);
638 return ret;
639 }
640 btrfs_set_node_blockptr(parent, parent_slot,
641 cow->start);
642 btrfs_set_node_ptr_generation(parent, parent_slot,
643 trans->transid);
644 btrfs_mark_buffer_dirty(trans, parent);
645 if (last_ref) {
646 ret = btrfs_tree_mod_log_free_eb(buf);
647 if (ret) {
648 btrfs_tree_unlock(cow);
649 free_extent_buffer(cow);
650 btrfs_abort_transaction(trans, ret);
651 return ret;
652 }
653 }
654 btrfs_free_tree_block(trans, btrfs_root_id(root), buf,
655 parent_start, last_ref);
656 }
657 if (unlock_orig)
658 btrfs_tree_unlock(buf);
659 free_extent_buffer_stale(buf);
660 btrfs_mark_buffer_dirty(trans, cow);
661 *cow_ret = cow;
662 return 0;
663}
664
665static inline int should_cow_block(struct btrfs_trans_handle *trans,
666 struct btrfs_root *root,
667 struct extent_buffer *buf)
668{
669 if (btrfs_is_testing(root->fs_info))
670 return 0;
671
672 /* Ensure we can see the FORCE_COW bit */
673 smp_mb__before_atomic();
674
675 /*
676 * We do not need to cow a block if
677 * 1) this block is not created or changed in this transaction;
678 * 2) this block does not belong to TREE_RELOC tree;
679 * 3) the root is not forced COW.
680 *
681 * What is forced COW:
682 * when we create snapshot during committing the transaction,
683 * after we've finished copying src root, we must COW the shared
684 * block to ensure the metadata consistency.
685 */
686 if (btrfs_header_generation(buf) == trans->transid &&
687 !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_WRITTEN) &&
688 !(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&
689 btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC)) &&
690 !test_bit(BTRFS_ROOT_FORCE_COW, &root->state))
691 return 0;
692 return 1;
693}
694
695/*
696 * COWs a single block, see btrfs_force_cow_block() for the real work.
697 * This version of it has extra checks so that a block isn't COWed more than
698 * once per transaction, as long as it hasn't been written yet
699 */
700int btrfs_cow_block(struct btrfs_trans_handle *trans,
701 struct btrfs_root *root, struct extent_buffer *buf,
702 struct extent_buffer *parent, int parent_slot,
703 struct extent_buffer **cow_ret,
704 enum btrfs_lock_nesting nest)
705{
706 struct btrfs_fs_info *fs_info = root->fs_info;
707 u64 search_start;
708 int ret;
709
710 if (unlikely(test_bit(BTRFS_ROOT_DELETING, &root->state))) {
711 btrfs_abort_transaction(trans, -EUCLEAN);
712 btrfs_crit(fs_info,
713 "attempt to COW block %llu on root %llu that is being deleted",
714 buf->start, btrfs_root_id(root));
715 return -EUCLEAN;
716 }
717
718 /*
719 * COWing must happen through a running transaction, which always
720 * matches the current fs generation (it's a transaction with a state
721 * less than TRANS_STATE_UNBLOCKED). If it doesn't, then turn the fs
722 * into error state to prevent the commit of any transaction.
723 */
724 if (unlikely(trans->transaction != fs_info->running_transaction ||
725 trans->transid != fs_info->generation)) {
726 btrfs_abort_transaction(trans, -EUCLEAN);
727 btrfs_crit(fs_info,
728"unexpected transaction when attempting to COW block %llu on root %llu, transaction %llu running transaction %llu fs generation %llu",
729 buf->start, btrfs_root_id(root), trans->transid,
730 fs_info->running_transaction->transid,
731 fs_info->generation);
732 return -EUCLEAN;
733 }
734
735 if (!should_cow_block(trans, root, buf)) {
736 *cow_ret = buf;
737 return 0;
738 }
739
740 search_start = round_down(buf->start, SZ_1G);
741
742 /*
743 * Before CoWing this block for later modification, check if it's
744 * the subtree root and do the delayed subtree trace if needed.
745 *
746 * Also We don't care about the error, as it's handled internally.
747 */
748 btrfs_qgroup_trace_subtree_after_cow(trans, root, buf);
749 ret = btrfs_force_cow_block(trans, root, buf, parent, parent_slot,
750 cow_ret, search_start, 0, nest);
751
752 trace_btrfs_cow_block(root, buf, *cow_ret);
753
754 return ret;
755}
756ALLOW_ERROR_INJECTION(btrfs_cow_block, ERRNO);
757
758/*
759 * same as comp_keys only with two btrfs_key's
760 */
761int __pure btrfs_comp_cpu_keys(const struct btrfs_key *k1, const struct btrfs_key *k2)
762{
763 if (k1->objectid > k2->objectid)
764 return 1;
765 if (k1->objectid < k2->objectid)
766 return -1;
767 if (k1->type > k2->type)
768 return 1;
769 if (k1->type < k2->type)
770 return -1;
771 if (k1->offset > k2->offset)
772 return 1;
773 if (k1->offset < k2->offset)
774 return -1;
775 return 0;
776}
777
778/*
779 * Search for a key in the given extent_buffer.
780 *
781 * The lower boundary for the search is specified by the slot number @first_slot.
782 * Use a value of 0 to search over the whole extent buffer. Works for both
783 * leaves and nodes.
784 *
785 * The slot in the extent buffer is returned via @slot. If the key exists in the
786 * extent buffer, then @slot will point to the slot where the key is, otherwise
787 * it points to the slot where you would insert the key.
788 *
789 * Slot may point to the total number of items (i.e. one position beyond the last
790 * key) if the key is bigger than the last key in the extent buffer.
791 */
792int btrfs_bin_search(struct extent_buffer *eb, int first_slot,
793 const struct btrfs_key *key, int *slot)
794{
795 unsigned long p;
796 int item_size;
797 /*
798 * Use unsigned types for the low and high slots, so that we get a more
799 * efficient division in the search loop below.
800 */
801 u32 low = first_slot;
802 u32 high = btrfs_header_nritems(eb);
803 int ret;
804 const int key_size = sizeof(struct btrfs_disk_key);
805
806 if (unlikely(low > high)) {
807 btrfs_err(eb->fs_info,
808 "%s: low (%u) > high (%u) eb %llu owner %llu level %d",
809 __func__, low, high, eb->start,
810 btrfs_header_owner(eb), btrfs_header_level(eb));
811 return -EINVAL;
812 }
813
814 if (btrfs_header_level(eb) == 0) {
815 p = offsetof(struct btrfs_leaf, items);
816 item_size = sizeof(struct btrfs_item);
817 } else {
818 p = offsetof(struct btrfs_node, ptrs);
819 item_size = sizeof(struct btrfs_key_ptr);
820 }
821
822 while (low < high) {
823 const int unit_size = eb->folio_size;
824 unsigned long oil;
825 unsigned long offset;
826 struct btrfs_disk_key *tmp;
827 struct btrfs_disk_key unaligned;
828 int mid;
829
830 mid = (low + high) / 2;
831 offset = p + mid * item_size;
832 oil = get_eb_offset_in_folio(eb, offset);
833
834 if (oil + key_size <= unit_size) {
835 const unsigned long idx = get_eb_folio_index(eb, offset);
836 char *kaddr = folio_address(eb->folios[idx]);
837
838 oil = get_eb_offset_in_folio(eb, offset);
839 tmp = (struct btrfs_disk_key *)(kaddr + oil);
840 } else {
841 read_extent_buffer(eb, &unaligned, offset, key_size);
842 tmp = &unaligned;
843 }
844
845 ret = btrfs_comp_keys(tmp, key);
846
847 if (ret < 0)
848 low = mid + 1;
849 else if (ret > 0)
850 high = mid;
851 else {
852 *slot = mid;
853 return 0;
854 }
855 }
856 *slot = low;
857 return 1;
858}
859
860static void root_add_used_bytes(struct btrfs_root *root)
861{
862 spin_lock(&root->accounting_lock);
863 btrfs_set_root_used(&root->root_item,
864 btrfs_root_used(&root->root_item) + root->fs_info->nodesize);
865 spin_unlock(&root->accounting_lock);
866}
867
868static void root_sub_used_bytes(struct btrfs_root *root)
869{
870 spin_lock(&root->accounting_lock);
871 btrfs_set_root_used(&root->root_item,
872 btrfs_root_used(&root->root_item) - root->fs_info->nodesize);
873 spin_unlock(&root->accounting_lock);
874}
875
876/* given a node and slot number, this reads the blocks it points to. The
877 * extent buffer is returned with a reference taken (but unlocked).
878 */
879struct extent_buffer *btrfs_read_node_slot(struct extent_buffer *parent,
880 int slot)
881{
882 int level = btrfs_header_level(parent);
883 struct btrfs_tree_parent_check check = { 0 };
884 struct extent_buffer *eb;
885
886 if (slot < 0 || slot >= btrfs_header_nritems(parent))
887 return ERR_PTR(-ENOENT);
888
889 ASSERT(level);
890
891 check.level = level - 1;
892 check.transid = btrfs_node_ptr_generation(parent, slot);
893 check.owner_root = btrfs_header_owner(parent);
894 check.has_first_key = true;
895 btrfs_node_key_to_cpu(parent, &check.first_key, slot);
896
897 eb = read_tree_block(parent->fs_info, btrfs_node_blockptr(parent, slot),
898 &check);
899 if (IS_ERR(eb))
900 return eb;
901 if (!extent_buffer_uptodate(eb)) {
902 free_extent_buffer(eb);
903 return ERR_PTR(-EIO);
904 }
905
906 return eb;
907}
908
909/*
910 * node level balancing, used to make sure nodes are in proper order for
911 * item deletion. We balance from the top down, so we have to make sure
912 * that a deletion won't leave an node completely empty later on.
913 */
914static noinline int balance_level(struct btrfs_trans_handle *trans,
915 struct btrfs_root *root,
916 struct btrfs_path *path, int level)
917{
918 struct btrfs_fs_info *fs_info = root->fs_info;
919 struct extent_buffer *right = NULL;
920 struct extent_buffer *mid;
921 struct extent_buffer *left = NULL;
922 struct extent_buffer *parent = NULL;
923 int ret = 0;
924 int wret;
925 int pslot;
926 int orig_slot = path->slots[level];
927 u64 orig_ptr;
928
929 ASSERT(level > 0);
930
931 mid = path->nodes[level];
932
933 WARN_ON(path->locks[level] != BTRFS_WRITE_LOCK);
934 WARN_ON(btrfs_header_generation(mid) != trans->transid);
935
936 orig_ptr = btrfs_node_blockptr(mid, orig_slot);
937
938 if (level < BTRFS_MAX_LEVEL - 1) {
939 parent = path->nodes[level + 1];
940 pslot = path->slots[level + 1];
941 }
942
943 /*
944 * deal with the case where there is only one pointer in the root
945 * by promoting the node below to a root
946 */
947 if (!parent) {
948 struct extent_buffer *child;
949
950 if (btrfs_header_nritems(mid) != 1)
951 return 0;
952
953 /* promote the child to a root */
954 child = btrfs_read_node_slot(mid, 0);
955 if (IS_ERR(child)) {
956 ret = PTR_ERR(child);
957 goto out;
958 }
959
960 btrfs_tree_lock(child);
961 ret = btrfs_cow_block(trans, root, child, mid, 0, &child,
962 BTRFS_NESTING_COW);
963 if (ret) {
964 btrfs_tree_unlock(child);
965 free_extent_buffer(child);
966 goto out;
967 }
968
969 ret = btrfs_tree_mod_log_insert_root(root->node, child, true);
970 if (ret < 0) {
971 btrfs_tree_unlock(child);
972 free_extent_buffer(child);
973 btrfs_abort_transaction(trans, ret);
974 goto out;
975 }
976 rcu_assign_pointer(root->node, child);
977
978 add_root_to_dirty_list(root);
979 btrfs_tree_unlock(child);
980
981 path->locks[level] = 0;
982 path->nodes[level] = NULL;
983 btrfs_clear_buffer_dirty(trans, mid);
984 btrfs_tree_unlock(mid);
985 /* once for the path */
986 free_extent_buffer(mid);
987
988 root_sub_used_bytes(root);
989 btrfs_free_tree_block(trans, btrfs_root_id(root), mid, 0, 1);
990 /* once for the root ptr */
991 free_extent_buffer_stale(mid);
992 return 0;
993 }
994 if (btrfs_header_nritems(mid) >
995 BTRFS_NODEPTRS_PER_BLOCK(fs_info) / 4)
996 return 0;
997
998 if (pslot) {
999 left = btrfs_read_node_slot(parent, pslot - 1);
1000 if (IS_ERR(left)) {
1001 ret = PTR_ERR(left);
1002 left = NULL;
1003 goto out;
1004 }
1005
1006 __btrfs_tree_lock(left, BTRFS_NESTING_LEFT);
1007 wret = btrfs_cow_block(trans, root, left,
1008 parent, pslot - 1, &left,
1009 BTRFS_NESTING_LEFT_COW);
1010 if (wret) {
1011 ret = wret;
1012 goto out;
1013 }
1014 }
1015
1016 if (pslot + 1 < btrfs_header_nritems(parent)) {
1017 right = btrfs_read_node_slot(parent, pslot + 1);
1018 if (IS_ERR(right)) {
1019 ret = PTR_ERR(right);
1020 right = NULL;
1021 goto out;
1022 }
1023
1024 __btrfs_tree_lock(right, BTRFS_NESTING_RIGHT);
1025 wret = btrfs_cow_block(trans, root, right,
1026 parent, pslot + 1, &right,
1027 BTRFS_NESTING_RIGHT_COW);
1028 if (wret) {
1029 ret = wret;
1030 goto out;
1031 }
1032 }
1033
1034 /* first, try to make some room in the middle buffer */
1035 if (left) {
1036 orig_slot += btrfs_header_nritems(left);
1037 wret = push_node_left(trans, left, mid, 1);
1038 if (wret < 0)
1039 ret = wret;
1040 }
1041
1042 /*
1043 * then try to empty the right most buffer into the middle
1044 */
1045 if (right) {
1046 wret = push_node_left(trans, mid, right, 1);
1047 if (wret < 0 && wret != -ENOSPC)
1048 ret = wret;
1049 if (btrfs_header_nritems(right) == 0) {
1050 btrfs_clear_buffer_dirty(trans, right);
1051 btrfs_tree_unlock(right);
1052 ret = btrfs_del_ptr(trans, root, path, level + 1, pslot + 1);
1053 if (ret < 0) {
1054 free_extent_buffer_stale(right);
1055 right = NULL;
1056 goto out;
1057 }
1058 root_sub_used_bytes(root);
1059 btrfs_free_tree_block(trans, btrfs_root_id(root), right,
1060 0, 1);
1061 free_extent_buffer_stale(right);
1062 right = NULL;
1063 } else {
1064 struct btrfs_disk_key right_key;
1065 btrfs_node_key(right, &right_key, 0);
1066 ret = btrfs_tree_mod_log_insert_key(parent, pslot + 1,
1067 BTRFS_MOD_LOG_KEY_REPLACE);
1068 if (ret < 0) {
1069 btrfs_abort_transaction(trans, ret);
1070 goto out;
1071 }
1072 btrfs_set_node_key(parent, &right_key, pslot + 1);
1073 btrfs_mark_buffer_dirty(trans, parent);
1074 }
1075 }
1076 if (btrfs_header_nritems(mid) == 1) {
1077 /*
1078 * we're not allowed to leave a node with one item in the
1079 * tree during a delete. A deletion from lower in the tree
1080 * could try to delete the only pointer in this node.
1081 * So, pull some keys from the left.
1082 * There has to be a left pointer at this point because
1083 * otherwise we would have pulled some pointers from the
1084 * right
1085 */
1086 if (unlikely(!left)) {
1087 btrfs_crit(fs_info,
1088"missing left child when middle child only has 1 item, parent bytenr %llu level %d mid bytenr %llu root %llu",
1089 parent->start, btrfs_header_level(parent),
1090 mid->start, btrfs_root_id(root));
1091 ret = -EUCLEAN;
1092 btrfs_abort_transaction(trans, ret);
1093 goto out;
1094 }
1095 wret = balance_node_right(trans, mid, left);
1096 if (wret < 0) {
1097 ret = wret;
1098 goto out;
1099 }
1100 if (wret == 1) {
1101 wret = push_node_left(trans, left, mid, 1);
1102 if (wret < 0)
1103 ret = wret;
1104 }
1105 BUG_ON(wret == 1);
1106 }
1107 if (btrfs_header_nritems(mid) == 0) {
1108 btrfs_clear_buffer_dirty(trans, mid);
1109 btrfs_tree_unlock(mid);
1110 ret = btrfs_del_ptr(trans, root, path, level + 1, pslot);
1111 if (ret < 0) {
1112 free_extent_buffer_stale(mid);
1113 mid = NULL;
1114 goto out;
1115 }
1116 root_sub_used_bytes(root);
1117 btrfs_free_tree_block(trans, btrfs_root_id(root), mid, 0, 1);
1118 free_extent_buffer_stale(mid);
1119 mid = NULL;
1120 } else {
1121 /* update the parent key to reflect our changes */
1122 struct btrfs_disk_key mid_key;
1123 btrfs_node_key(mid, &mid_key, 0);
1124 ret = btrfs_tree_mod_log_insert_key(parent, pslot,
1125 BTRFS_MOD_LOG_KEY_REPLACE);
1126 if (ret < 0) {
1127 btrfs_abort_transaction(trans, ret);
1128 goto out;
1129 }
1130 btrfs_set_node_key(parent, &mid_key, pslot);
1131 btrfs_mark_buffer_dirty(trans, parent);
1132 }
1133
1134 /* update the path */
1135 if (left) {
1136 if (btrfs_header_nritems(left) > orig_slot) {
1137 atomic_inc(&left->refs);
1138 /* left was locked after cow */
1139 path->nodes[level] = left;
1140 path->slots[level + 1] -= 1;
1141 path->slots[level] = orig_slot;
1142 if (mid) {
1143 btrfs_tree_unlock(mid);
1144 free_extent_buffer(mid);
1145 }
1146 } else {
1147 orig_slot -= btrfs_header_nritems(left);
1148 path->slots[level] = orig_slot;
1149 }
1150 }
1151 /* double check we haven't messed things up */
1152 if (orig_ptr !=
1153 btrfs_node_blockptr(path->nodes[level], path->slots[level]))
1154 BUG();
1155out:
1156 if (right) {
1157 btrfs_tree_unlock(right);
1158 free_extent_buffer(right);
1159 }
1160 if (left) {
1161 if (path->nodes[level] != left)
1162 btrfs_tree_unlock(left);
1163 free_extent_buffer(left);
1164 }
1165 return ret;
1166}
1167
1168/* Node balancing for insertion. Here we only split or push nodes around
1169 * when they are completely full. This is also done top down, so we
1170 * have to be pessimistic.
1171 */
1172static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans,
1173 struct btrfs_root *root,
1174 struct btrfs_path *path, int level)
1175{
1176 struct btrfs_fs_info *fs_info = root->fs_info;
1177 struct extent_buffer *right = NULL;
1178 struct extent_buffer *mid;
1179 struct extent_buffer *left = NULL;
1180 struct extent_buffer *parent = NULL;
1181 int ret = 0;
1182 int wret;
1183 int pslot;
1184 int orig_slot = path->slots[level];
1185
1186 if (level == 0)
1187 return 1;
1188
1189 mid = path->nodes[level];
1190 WARN_ON(btrfs_header_generation(mid) != trans->transid);
1191
1192 if (level < BTRFS_MAX_LEVEL - 1) {
1193 parent = path->nodes[level + 1];
1194 pslot = path->slots[level + 1];
1195 }
1196
1197 if (!parent)
1198 return 1;
1199
1200 /* first, try to make some room in the middle buffer */
1201 if (pslot) {
1202 u32 left_nr;
1203
1204 left = btrfs_read_node_slot(parent, pslot - 1);
1205 if (IS_ERR(left))
1206 return PTR_ERR(left);
1207
1208 __btrfs_tree_lock(left, BTRFS_NESTING_LEFT);
1209
1210 left_nr = btrfs_header_nritems(left);
1211 if (left_nr >= BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 1) {
1212 wret = 1;
1213 } else {
1214 ret = btrfs_cow_block(trans, root, left, parent,
1215 pslot - 1, &left,
1216 BTRFS_NESTING_LEFT_COW);
1217 if (ret)
1218 wret = 1;
1219 else {
1220 wret = push_node_left(trans, left, mid, 0);
1221 }
1222 }
1223 if (wret < 0)
1224 ret = wret;
1225 if (wret == 0) {
1226 struct btrfs_disk_key disk_key;
1227 orig_slot += left_nr;
1228 btrfs_node_key(mid, &disk_key, 0);
1229 ret = btrfs_tree_mod_log_insert_key(parent, pslot,
1230 BTRFS_MOD_LOG_KEY_REPLACE);
1231 if (ret < 0) {
1232 btrfs_tree_unlock(left);
1233 free_extent_buffer(left);
1234 btrfs_abort_transaction(trans, ret);
1235 return ret;
1236 }
1237 btrfs_set_node_key(parent, &disk_key, pslot);
1238 btrfs_mark_buffer_dirty(trans, parent);
1239 if (btrfs_header_nritems(left) > orig_slot) {
1240 path->nodes[level] = left;
1241 path->slots[level + 1] -= 1;
1242 path->slots[level] = orig_slot;
1243 btrfs_tree_unlock(mid);
1244 free_extent_buffer(mid);
1245 } else {
1246 orig_slot -=
1247 btrfs_header_nritems(left);
1248 path->slots[level] = orig_slot;
1249 btrfs_tree_unlock(left);
1250 free_extent_buffer(left);
1251 }
1252 return 0;
1253 }
1254 btrfs_tree_unlock(left);
1255 free_extent_buffer(left);
1256 }
1257
1258 /*
1259 * then try to empty the right most buffer into the middle
1260 */
1261 if (pslot + 1 < btrfs_header_nritems(parent)) {
1262 u32 right_nr;
1263
1264 right = btrfs_read_node_slot(parent, pslot + 1);
1265 if (IS_ERR(right))
1266 return PTR_ERR(right);
1267
1268 __btrfs_tree_lock(right, BTRFS_NESTING_RIGHT);
1269
1270 right_nr = btrfs_header_nritems(right);
1271 if (right_nr >= BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 1) {
1272 wret = 1;
1273 } else {
1274 ret = btrfs_cow_block(trans, root, right,
1275 parent, pslot + 1,
1276 &right, BTRFS_NESTING_RIGHT_COW);
1277 if (ret)
1278 wret = 1;
1279 else {
1280 wret = balance_node_right(trans, right, mid);
1281 }
1282 }
1283 if (wret < 0)
1284 ret = wret;
1285 if (wret == 0) {
1286 struct btrfs_disk_key disk_key;
1287
1288 btrfs_node_key(right, &disk_key, 0);
1289 ret = btrfs_tree_mod_log_insert_key(parent, pslot + 1,
1290 BTRFS_MOD_LOG_KEY_REPLACE);
1291 if (ret < 0) {
1292 btrfs_tree_unlock(right);
1293 free_extent_buffer(right);
1294 btrfs_abort_transaction(trans, ret);
1295 return ret;
1296 }
1297 btrfs_set_node_key(parent, &disk_key, pslot + 1);
1298 btrfs_mark_buffer_dirty(trans, parent);
1299
1300 if (btrfs_header_nritems(mid) <= orig_slot) {
1301 path->nodes[level] = right;
1302 path->slots[level + 1] += 1;
1303 path->slots[level] = orig_slot -
1304 btrfs_header_nritems(mid);
1305 btrfs_tree_unlock(mid);
1306 free_extent_buffer(mid);
1307 } else {
1308 btrfs_tree_unlock(right);
1309 free_extent_buffer(right);
1310 }
1311 return 0;
1312 }
1313 btrfs_tree_unlock(right);
1314 free_extent_buffer(right);
1315 }
1316 return 1;
1317}
1318
1319/*
1320 * readahead one full node of leaves, finding things that are close
1321 * to the block in 'slot', and triggering ra on them.
1322 */
1323static void reada_for_search(struct btrfs_fs_info *fs_info,
1324 struct btrfs_path *path,
1325 int level, int slot, u64 objectid)
1326{
1327 struct extent_buffer *node;
1328 struct btrfs_disk_key disk_key;
1329 u32 nritems;
1330 u64 search;
1331 u64 target;
1332 u64 nread = 0;
1333 u64 nread_max;
1334 u32 nr;
1335 u32 blocksize;
1336 u32 nscan = 0;
1337
1338 if (level != 1 && path->reada != READA_FORWARD_ALWAYS)
1339 return;
1340
1341 if (!path->nodes[level])
1342 return;
1343
1344 node = path->nodes[level];
1345
1346 /*
1347 * Since the time between visiting leaves is much shorter than the time
1348 * between visiting nodes, limit read ahead of nodes to 1, to avoid too
1349 * much IO at once (possibly random).
1350 */
1351 if (path->reada == READA_FORWARD_ALWAYS) {
1352 if (level > 1)
1353 nread_max = node->fs_info->nodesize;
1354 else
1355 nread_max = SZ_128K;
1356 } else {
1357 nread_max = SZ_64K;
1358 }
1359
1360 search = btrfs_node_blockptr(node, slot);
1361 blocksize = fs_info->nodesize;
1362 if (path->reada != READA_FORWARD_ALWAYS) {
1363 struct extent_buffer *eb;
1364
1365 eb = find_extent_buffer(fs_info, search);
1366 if (eb) {
1367 free_extent_buffer(eb);
1368 return;
1369 }
1370 }
1371
1372 target = search;
1373
1374 nritems = btrfs_header_nritems(node);
1375 nr = slot;
1376
1377 while (1) {
1378 if (path->reada == READA_BACK) {
1379 if (nr == 0)
1380 break;
1381 nr--;
1382 } else if (path->reada == READA_FORWARD ||
1383 path->reada == READA_FORWARD_ALWAYS) {
1384 nr++;
1385 if (nr >= nritems)
1386 break;
1387 }
1388 if (path->reada == READA_BACK && objectid) {
1389 btrfs_node_key(node, &disk_key, nr);
1390 if (btrfs_disk_key_objectid(&disk_key) != objectid)
1391 break;
1392 }
1393 search = btrfs_node_blockptr(node, nr);
1394 if (path->reada == READA_FORWARD_ALWAYS ||
1395 (search <= target && target - search <= 65536) ||
1396 (search > target && search - target <= 65536)) {
1397 btrfs_readahead_node_child(node, nr);
1398 nread += blocksize;
1399 }
1400 nscan++;
1401 if (nread > nread_max || nscan > 32)
1402 break;
1403 }
1404}
1405
1406static noinline void reada_for_balance(struct btrfs_path *path, int level)
1407{
1408 struct extent_buffer *parent;
1409 int slot;
1410 int nritems;
1411
1412 parent = path->nodes[level + 1];
1413 if (!parent)
1414 return;
1415
1416 nritems = btrfs_header_nritems(parent);
1417 slot = path->slots[level + 1];
1418
1419 if (slot > 0)
1420 btrfs_readahead_node_child(parent, slot - 1);
1421 if (slot + 1 < nritems)
1422 btrfs_readahead_node_child(parent, slot + 1);
1423}
1424
1425
1426/*
1427 * when we walk down the tree, it is usually safe to unlock the higher layers
1428 * in the tree. The exceptions are when our path goes through slot 0, because
1429 * operations on the tree might require changing key pointers higher up in the
1430 * tree.
1431 *
1432 * callers might also have set path->keep_locks, which tells this code to keep
1433 * the lock if the path points to the last slot in the block. This is part of
1434 * walking through the tree, and selecting the next slot in the higher block.
1435 *
1436 * lowest_unlock sets the lowest level in the tree we're allowed to unlock. so
1437 * if lowest_unlock is 1, level 0 won't be unlocked
1438 */
1439static noinline void unlock_up(struct btrfs_path *path, int level,
1440 int lowest_unlock, int min_write_lock_level,
1441 int *write_lock_level)
1442{
1443 int i;
1444 int skip_level = level;
1445 bool check_skip = true;
1446
1447 for (i = level; i < BTRFS_MAX_LEVEL; i++) {
1448 if (!path->nodes[i])
1449 break;
1450 if (!path->locks[i])
1451 break;
1452
1453 if (check_skip) {
1454 if (path->slots[i] == 0) {
1455 skip_level = i + 1;
1456 continue;
1457 }
1458
1459 if (path->keep_locks) {
1460 u32 nritems;
1461
1462 nritems = btrfs_header_nritems(path->nodes[i]);
1463 if (nritems < 1 || path->slots[i] >= nritems - 1) {
1464 skip_level = i + 1;
1465 continue;
1466 }
1467 }
1468 }
1469
1470 if (i >= lowest_unlock && i > skip_level) {
1471 check_skip = false;
1472 btrfs_tree_unlock_rw(path->nodes[i], path->locks[i]);
1473 path->locks[i] = 0;
1474 if (write_lock_level &&
1475 i > min_write_lock_level &&
1476 i <= *write_lock_level) {
1477 *write_lock_level = i - 1;
1478 }
1479 }
1480 }
1481}
1482
1483/*
1484 * Helper function for btrfs_search_slot() and other functions that do a search
1485 * on a btree. The goal is to find a tree block in the cache (the radix tree at
1486 * fs_info->buffer_radix), but if we can't find it, or it's not up to date, read
1487 * its pages from disk.
1488 *
1489 * Returns -EAGAIN, with the path unlocked, if the caller needs to repeat the
1490 * whole btree search, starting again from the current root node.
1491 */
1492static int
1493read_block_for_search(struct btrfs_root *root, struct btrfs_path *p,
1494 struct extent_buffer **eb_ret, int level, int slot,
1495 const struct btrfs_key *key)
1496{
1497 struct btrfs_fs_info *fs_info = root->fs_info;
1498 struct btrfs_tree_parent_check check = { 0 };
1499 u64 blocknr;
1500 u64 gen;
1501 struct extent_buffer *tmp;
1502 int ret;
1503 int parent_level;
1504 bool unlock_up;
1505
1506 unlock_up = ((level + 1 < BTRFS_MAX_LEVEL) && p->locks[level + 1]);
1507 blocknr = btrfs_node_blockptr(*eb_ret, slot);
1508 gen = btrfs_node_ptr_generation(*eb_ret, slot);
1509 parent_level = btrfs_header_level(*eb_ret);
1510 btrfs_node_key_to_cpu(*eb_ret, &check.first_key, slot);
1511 check.has_first_key = true;
1512 check.level = parent_level - 1;
1513 check.transid = gen;
1514 check.owner_root = root->root_key.objectid;
1515
1516 /*
1517 * If we need to read an extent buffer from disk and we are holding locks
1518 * on upper level nodes, we unlock all the upper nodes before reading the
1519 * extent buffer, and then return -EAGAIN to the caller as it needs to
1520 * restart the search. We don't release the lock on the current level
1521 * because we need to walk this node to figure out which blocks to read.
1522 */
1523 tmp = find_extent_buffer(fs_info, blocknr);
1524 if (tmp) {
1525 if (p->reada == READA_FORWARD_ALWAYS)
1526 reada_for_search(fs_info, p, level, slot, key->objectid);
1527
1528 /* first we do an atomic uptodate check */
1529 if (btrfs_buffer_uptodate(tmp, gen, 1) > 0) {
1530 /*
1531 * Do extra check for first_key, eb can be stale due to
1532 * being cached, read from scrub, or have multiple
1533 * parents (shared tree blocks).
1534 */
1535 if (btrfs_verify_level_key(tmp,
1536 parent_level - 1, &check.first_key, gen)) {
1537 free_extent_buffer(tmp);
1538 return -EUCLEAN;
1539 }
1540 *eb_ret = tmp;
1541 return 0;
1542 }
1543
1544 if (p->nowait) {
1545 free_extent_buffer(tmp);
1546 return -EAGAIN;
1547 }
1548
1549 if (unlock_up)
1550 btrfs_unlock_up_safe(p, level + 1);
1551
1552 /* now we're allowed to do a blocking uptodate check */
1553 ret = btrfs_read_extent_buffer(tmp, &check);
1554 if (ret) {
1555 free_extent_buffer(tmp);
1556 btrfs_release_path(p);
1557 return -EIO;
1558 }
1559 if (btrfs_check_eb_owner(tmp, root->root_key.objectid)) {
1560 free_extent_buffer(tmp);
1561 btrfs_release_path(p);
1562 return -EUCLEAN;
1563 }
1564
1565 if (unlock_up)
1566 ret = -EAGAIN;
1567
1568 goto out;
1569 } else if (p->nowait) {
1570 return -EAGAIN;
1571 }
1572
1573 if (unlock_up) {
1574 btrfs_unlock_up_safe(p, level + 1);
1575 ret = -EAGAIN;
1576 } else {
1577 ret = 0;
1578 }
1579
1580 if (p->reada != READA_NONE)
1581 reada_for_search(fs_info, p, level, slot, key->objectid);
1582
1583 tmp = read_tree_block(fs_info, blocknr, &check);
1584 if (IS_ERR(tmp)) {
1585 btrfs_release_path(p);
1586 return PTR_ERR(tmp);
1587 }
1588 /*
1589 * If the read above didn't mark this buffer up to date,
1590 * it will never end up being up to date. Set ret to EIO now
1591 * and give up so that our caller doesn't loop forever
1592 * on our EAGAINs.
1593 */
1594 if (!extent_buffer_uptodate(tmp))
1595 ret = -EIO;
1596
1597out:
1598 if (ret == 0) {
1599 *eb_ret = tmp;
1600 } else {
1601 free_extent_buffer(tmp);
1602 btrfs_release_path(p);
1603 }
1604
1605 return ret;
1606}
1607
1608/*
1609 * helper function for btrfs_search_slot. This does all of the checks
1610 * for node-level blocks and does any balancing required based on
1611 * the ins_len.
1612 *
1613 * If no extra work was required, zero is returned. If we had to
1614 * drop the path, -EAGAIN is returned and btrfs_search_slot must
1615 * start over
1616 */
1617static int
1618setup_nodes_for_search(struct btrfs_trans_handle *trans,
1619 struct btrfs_root *root, struct btrfs_path *p,
1620 struct extent_buffer *b, int level, int ins_len,
1621 int *write_lock_level)
1622{
1623 struct btrfs_fs_info *fs_info = root->fs_info;
1624 int ret = 0;
1625
1626 if ((p->search_for_split || ins_len > 0) && btrfs_header_nritems(b) >=
1627 BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 3) {
1628
1629 if (*write_lock_level < level + 1) {
1630 *write_lock_level = level + 1;
1631 btrfs_release_path(p);
1632 return -EAGAIN;
1633 }
1634
1635 reada_for_balance(p, level);
1636 ret = split_node(trans, root, p, level);
1637
1638 b = p->nodes[level];
1639 } else if (ins_len < 0 && btrfs_header_nritems(b) <
1640 BTRFS_NODEPTRS_PER_BLOCK(fs_info) / 2) {
1641
1642 if (*write_lock_level < level + 1) {
1643 *write_lock_level = level + 1;
1644 btrfs_release_path(p);
1645 return -EAGAIN;
1646 }
1647
1648 reada_for_balance(p, level);
1649 ret = balance_level(trans, root, p, level);
1650 if (ret)
1651 return ret;
1652
1653 b = p->nodes[level];
1654 if (!b) {
1655 btrfs_release_path(p);
1656 return -EAGAIN;
1657 }
1658 BUG_ON(btrfs_header_nritems(b) == 1);
1659 }
1660 return ret;
1661}
1662
1663int btrfs_find_item(struct btrfs_root *fs_root, struct btrfs_path *path,
1664 u64 iobjectid, u64 ioff, u8 key_type,
1665 struct btrfs_key *found_key)
1666{
1667 int ret;
1668 struct btrfs_key key;
1669 struct extent_buffer *eb;
1670
1671 ASSERT(path);
1672 ASSERT(found_key);
1673
1674 key.type = key_type;
1675 key.objectid = iobjectid;
1676 key.offset = ioff;
1677
1678 ret = btrfs_search_slot(NULL, fs_root, &key, path, 0, 0);
1679 if (ret < 0)
1680 return ret;
1681
1682 eb = path->nodes[0];
1683 if (ret && path->slots[0] >= btrfs_header_nritems(eb)) {
1684 ret = btrfs_next_leaf(fs_root, path);
1685 if (ret)
1686 return ret;
1687 eb = path->nodes[0];
1688 }
1689
1690 btrfs_item_key_to_cpu(eb, found_key, path->slots[0]);
1691 if (found_key->type != key.type ||
1692 found_key->objectid != key.objectid)
1693 return 1;
1694
1695 return 0;
1696}
1697
1698static struct extent_buffer *btrfs_search_slot_get_root(struct btrfs_root *root,
1699 struct btrfs_path *p,
1700 int write_lock_level)
1701{
1702 struct extent_buffer *b;
1703 int root_lock = 0;
1704 int level = 0;
1705
1706 if (p->search_commit_root) {
1707 b = root->commit_root;
1708 atomic_inc(&b->refs);
1709 level = btrfs_header_level(b);
1710 /*
1711 * Ensure that all callers have set skip_locking when
1712 * p->search_commit_root = 1.
1713 */
1714 ASSERT(p->skip_locking == 1);
1715
1716 goto out;
1717 }
1718
1719 if (p->skip_locking) {
1720 b = btrfs_root_node(root);
1721 level = btrfs_header_level(b);
1722 goto out;
1723 }
1724
1725 /* We try very hard to do read locks on the root */
1726 root_lock = BTRFS_READ_LOCK;
1727
1728 /*
1729 * If the level is set to maximum, we can skip trying to get the read
1730 * lock.
1731 */
1732 if (write_lock_level < BTRFS_MAX_LEVEL) {
1733 /*
1734 * We don't know the level of the root node until we actually
1735 * have it read locked
1736 */
1737 if (p->nowait) {
1738 b = btrfs_try_read_lock_root_node(root);
1739 if (IS_ERR(b))
1740 return b;
1741 } else {
1742 b = btrfs_read_lock_root_node(root);
1743 }
1744 level = btrfs_header_level(b);
1745 if (level > write_lock_level)
1746 goto out;
1747
1748 /* Whoops, must trade for write lock */
1749 btrfs_tree_read_unlock(b);
1750 free_extent_buffer(b);
1751 }
1752
1753 b = btrfs_lock_root_node(root);
1754 root_lock = BTRFS_WRITE_LOCK;
1755
1756 /* The level might have changed, check again */
1757 level = btrfs_header_level(b);
1758
1759out:
1760 /*
1761 * The root may have failed to write out at some point, and thus is no
1762 * longer valid, return an error in this case.
1763 */
1764 if (!extent_buffer_uptodate(b)) {
1765 if (root_lock)
1766 btrfs_tree_unlock_rw(b, root_lock);
1767 free_extent_buffer(b);
1768 return ERR_PTR(-EIO);
1769 }
1770
1771 p->nodes[level] = b;
1772 if (!p->skip_locking)
1773 p->locks[level] = root_lock;
1774 /*
1775 * Callers are responsible for dropping b's references.
1776 */
1777 return b;
1778}
1779
1780/*
1781 * Replace the extent buffer at the lowest level of the path with a cloned
1782 * version. The purpose is to be able to use it safely, after releasing the
1783 * commit root semaphore, even if relocation is happening in parallel, the
1784 * transaction used for relocation is committed and the extent buffer is
1785 * reallocated in the next transaction.
1786 *
1787 * This is used in a context where the caller does not prevent transaction
1788 * commits from happening, either by holding a transaction handle or holding
1789 * some lock, while it's doing searches through a commit root.
1790 * At the moment it's only used for send operations.
1791 */
1792static int finish_need_commit_sem_search(struct btrfs_path *path)
1793{
1794 const int i = path->lowest_level;
1795 const int slot = path->slots[i];
1796 struct extent_buffer *lowest = path->nodes[i];
1797 struct extent_buffer *clone;
1798
1799 ASSERT(path->need_commit_sem);
1800
1801 if (!lowest)
1802 return 0;
1803
1804 lockdep_assert_held_read(&lowest->fs_info->commit_root_sem);
1805
1806 clone = btrfs_clone_extent_buffer(lowest);
1807 if (!clone)
1808 return -ENOMEM;
1809
1810 btrfs_release_path(path);
1811 path->nodes[i] = clone;
1812 path->slots[i] = slot;
1813
1814 return 0;
1815}
1816
1817static inline int search_for_key_slot(struct extent_buffer *eb,
1818 int search_low_slot,
1819 const struct btrfs_key *key,
1820 int prev_cmp,
1821 int *slot)
1822{
1823 /*
1824 * If a previous call to btrfs_bin_search() on a parent node returned an
1825 * exact match (prev_cmp == 0), we can safely assume the target key will
1826 * always be at slot 0 on lower levels, since each key pointer
1827 * (struct btrfs_key_ptr) refers to the lowest key accessible from the
1828 * subtree it points to. Thus we can skip searching lower levels.
1829 */
1830 if (prev_cmp == 0) {
1831 *slot = 0;
1832 return 0;
1833 }
1834
1835 return btrfs_bin_search(eb, search_low_slot, key, slot);
1836}
1837
1838static int search_leaf(struct btrfs_trans_handle *trans,
1839 struct btrfs_root *root,
1840 const struct btrfs_key *key,
1841 struct btrfs_path *path,
1842 int ins_len,
1843 int prev_cmp)
1844{
1845 struct extent_buffer *leaf = path->nodes[0];
1846 int leaf_free_space = -1;
1847 int search_low_slot = 0;
1848 int ret;
1849 bool do_bin_search = true;
1850
1851 /*
1852 * If we are doing an insertion, the leaf has enough free space and the
1853 * destination slot for the key is not slot 0, then we can unlock our
1854 * write lock on the parent, and any other upper nodes, before doing the
1855 * binary search on the leaf (with search_for_key_slot()), allowing other
1856 * tasks to lock the parent and any other upper nodes.
1857 */
1858 if (ins_len > 0) {
1859 /*
1860 * Cache the leaf free space, since we will need it later and it
1861 * will not change until then.
1862 */
1863 leaf_free_space = btrfs_leaf_free_space(leaf);
1864
1865 /*
1866 * !path->locks[1] means we have a single node tree, the leaf is
1867 * the root of the tree.
1868 */
1869 if (path->locks[1] && leaf_free_space >= ins_len) {
1870 struct btrfs_disk_key first_key;
1871
1872 ASSERT(btrfs_header_nritems(leaf) > 0);
1873 btrfs_item_key(leaf, &first_key, 0);
1874
1875 /*
1876 * Doing the extra comparison with the first key is cheap,
1877 * taking into account that the first key is very likely
1878 * already in a cache line because it immediately follows
1879 * the extent buffer's header and we have recently accessed
1880 * the header's level field.
1881 */
1882 ret = btrfs_comp_keys(&first_key, key);
1883 if (ret < 0) {
1884 /*
1885 * The first key is smaller than the key we want
1886 * to insert, so we are safe to unlock all upper
1887 * nodes and we have to do the binary search.
1888 *
1889 * We do use btrfs_unlock_up_safe() and not
1890 * unlock_up() because the later does not unlock
1891 * nodes with a slot of 0 - we can safely unlock
1892 * any node even if its slot is 0 since in this
1893 * case the key does not end up at slot 0 of the
1894 * leaf and there's no need to split the leaf.
1895 */
1896 btrfs_unlock_up_safe(path, 1);
1897 search_low_slot = 1;
1898 } else {
1899 /*
1900 * The first key is >= then the key we want to
1901 * insert, so we can skip the binary search as
1902 * the target key will be at slot 0.
1903 *
1904 * We can not unlock upper nodes when the key is
1905 * less than the first key, because we will need
1906 * to update the key at slot 0 of the parent node
1907 * and possibly of other upper nodes too.
1908 * If the key matches the first key, then we can
1909 * unlock all the upper nodes, using
1910 * btrfs_unlock_up_safe() instead of unlock_up()
1911 * as stated above.
1912 */
1913 if (ret == 0)
1914 btrfs_unlock_up_safe(path, 1);
1915 /*
1916 * ret is already 0 or 1, matching the result of
1917 * a btrfs_bin_search() call, so there is no need
1918 * to adjust it.
1919 */
1920 do_bin_search = false;
1921 path->slots[0] = 0;
1922 }
1923 }
1924 }
1925
1926 if (do_bin_search) {
1927 ret = search_for_key_slot(leaf, search_low_slot, key,
1928 prev_cmp, &path->slots[0]);
1929 if (ret < 0)
1930 return ret;
1931 }
1932
1933 if (ins_len > 0) {
1934 /*
1935 * Item key already exists. In this case, if we are allowed to
1936 * insert the item (for example, in dir_item case, item key
1937 * collision is allowed), it will be merged with the original
1938 * item. Only the item size grows, no new btrfs item will be
1939 * added. If search_for_extension is not set, ins_len already
1940 * accounts the size btrfs_item, deduct it here so leaf space
1941 * check will be correct.
1942 */
1943 if (ret == 0 && !path->search_for_extension) {
1944 ASSERT(ins_len >= sizeof(struct btrfs_item));
1945 ins_len -= sizeof(struct btrfs_item);
1946 }
1947
1948 ASSERT(leaf_free_space >= 0);
1949
1950 if (leaf_free_space < ins_len) {
1951 int err;
1952
1953 err = split_leaf(trans, root, key, path, ins_len,
1954 (ret == 0));
1955 ASSERT(err <= 0);
1956 if (WARN_ON(err > 0))
1957 err = -EUCLEAN;
1958 if (err)
1959 ret = err;
1960 }
1961 }
1962
1963 return ret;
1964}
1965
1966/*
1967 * Look for a key in a tree and perform necessary modifications to preserve
1968 * tree invariants.
1969 *
1970 * @trans: Handle of transaction, used when modifying the tree
1971 * @p: Holds all btree nodes along the search path
1972 * @root: The root node of the tree
1973 * @key: The key we are looking for
1974 * @ins_len: Indicates purpose of search:
1975 * >0 for inserts it's size of item inserted (*)
1976 * <0 for deletions
1977 * 0 for plain searches, not modifying the tree
1978 *
1979 * (*) If size of item inserted doesn't include
1980 * sizeof(struct btrfs_item), then p->search_for_extension must
1981 * be set.
1982 * @cow: boolean should CoW operations be performed. Must always be 1
1983 * when modifying the tree.
1984 *
1985 * If @ins_len > 0, nodes and leaves will be split as we walk down the tree.
1986 * If @ins_len < 0, nodes will be merged as we walk down the tree (if possible)
1987 *
1988 * If @key is found, 0 is returned and you can find the item in the leaf level
1989 * of the path (level 0)
1990 *
1991 * If @key isn't found, 1 is returned and the leaf level of the path (level 0)
1992 * points to the slot where it should be inserted
1993 *
1994 * If an error is encountered while searching the tree a negative error number
1995 * is returned
1996 */
1997int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1998 const struct btrfs_key *key, struct btrfs_path *p,
1999 int ins_len, int cow)
2000{
2001 struct btrfs_fs_info *fs_info = root->fs_info;
2002 struct extent_buffer *b;
2003 int slot;
2004 int ret;
2005 int err;
2006 int level;
2007 int lowest_unlock = 1;
2008 /* everything at write_lock_level or lower must be write locked */
2009 int write_lock_level = 0;
2010 u8 lowest_level = 0;
2011 int min_write_lock_level;
2012 int prev_cmp;
2013
2014 might_sleep();
2015
2016 lowest_level = p->lowest_level;
2017 WARN_ON(lowest_level && ins_len > 0);
2018 WARN_ON(p->nodes[0] != NULL);
2019 BUG_ON(!cow && ins_len);
2020
2021 /*
2022 * For now only allow nowait for read only operations. There's no
2023 * strict reason why we can't, we just only need it for reads so it's
2024 * only implemented for reads.
2025 */
2026 ASSERT(!p->nowait || !cow);
2027
2028 if (ins_len < 0) {
2029 lowest_unlock = 2;
2030
2031 /* when we are removing items, we might have to go up to level
2032 * two as we update tree pointers Make sure we keep write
2033 * for those levels as well
2034 */
2035 write_lock_level = 2;
2036 } else if (ins_len > 0) {
2037 /*
2038 * for inserting items, make sure we have a write lock on
2039 * level 1 so we can update keys
2040 */
2041 write_lock_level = 1;
2042 }
2043
2044 if (!cow)
2045 write_lock_level = -1;
2046
2047 if (cow && (p->keep_locks || p->lowest_level))
2048 write_lock_level = BTRFS_MAX_LEVEL;
2049
2050 min_write_lock_level = write_lock_level;
2051
2052 if (p->need_commit_sem) {
2053 ASSERT(p->search_commit_root);
2054 if (p->nowait) {
2055 if (!down_read_trylock(&fs_info->commit_root_sem))
2056 return -EAGAIN;
2057 } else {
2058 down_read(&fs_info->commit_root_sem);
2059 }
2060 }
2061
2062again:
2063 prev_cmp = -1;
2064 b = btrfs_search_slot_get_root(root, p, write_lock_level);
2065 if (IS_ERR(b)) {
2066 ret = PTR_ERR(b);
2067 goto done;
2068 }
2069
2070 while (b) {
2071 int dec = 0;
2072
2073 level = btrfs_header_level(b);
2074
2075 if (cow) {
2076 bool last_level = (level == (BTRFS_MAX_LEVEL - 1));
2077
2078 /*
2079 * if we don't really need to cow this block
2080 * then we don't want to set the path blocking,
2081 * so we test it here
2082 */
2083 if (!should_cow_block(trans, root, b))
2084 goto cow_done;
2085
2086 /*
2087 * must have write locks on this node and the
2088 * parent
2089 */
2090 if (level > write_lock_level ||
2091 (level + 1 > write_lock_level &&
2092 level + 1 < BTRFS_MAX_LEVEL &&
2093 p->nodes[level + 1])) {
2094 write_lock_level = level + 1;
2095 btrfs_release_path(p);
2096 goto again;
2097 }
2098
2099 if (last_level)
2100 err = btrfs_cow_block(trans, root, b, NULL, 0,
2101 &b,
2102 BTRFS_NESTING_COW);
2103 else
2104 err = btrfs_cow_block(trans, root, b,
2105 p->nodes[level + 1],
2106 p->slots[level + 1], &b,
2107 BTRFS_NESTING_COW);
2108 if (err) {
2109 ret = err;
2110 goto done;
2111 }
2112 }
2113cow_done:
2114 p->nodes[level] = b;
2115
2116 /*
2117 * we have a lock on b and as long as we aren't changing
2118 * the tree, there is no way to for the items in b to change.
2119 * It is safe to drop the lock on our parent before we
2120 * go through the expensive btree search on b.
2121 *
2122 * If we're inserting or deleting (ins_len != 0), then we might
2123 * be changing slot zero, which may require changing the parent.
2124 * So, we can't drop the lock until after we know which slot
2125 * we're operating on.
2126 */
2127 if (!ins_len && !p->keep_locks) {
2128 int u = level + 1;
2129
2130 if (u < BTRFS_MAX_LEVEL && p->locks[u]) {
2131 btrfs_tree_unlock_rw(p->nodes[u], p->locks[u]);
2132 p->locks[u] = 0;
2133 }
2134 }
2135
2136 if (level == 0) {
2137 if (ins_len > 0)
2138 ASSERT(write_lock_level >= 1);
2139
2140 ret = search_leaf(trans, root, key, p, ins_len, prev_cmp);
2141 if (!p->search_for_split)
2142 unlock_up(p, level, lowest_unlock,
2143 min_write_lock_level, NULL);
2144 goto done;
2145 }
2146
2147 ret = search_for_key_slot(b, 0, key, prev_cmp, &slot);
2148 if (ret < 0)
2149 goto done;
2150 prev_cmp = ret;
2151
2152 if (ret && slot > 0) {
2153 dec = 1;
2154 slot--;
2155 }
2156 p->slots[level] = slot;
2157 err = setup_nodes_for_search(trans, root, p, b, level, ins_len,
2158 &write_lock_level);
2159 if (err == -EAGAIN)
2160 goto again;
2161 if (err) {
2162 ret = err;
2163 goto done;
2164 }
2165 b = p->nodes[level];
2166 slot = p->slots[level];
2167
2168 /*
2169 * Slot 0 is special, if we change the key we have to update
2170 * the parent pointer which means we must have a write lock on
2171 * the parent
2172 */
2173 if (slot == 0 && ins_len && write_lock_level < level + 1) {
2174 write_lock_level = level + 1;
2175 btrfs_release_path(p);
2176 goto again;
2177 }
2178
2179 unlock_up(p, level, lowest_unlock, min_write_lock_level,
2180 &write_lock_level);
2181
2182 if (level == lowest_level) {
2183 if (dec)
2184 p->slots[level]++;
2185 goto done;
2186 }
2187
2188 err = read_block_for_search(root, p, &b, level, slot, key);
2189 if (err == -EAGAIN)
2190 goto again;
2191 if (err) {
2192 ret = err;
2193 goto done;
2194 }
2195
2196 if (!p->skip_locking) {
2197 level = btrfs_header_level(b);
2198
2199 btrfs_maybe_reset_lockdep_class(root, b);
2200
2201 if (level <= write_lock_level) {
2202 btrfs_tree_lock(b);
2203 p->locks[level] = BTRFS_WRITE_LOCK;
2204 } else {
2205 if (p->nowait) {
2206 if (!btrfs_try_tree_read_lock(b)) {
2207 free_extent_buffer(b);
2208 ret = -EAGAIN;
2209 goto done;
2210 }
2211 } else {
2212 btrfs_tree_read_lock(b);
2213 }
2214 p->locks[level] = BTRFS_READ_LOCK;
2215 }
2216 p->nodes[level] = b;
2217 }
2218 }
2219 ret = 1;
2220done:
2221 if (ret < 0 && !p->skip_release_on_error)
2222 btrfs_release_path(p);
2223
2224 if (p->need_commit_sem) {
2225 int ret2;
2226
2227 ret2 = finish_need_commit_sem_search(p);
2228 up_read(&fs_info->commit_root_sem);
2229 if (ret2)
2230 ret = ret2;
2231 }
2232
2233 return ret;
2234}
2235ALLOW_ERROR_INJECTION(btrfs_search_slot, ERRNO);
2236
2237/*
2238 * Like btrfs_search_slot, this looks for a key in the given tree. It uses the
2239 * current state of the tree together with the operations recorded in the tree
2240 * modification log to search for the key in a previous version of this tree, as
2241 * denoted by the time_seq parameter.
2242 *
2243 * Naturally, there is no support for insert, delete or cow operations.
2244 *
2245 * The resulting path and return value will be set up as if we called
2246 * btrfs_search_slot at that point in time with ins_len and cow both set to 0.
2247 */
2248int btrfs_search_old_slot(struct btrfs_root *root, const struct btrfs_key *key,
2249 struct btrfs_path *p, u64 time_seq)
2250{
2251 struct btrfs_fs_info *fs_info = root->fs_info;
2252 struct extent_buffer *b;
2253 int slot;
2254 int ret;
2255 int err;
2256 int level;
2257 int lowest_unlock = 1;
2258 u8 lowest_level = 0;
2259
2260 lowest_level = p->lowest_level;
2261 WARN_ON(p->nodes[0] != NULL);
2262 ASSERT(!p->nowait);
2263
2264 if (p->search_commit_root) {
2265 BUG_ON(time_seq);
2266 return btrfs_search_slot(NULL, root, key, p, 0, 0);
2267 }
2268
2269again:
2270 b = btrfs_get_old_root(root, time_seq);
2271 if (!b) {
2272 ret = -EIO;
2273 goto done;
2274 }
2275 level = btrfs_header_level(b);
2276 p->locks[level] = BTRFS_READ_LOCK;
2277
2278 while (b) {
2279 int dec = 0;
2280
2281 level = btrfs_header_level(b);
2282 p->nodes[level] = b;
2283
2284 /*
2285 * we have a lock on b and as long as we aren't changing
2286 * the tree, there is no way to for the items in b to change.
2287 * It is safe to drop the lock on our parent before we
2288 * go through the expensive btree search on b.
2289 */
2290 btrfs_unlock_up_safe(p, level + 1);
2291
2292 ret = btrfs_bin_search(b, 0, key, &slot);
2293 if (ret < 0)
2294 goto done;
2295
2296 if (level == 0) {
2297 p->slots[level] = slot;
2298 unlock_up(p, level, lowest_unlock, 0, NULL);
2299 goto done;
2300 }
2301
2302 if (ret && slot > 0) {
2303 dec = 1;
2304 slot--;
2305 }
2306 p->slots[level] = slot;
2307 unlock_up(p, level, lowest_unlock, 0, NULL);
2308
2309 if (level == lowest_level) {
2310 if (dec)
2311 p->slots[level]++;
2312 goto done;
2313 }
2314
2315 err = read_block_for_search(root, p, &b, level, slot, key);
2316 if (err == -EAGAIN)
2317 goto again;
2318 if (err) {
2319 ret = err;
2320 goto done;
2321 }
2322
2323 level = btrfs_header_level(b);
2324 btrfs_tree_read_lock(b);
2325 b = btrfs_tree_mod_log_rewind(fs_info, p, b, time_seq);
2326 if (!b) {
2327 ret = -ENOMEM;
2328 goto done;
2329 }
2330 p->locks[level] = BTRFS_READ_LOCK;
2331 p->nodes[level] = b;
2332 }
2333 ret = 1;
2334done:
2335 if (ret < 0)
2336 btrfs_release_path(p);
2337
2338 return ret;
2339}
2340
2341/*
2342 * Search the tree again to find a leaf with smaller keys.
2343 * Returns 0 if it found something.
2344 * Returns 1 if there are no smaller keys.
2345 * Returns < 0 on error.
2346 *
2347 * This may release the path, and so you may lose any locks held at the
2348 * time you call it.
2349 */
2350static int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path)
2351{
2352 struct btrfs_key key;
2353 struct btrfs_key orig_key;
2354 struct btrfs_disk_key found_key;
2355 int ret;
2356
2357 btrfs_item_key_to_cpu(path->nodes[0], &key, 0);
2358 orig_key = key;
2359
2360 if (key.offset > 0) {
2361 key.offset--;
2362 } else if (key.type > 0) {
2363 key.type--;
2364 key.offset = (u64)-1;
2365 } else if (key.objectid > 0) {
2366 key.objectid--;
2367 key.type = (u8)-1;
2368 key.offset = (u64)-1;
2369 } else {
2370 return 1;
2371 }
2372
2373 btrfs_release_path(path);
2374 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2375 if (ret <= 0)
2376 return ret;
2377
2378 /*
2379 * Previous key not found. Even if we were at slot 0 of the leaf we had
2380 * before releasing the path and calling btrfs_search_slot(), we now may
2381 * be in a slot pointing to the same original key - this can happen if
2382 * after we released the path, one of more items were moved from a
2383 * sibling leaf into the front of the leaf we had due to an insertion
2384 * (see push_leaf_right()).
2385 * If we hit this case and our slot is > 0 and just decrement the slot
2386 * so that the caller does not process the same key again, which may or
2387 * may not break the caller, depending on its logic.
2388 */
2389 if (path->slots[0] < btrfs_header_nritems(path->nodes[0])) {
2390 btrfs_item_key(path->nodes[0], &found_key, path->slots[0]);
2391 ret = btrfs_comp_keys(&found_key, &orig_key);
2392 if (ret == 0) {
2393 if (path->slots[0] > 0) {
2394 path->slots[0]--;
2395 return 0;
2396 }
2397 /*
2398 * At slot 0, same key as before, it means orig_key is
2399 * the lowest, leftmost, key in the tree. We're done.
2400 */
2401 return 1;
2402 }
2403 }
2404
2405 btrfs_item_key(path->nodes[0], &found_key, 0);
2406 ret = btrfs_comp_keys(&found_key, &key);
2407 /*
2408 * We might have had an item with the previous key in the tree right
2409 * before we released our path. And after we released our path, that
2410 * item might have been pushed to the first slot (0) of the leaf we
2411 * were holding due to a tree balance. Alternatively, an item with the
2412 * previous key can exist as the only element of a leaf (big fat item).
2413 * Therefore account for these 2 cases, so that our callers (like
2414 * btrfs_previous_item) don't miss an existing item with a key matching
2415 * the previous key we computed above.
2416 */
2417 if (ret <= 0)
2418 return 0;
2419 return 1;
2420}
2421
2422/*
2423 * helper to use instead of search slot if no exact match is needed but
2424 * instead the next or previous item should be returned.
2425 * When find_higher is true, the next higher item is returned, the next lower
2426 * otherwise.
2427 * When return_any and find_higher are both true, and no higher item is found,
2428 * return the next lower instead.
2429 * When return_any is true and find_higher is false, and no lower item is found,
2430 * return the next higher instead.
2431 * It returns 0 if any item is found, 1 if none is found (tree empty), and
2432 * < 0 on error
2433 */
2434int btrfs_search_slot_for_read(struct btrfs_root *root,
2435 const struct btrfs_key *key,
2436 struct btrfs_path *p, int find_higher,
2437 int return_any)
2438{
2439 int ret;
2440 struct extent_buffer *leaf;
2441
2442again:
2443 ret = btrfs_search_slot(NULL, root, key, p, 0, 0);
2444 if (ret <= 0)
2445 return ret;
2446 /*
2447 * a return value of 1 means the path is at the position where the
2448 * item should be inserted. Normally this is the next bigger item,
2449 * but in case the previous item is the last in a leaf, path points
2450 * to the first free slot in the previous leaf, i.e. at an invalid
2451 * item.
2452 */
2453 leaf = p->nodes[0];
2454
2455 if (find_higher) {
2456 if (p->slots[0] >= btrfs_header_nritems(leaf)) {
2457 ret = btrfs_next_leaf(root, p);
2458 if (ret <= 0)
2459 return ret;
2460 if (!return_any)
2461 return 1;
2462 /*
2463 * no higher item found, return the next
2464 * lower instead
2465 */
2466 return_any = 0;
2467 find_higher = 0;
2468 btrfs_release_path(p);
2469 goto again;
2470 }
2471 } else {
2472 if (p->slots[0] == 0) {
2473 ret = btrfs_prev_leaf(root, p);
2474 if (ret < 0)
2475 return ret;
2476 if (!ret) {
2477 leaf = p->nodes[0];
2478 if (p->slots[0] == btrfs_header_nritems(leaf))
2479 p->slots[0]--;
2480 return 0;
2481 }
2482 if (!return_any)
2483 return 1;
2484 /*
2485 * no lower item found, return the next
2486 * higher instead
2487 */
2488 return_any = 0;
2489 find_higher = 1;
2490 btrfs_release_path(p);
2491 goto again;
2492 } else {
2493 --p->slots[0];
2494 }
2495 }
2496 return 0;
2497}
2498
2499/*
2500 * Execute search and call btrfs_previous_item to traverse backwards if the item
2501 * was not found.
2502 *
2503 * Return 0 if found, 1 if not found and < 0 if error.
2504 */
2505int btrfs_search_backwards(struct btrfs_root *root, struct btrfs_key *key,
2506 struct btrfs_path *path)
2507{
2508 int ret;
2509
2510 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
2511 if (ret > 0)
2512 ret = btrfs_previous_item(root, path, key->objectid, key->type);
2513
2514 if (ret == 0)
2515 btrfs_item_key_to_cpu(path->nodes[0], key, path->slots[0]);
2516
2517 return ret;
2518}
2519
2520/*
2521 * Search for a valid slot for the given path.
2522 *
2523 * @root: The root node of the tree.
2524 * @key: Will contain a valid item if found.
2525 * @path: The starting point to validate the slot.
2526 *
2527 * Return: 0 if the item is valid
2528 * 1 if not found
2529 * <0 if error.
2530 */
2531int btrfs_get_next_valid_item(struct btrfs_root *root, struct btrfs_key *key,
2532 struct btrfs_path *path)
2533{
2534 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
2535 int ret;
2536
2537 ret = btrfs_next_leaf(root, path);
2538 if (ret)
2539 return ret;
2540 }
2541
2542 btrfs_item_key_to_cpu(path->nodes[0], key, path->slots[0]);
2543 return 0;
2544}
2545
2546/*
2547 * adjust the pointers going up the tree, starting at level
2548 * making sure the right key of each node is points to 'key'.
2549 * This is used after shifting pointers to the left, so it stops
2550 * fixing up pointers when a given leaf/node is not in slot 0 of the
2551 * higher levels
2552 *
2553 */
2554static void fixup_low_keys(struct btrfs_trans_handle *trans,
2555 struct btrfs_path *path,
2556 struct btrfs_disk_key *key, int level)
2557{
2558 int i;
2559 struct extent_buffer *t;
2560 int ret;
2561
2562 for (i = level; i < BTRFS_MAX_LEVEL; i++) {
2563 int tslot = path->slots[i];
2564
2565 if (!path->nodes[i])
2566 break;
2567 t = path->nodes[i];
2568 ret = btrfs_tree_mod_log_insert_key(t, tslot,
2569 BTRFS_MOD_LOG_KEY_REPLACE);
2570 BUG_ON(ret < 0);
2571 btrfs_set_node_key(t, key, tslot);
2572 btrfs_mark_buffer_dirty(trans, path->nodes[i]);
2573 if (tslot != 0)
2574 break;
2575 }
2576}
2577
2578/*
2579 * update item key.
2580 *
2581 * This function isn't completely safe. It's the caller's responsibility
2582 * that the new key won't break the order
2583 */
2584void btrfs_set_item_key_safe(struct btrfs_trans_handle *trans,
2585 struct btrfs_path *path,
2586 const struct btrfs_key *new_key)
2587{
2588 struct btrfs_fs_info *fs_info = trans->fs_info;
2589 struct btrfs_disk_key disk_key;
2590 struct extent_buffer *eb;
2591 int slot;
2592
2593 eb = path->nodes[0];
2594 slot = path->slots[0];
2595 if (slot > 0) {
2596 btrfs_item_key(eb, &disk_key, slot - 1);
2597 if (unlikely(btrfs_comp_keys(&disk_key, new_key) >= 0)) {
2598 btrfs_print_leaf(eb);
2599 btrfs_crit(fs_info,
2600 "slot %u key (%llu %u %llu) new key (%llu %u %llu)",
2601 slot, btrfs_disk_key_objectid(&disk_key),
2602 btrfs_disk_key_type(&disk_key),
2603 btrfs_disk_key_offset(&disk_key),
2604 new_key->objectid, new_key->type,
2605 new_key->offset);
2606 BUG();
2607 }
2608 }
2609 if (slot < btrfs_header_nritems(eb) - 1) {
2610 btrfs_item_key(eb, &disk_key, slot + 1);
2611 if (unlikely(btrfs_comp_keys(&disk_key, new_key) <= 0)) {
2612 btrfs_print_leaf(eb);
2613 btrfs_crit(fs_info,
2614 "slot %u key (%llu %u %llu) new key (%llu %u %llu)",
2615 slot, btrfs_disk_key_objectid(&disk_key),
2616 btrfs_disk_key_type(&disk_key),
2617 btrfs_disk_key_offset(&disk_key),
2618 new_key->objectid, new_key->type,
2619 new_key->offset);
2620 BUG();
2621 }
2622 }
2623
2624 btrfs_cpu_key_to_disk(&disk_key, new_key);
2625 btrfs_set_item_key(eb, &disk_key, slot);
2626 btrfs_mark_buffer_dirty(trans, eb);
2627 if (slot == 0)
2628 fixup_low_keys(trans, path, &disk_key, 1);
2629}
2630
2631/*
2632 * Check key order of two sibling extent buffers.
2633 *
2634 * Return true if something is wrong.
2635 * Return false if everything is fine.
2636 *
2637 * Tree-checker only works inside one tree block, thus the following
2638 * corruption can not be detected by tree-checker:
2639 *
2640 * Leaf @left | Leaf @right
2641 * --------------------------------------------------------------
2642 * | 1 | 2 | 3 | 4 | 5 | f6 | | 7 | 8 |
2643 *
2644 * Key f6 in leaf @left itself is valid, but not valid when the next
2645 * key in leaf @right is 7.
2646 * This can only be checked at tree block merge time.
2647 * And since tree checker has ensured all key order in each tree block
2648 * is correct, we only need to bother the last key of @left and the first
2649 * key of @right.
2650 */
2651static bool check_sibling_keys(struct extent_buffer *left,
2652 struct extent_buffer *right)
2653{
2654 struct btrfs_key left_last;
2655 struct btrfs_key right_first;
2656 int level = btrfs_header_level(left);
2657 int nr_left = btrfs_header_nritems(left);
2658 int nr_right = btrfs_header_nritems(right);
2659
2660 /* No key to check in one of the tree blocks */
2661 if (!nr_left || !nr_right)
2662 return false;
2663
2664 if (level) {
2665 btrfs_node_key_to_cpu(left, &left_last, nr_left - 1);
2666 btrfs_node_key_to_cpu(right, &right_first, 0);
2667 } else {
2668 btrfs_item_key_to_cpu(left, &left_last, nr_left - 1);
2669 btrfs_item_key_to_cpu(right, &right_first, 0);
2670 }
2671
2672 if (unlikely(btrfs_comp_cpu_keys(&left_last, &right_first) >= 0)) {
2673 btrfs_crit(left->fs_info, "left extent buffer:");
2674 btrfs_print_tree(left, false);
2675 btrfs_crit(left->fs_info, "right extent buffer:");
2676 btrfs_print_tree(right, false);
2677 btrfs_crit(left->fs_info,
2678"bad key order, sibling blocks, left last (%llu %u %llu) right first (%llu %u %llu)",
2679 left_last.objectid, left_last.type,
2680 left_last.offset, right_first.objectid,
2681 right_first.type, right_first.offset);
2682 return true;
2683 }
2684 return false;
2685}
2686
2687/*
2688 * try to push data from one node into the next node left in the
2689 * tree.
2690 *
2691 * returns 0 if some ptrs were pushed left, < 0 if there was some horrible
2692 * error, and > 0 if there was no room in the left hand block.
2693 */
2694static int push_node_left(struct btrfs_trans_handle *trans,
2695 struct extent_buffer *dst,
2696 struct extent_buffer *src, int empty)
2697{
2698 struct btrfs_fs_info *fs_info = trans->fs_info;
2699 int push_items = 0;
2700 int src_nritems;
2701 int dst_nritems;
2702 int ret = 0;
2703
2704 src_nritems = btrfs_header_nritems(src);
2705 dst_nritems = btrfs_header_nritems(dst);
2706 push_items = BTRFS_NODEPTRS_PER_BLOCK(fs_info) - dst_nritems;
2707 WARN_ON(btrfs_header_generation(src) != trans->transid);
2708 WARN_ON(btrfs_header_generation(dst) != trans->transid);
2709
2710 if (!empty && src_nritems <= 8)
2711 return 1;
2712
2713 if (push_items <= 0)
2714 return 1;
2715
2716 if (empty) {
2717 push_items = min(src_nritems, push_items);
2718 if (push_items < src_nritems) {
2719 /* leave at least 8 pointers in the node if
2720 * we aren't going to empty it
2721 */
2722 if (src_nritems - push_items < 8) {
2723 if (push_items <= 8)
2724 return 1;
2725 push_items -= 8;
2726 }
2727 }
2728 } else
2729 push_items = min(src_nritems - 8, push_items);
2730
2731 /* dst is the left eb, src is the middle eb */
2732 if (check_sibling_keys(dst, src)) {
2733 ret = -EUCLEAN;
2734 btrfs_abort_transaction(trans, ret);
2735 return ret;
2736 }
2737 ret = btrfs_tree_mod_log_eb_copy(dst, src, dst_nritems, 0, push_items);
2738 if (ret) {
2739 btrfs_abort_transaction(trans, ret);
2740 return ret;
2741 }
2742 copy_extent_buffer(dst, src,
2743 btrfs_node_key_ptr_offset(dst, dst_nritems),
2744 btrfs_node_key_ptr_offset(src, 0),
2745 push_items * sizeof(struct btrfs_key_ptr));
2746
2747 if (push_items < src_nritems) {
2748 /*
2749 * btrfs_tree_mod_log_eb_copy handles logging the move, so we
2750 * don't need to do an explicit tree mod log operation for it.
2751 */
2752 memmove_extent_buffer(src, btrfs_node_key_ptr_offset(src, 0),
2753 btrfs_node_key_ptr_offset(src, push_items),
2754 (src_nritems - push_items) *
2755 sizeof(struct btrfs_key_ptr));
2756 }
2757 btrfs_set_header_nritems(src, src_nritems - push_items);
2758 btrfs_set_header_nritems(dst, dst_nritems + push_items);
2759 btrfs_mark_buffer_dirty(trans, src);
2760 btrfs_mark_buffer_dirty(trans, dst);
2761
2762 return ret;
2763}
2764
2765/*
2766 * try to push data from one node into the next node right in the
2767 * tree.
2768 *
2769 * returns 0 if some ptrs were pushed, < 0 if there was some horrible
2770 * error, and > 0 if there was no room in the right hand block.
2771 *
2772 * this will only push up to 1/2 the contents of the left node over
2773 */
2774static int balance_node_right(struct btrfs_trans_handle *trans,
2775 struct extent_buffer *dst,
2776 struct extent_buffer *src)
2777{
2778 struct btrfs_fs_info *fs_info = trans->fs_info;
2779 int push_items = 0;
2780 int max_push;
2781 int src_nritems;
2782 int dst_nritems;
2783 int ret = 0;
2784
2785 WARN_ON(btrfs_header_generation(src) != trans->transid);
2786 WARN_ON(btrfs_header_generation(dst) != trans->transid);
2787
2788 src_nritems = btrfs_header_nritems(src);
2789 dst_nritems = btrfs_header_nritems(dst);
2790 push_items = BTRFS_NODEPTRS_PER_BLOCK(fs_info) - dst_nritems;
2791 if (push_items <= 0)
2792 return 1;
2793
2794 if (src_nritems < 4)
2795 return 1;
2796
2797 max_push = src_nritems / 2 + 1;
2798 /* don't try to empty the node */
2799 if (max_push >= src_nritems)
2800 return 1;
2801
2802 if (max_push < push_items)
2803 push_items = max_push;
2804
2805 /* dst is the right eb, src is the middle eb */
2806 if (check_sibling_keys(src, dst)) {
2807 ret = -EUCLEAN;
2808 btrfs_abort_transaction(trans, ret);
2809 return ret;
2810 }
2811
2812 /*
2813 * btrfs_tree_mod_log_eb_copy handles logging the move, so we don't
2814 * need to do an explicit tree mod log operation for it.
2815 */
2816 memmove_extent_buffer(dst, btrfs_node_key_ptr_offset(dst, push_items),
2817 btrfs_node_key_ptr_offset(dst, 0),
2818 (dst_nritems) *
2819 sizeof(struct btrfs_key_ptr));
2820
2821 ret = btrfs_tree_mod_log_eb_copy(dst, src, 0, src_nritems - push_items,
2822 push_items);
2823 if (ret) {
2824 btrfs_abort_transaction(trans, ret);
2825 return ret;
2826 }
2827 copy_extent_buffer(dst, src,
2828 btrfs_node_key_ptr_offset(dst, 0),
2829 btrfs_node_key_ptr_offset(src, src_nritems - push_items),
2830 push_items * sizeof(struct btrfs_key_ptr));
2831
2832 btrfs_set_header_nritems(src, src_nritems - push_items);
2833 btrfs_set_header_nritems(dst, dst_nritems + push_items);
2834
2835 btrfs_mark_buffer_dirty(trans, src);
2836 btrfs_mark_buffer_dirty(trans, dst);
2837
2838 return ret;
2839}
2840
2841/*
2842 * helper function to insert a new root level in the tree.
2843 * A new node is allocated, and a single item is inserted to
2844 * point to the existing root
2845 *
2846 * returns zero on success or < 0 on failure.
2847 */
2848static noinline int insert_new_root(struct btrfs_trans_handle *trans,
2849 struct btrfs_root *root,
2850 struct btrfs_path *path, int level)
2851{
2852 u64 lower_gen;
2853 struct extent_buffer *lower;
2854 struct extent_buffer *c;
2855 struct extent_buffer *old;
2856 struct btrfs_disk_key lower_key;
2857 int ret;
2858
2859 BUG_ON(path->nodes[level]);
2860 BUG_ON(path->nodes[level-1] != root->node);
2861
2862 lower = path->nodes[level-1];
2863 if (level == 1)
2864 btrfs_item_key(lower, &lower_key, 0);
2865 else
2866 btrfs_node_key(lower, &lower_key, 0);
2867
2868 c = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid,
2869 &lower_key, level, root->node->start, 0,
2870 0, BTRFS_NESTING_NEW_ROOT);
2871 if (IS_ERR(c))
2872 return PTR_ERR(c);
2873
2874 root_add_used_bytes(root);
2875
2876 btrfs_set_header_nritems(c, 1);
2877 btrfs_set_node_key(c, &lower_key, 0);
2878 btrfs_set_node_blockptr(c, 0, lower->start);
2879 lower_gen = btrfs_header_generation(lower);
2880 WARN_ON(lower_gen != trans->transid);
2881
2882 btrfs_set_node_ptr_generation(c, 0, lower_gen);
2883
2884 btrfs_mark_buffer_dirty(trans, c);
2885
2886 old = root->node;
2887 ret = btrfs_tree_mod_log_insert_root(root->node, c, false);
2888 if (ret < 0) {
2889 btrfs_free_tree_block(trans, btrfs_root_id(root), c, 0, 1);
2890 btrfs_tree_unlock(c);
2891 free_extent_buffer(c);
2892 return ret;
2893 }
2894 rcu_assign_pointer(root->node, c);
2895
2896 /* the super has an extra ref to root->node */
2897 free_extent_buffer(old);
2898
2899 add_root_to_dirty_list(root);
2900 atomic_inc(&c->refs);
2901 path->nodes[level] = c;
2902 path->locks[level] = BTRFS_WRITE_LOCK;
2903 path->slots[level] = 0;
2904 return 0;
2905}
2906
2907/*
2908 * worker function to insert a single pointer in a node.
2909 * the node should have enough room for the pointer already
2910 *
2911 * slot and level indicate where you want the key to go, and
2912 * blocknr is the block the key points to.
2913 */
2914static int insert_ptr(struct btrfs_trans_handle *trans,
2915 struct btrfs_path *path,
2916 struct btrfs_disk_key *key, u64 bytenr,
2917 int slot, int level)
2918{
2919 struct extent_buffer *lower;
2920 int nritems;
2921 int ret;
2922
2923 BUG_ON(!path->nodes[level]);
2924 btrfs_assert_tree_write_locked(path->nodes[level]);
2925 lower = path->nodes[level];
2926 nritems = btrfs_header_nritems(lower);
2927 BUG_ON(slot > nritems);
2928 BUG_ON(nritems == BTRFS_NODEPTRS_PER_BLOCK(trans->fs_info));
2929 if (slot != nritems) {
2930 if (level) {
2931 ret = btrfs_tree_mod_log_insert_move(lower, slot + 1,
2932 slot, nritems - slot);
2933 if (ret < 0) {
2934 btrfs_abort_transaction(trans, ret);
2935 return ret;
2936 }
2937 }
2938 memmove_extent_buffer(lower,
2939 btrfs_node_key_ptr_offset(lower, slot + 1),
2940 btrfs_node_key_ptr_offset(lower, slot),
2941 (nritems - slot) * sizeof(struct btrfs_key_ptr));
2942 }
2943 if (level) {
2944 ret = btrfs_tree_mod_log_insert_key(lower, slot,
2945 BTRFS_MOD_LOG_KEY_ADD);
2946 if (ret < 0) {
2947 btrfs_abort_transaction(trans, ret);
2948 return ret;
2949 }
2950 }
2951 btrfs_set_node_key(lower, key, slot);
2952 btrfs_set_node_blockptr(lower, slot, bytenr);
2953 WARN_ON(trans->transid == 0);
2954 btrfs_set_node_ptr_generation(lower, slot, trans->transid);
2955 btrfs_set_header_nritems(lower, nritems + 1);
2956 btrfs_mark_buffer_dirty(trans, lower);
2957
2958 return 0;
2959}
2960
2961/*
2962 * split the node at the specified level in path in two.
2963 * The path is corrected to point to the appropriate node after the split
2964 *
2965 * Before splitting this tries to make some room in the node by pushing
2966 * left and right, if either one works, it returns right away.
2967 *
2968 * returns 0 on success and < 0 on failure
2969 */
2970static noinline int split_node(struct btrfs_trans_handle *trans,
2971 struct btrfs_root *root,
2972 struct btrfs_path *path, int level)
2973{
2974 struct btrfs_fs_info *fs_info = root->fs_info;
2975 struct extent_buffer *c;
2976 struct extent_buffer *split;
2977 struct btrfs_disk_key disk_key;
2978 int mid;
2979 int ret;
2980 u32 c_nritems;
2981
2982 c = path->nodes[level];
2983 WARN_ON(btrfs_header_generation(c) != trans->transid);
2984 if (c == root->node) {
2985 /*
2986 * trying to split the root, lets make a new one
2987 *
2988 * tree mod log: We don't log_removal old root in
2989 * insert_new_root, because that root buffer will be kept as a
2990 * normal node. We are going to log removal of half of the
2991 * elements below with btrfs_tree_mod_log_eb_copy(). We're
2992 * holding a tree lock on the buffer, which is why we cannot
2993 * race with other tree_mod_log users.
2994 */
2995 ret = insert_new_root(trans, root, path, level + 1);
2996 if (ret)
2997 return ret;
2998 } else {
2999 ret = push_nodes_for_insert(trans, root, path, level);
3000 c = path->nodes[level];
3001 if (!ret && btrfs_header_nritems(c) <
3002 BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 3)
3003 return 0;
3004 if (ret < 0)
3005 return ret;
3006 }
3007
3008 c_nritems = btrfs_header_nritems(c);
3009 mid = (c_nritems + 1) / 2;
3010 btrfs_node_key(c, &disk_key, mid);
3011
3012 split = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid,
3013 &disk_key, level, c->start, 0,
3014 0, BTRFS_NESTING_SPLIT);
3015 if (IS_ERR(split))
3016 return PTR_ERR(split);
3017
3018 root_add_used_bytes(root);
3019 ASSERT(btrfs_header_level(c) == level);
3020
3021 ret = btrfs_tree_mod_log_eb_copy(split, c, 0, mid, c_nritems - mid);
3022 if (ret) {
3023 btrfs_tree_unlock(split);
3024 free_extent_buffer(split);
3025 btrfs_abort_transaction(trans, ret);
3026 return ret;
3027 }
3028 copy_extent_buffer(split, c,
3029 btrfs_node_key_ptr_offset(split, 0),
3030 btrfs_node_key_ptr_offset(c, mid),
3031 (c_nritems - mid) * sizeof(struct btrfs_key_ptr));
3032 btrfs_set_header_nritems(split, c_nritems - mid);
3033 btrfs_set_header_nritems(c, mid);
3034
3035 btrfs_mark_buffer_dirty(trans, c);
3036 btrfs_mark_buffer_dirty(trans, split);
3037
3038 ret = insert_ptr(trans, path, &disk_key, split->start,
3039 path->slots[level + 1] + 1, level + 1);
3040 if (ret < 0) {
3041 btrfs_tree_unlock(split);
3042 free_extent_buffer(split);
3043 return ret;
3044 }
3045
3046 if (path->slots[level] >= mid) {
3047 path->slots[level] -= mid;
3048 btrfs_tree_unlock(c);
3049 free_extent_buffer(c);
3050 path->nodes[level] = split;
3051 path->slots[level + 1] += 1;
3052 } else {
3053 btrfs_tree_unlock(split);
3054 free_extent_buffer(split);
3055 }
3056 return 0;
3057}
3058
3059/*
3060 * how many bytes are required to store the items in a leaf. start
3061 * and nr indicate which items in the leaf to check. This totals up the
3062 * space used both by the item structs and the item data
3063 */
3064static int leaf_space_used(const struct extent_buffer *l, int start, int nr)
3065{
3066 int data_len;
3067 int nritems = btrfs_header_nritems(l);
3068 int end = min(nritems, start + nr) - 1;
3069
3070 if (!nr)
3071 return 0;
3072 data_len = btrfs_item_offset(l, start) + btrfs_item_size(l, start);
3073 data_len = data_len - btrfs_item_offset(l, end);
3074 data_len += sizeof(struct btrfs_item) * nr;
3075 WARN_ON(data_len < 0);
3076 return data_len;
3077}
3078
3079/*
3080 * The space between the end of the leaf items and
3081 * the start of the leaf data. IOW, how much room
3082 * the leaf has left for both items and data
3083 */
3084int btrfs_leaf_free_space(const struct extent_buffer *leaf)
3085{
3086 struct btrfs_fs_info *fs_info = leaf->fs_info;
3087 int nritems = btrfs_header_nritems(leaf);
3088 int ret;
3089
3090 ret = BTRFS_LEAF_DATA_SIZE(fs_info) - leaf_space_used(leaf, 0, nritems);
3091 if (ret < 0) {
3092 btrfs_crit(fs_info,
3093 "leaf free space ret %d, leaf data size %lu, used %d nritems %d",
3094 ret,
3095 (unsigned long) BTRFS_LEAF_DATA_SIZE(fs_info),
3096 leaf_space_used(leaf, 0, nritems), nritems);
3097 }
3098 return ret;
3099}
3100
3101/*
3102 * min slot controls the lowest index we're willing to push to the
3103 * right. We'll push up to and including min_slot, but no lower
3104 */
3105static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
3106 struct btrfs_path *path,
3107 int data_size, int empty,
3108 struct extent_buffer *right,
3109 int free_space, u32 left_nritems,
3110 u32 min_slot)
3111{
3112 struct btrfs_fs_info *fs_info = right->fs_info;
3113 struct extent_buffer *left = path->nodes[0];
3114 struct extent_buffer *upper = path->nodes[1];
3115 struct btrfs_map_token token;
3116 struct btrfs_disk_key disk_key;
3117 int slot;
3118 u32 i;
3119 int push_space = 0;
3120 int push_items = 0;
3121 u32 nr;
3122 u32 right_nritems;
3123 u32 data_end;
3124 u32 this_item_size;
3125
3126 if (empty)
3127 nr = 0;
3128 else
3129 nr = max_t(u32, 1, min_slot);
3130
3131 if (path->slots[0] >= left_nritems)
3132 push_space += data_size;
3133
3134 slot = path->slots[1];
3135 i = left_nritems - 1;
3136 while (i >= nr) {
3137 if (!empty && push_items > 0) {
3138 if (path->slots[0] > i)
3139 break;
3140 if (path->slots[0] == i) {
3141 int space = btrfs_leaf_free_space(left);
3142
3143 if (space + push_space * 2 > free_space)
3144 break;
3145 }
3146 }
3147
3148 if (path->slots[0] == i)
3149 push_space += data_size;
3150
3151 this_item_size = btrfs_item_size(left, i);
3152 if (this_item_size + sizeof(struct btrfs_item) +
3153 push_space > free_space)
3154 break;
3155
3156 push_items++;
3157 push_space += this_item_size + sizeof(struct btrfs_item);
3158 if (i == 0)
3159 break;
3160 i--;
3161 }
3162
3163 if (push_items == 0)
3164 goto out_unlock;
3165
3166 WARN_ON(!empty && push_items == left_nritems);
3167
3168 /* push left to right */
3169 right_nritems = btrfs_header_nritems(right);
3170
3171 push_space = btrfs_item_data_end(left, left_nritems - push_items);
3172 push_space -= leaf_data_end(left);
3173
3174 /* make room in the right data area */
3175 data_end = leaf_data_end(right);
3176 memmove_leaf_data(right, data_end - push_space, data_end,
3177 BTRFS_LEAF_DATA_SIZE(fs_info) - data_end);
3178
3179 /* copy from the left data area */
3180 copy_leaf_data(right, left, BTRFS_LEAF_DATA_SIZE(fs_info) - push_space,
3181 leaf_data_end(left), push_space);
3182
3183 memmove_leaf_items(right, push_items, 0, right_nritems);
3184
3185 /* copy the items from left to right */
3186 copy_leaf_items(right, left, 0, left_nritems - push_items, push_items);
3187
3188 /* update the item pointers */
3189 btrfs_init_map_token(&token, right);
3190 right_nritems += push_items;
3191 btrfs_set_header_nritems(right, right_nritems);
3192 push_space = BTRFS_LEAF_DATA_SIZE(fs_info);
3193 for (i = 0; i < right_nritems; i++) {
3194 push_space -= btrfs_token_item_size(&token, i);
3195 btrfs_set_token_item_offset(&token, i, push_space);
3196 }
3197
3198 left_nritems -= push_items;
3199 btrfs_set_header_nritems(left, left_nritems);
3200
3201 if (left_nritems)
3202 btrfs_mark_buffer_dirty(trans, left);
3203 else
3204 btrfs_clear_buffer_dirty(trans, left);
3205
3206 btrfs_mark_buffer_dirty(trans, right);
3207
3208 btrfs_item_key(right, &disk_key, 0);
3209 btrfs_set_node_key(upper, &disk_key, slot + 1);
3210 btrfs_mark_buffer_dirty(trans, upper);
3211
3212 /* then fixup the leaf pointer in the path */
3213 if (path->slots[0] >= left_nritems) {
3214 path->slots[0] -= left_nritems;
3215 if (btrfs_header_nritems(path->nodes[0]) == 0)
3216 btrfs_clear_buffer_dirty(trans, path->nodes[0]);
3217 btrfs_tree_unlock(path->nodes[0]);
3218 free_extent_buffer(path->nodes[0]);
3219 path->nodes[0] = right;
3220 path->slots[1] += 1;
3221 } else {
3222 btrfs_tree_unlock(right);
3223 free_extent_buffer(right);
3224 }
3225 return 0;
3226
3227out_unlock:
3228 btrfs_tree_unlock(right);
3229 free_extent_buffer(right);
3230 return 1;
3231}
3232
3233/*
3234 * push some data in the path leaf to the right, trying to free up at
3235 * least data_size bytes. returns zero if the push worked, nonzero otherwise
3236 *
3237 * returns 1 if the push failed because the other node didn't have enough
3238 * room, 0 if everything worked out and < 0 if there were major errors.
3239 *
3240 * this will push starting from min_slot to the end of the leaf. It won't
3241 * push any slot lower than min_slot
3242 */
3243static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
3244 *root, struct btrfs_path *path,
3245 int min_data_size, int data_size,
3246 int empty, u32 min_slot)
3247{
3248 struct extent_buffer *left = path->nodes[0];
3249 struct extent_buffer *right;
3250 struct extent_buffer *upper;
3251 int slot;
3252 int free_space;
3253 u32 left_nritems;
3254 int ret;
3255
3256 if (!path->nodes[1])
3257 return 1;
3258
3259 slot = path->slots[1];
3260 upper = path->nodes[1];
3261 if (slot >= btrfs_header_nritems(upper) - 1)
3262 return 1;
3263
3264 btrfs_assert_tree_write_locked(path->nodes[1]);
3265
3266 right = btrfs_read_node_slot(upper, slot + 1);
3267 if (IS_ERR(right))
3268 return PTR_ERR(right);
3269
3270 __btrfs_tree_lock(right, BTRFS_NESTING_RIGHT);
3271
3272 free_space = btrfs_leaf_free_space(right);
3273 if (free_space < data_size)
3274 goto out_unlock;
3275
3276 ret = btrfs_cow_block(trans, root, right, upper,
3277 slot + 1, &right, BTRFS_NESTING_RIGHT_COW);
3278 if (ret)
3279 goto out_unlock;
3280
3281 left_nritems = btrfs_header_nritems(left);
3282 if (left_nritems == 0)
3283 goto out_unlock;
3284
3285 if (check_sibling_keys(left, right)) {
3286 ret = -EUCLEAN;
3287 btrfs_abort_transaction(trans, ret);
3288 btrfs_tree_unlock(right);
3289 free_extent_buffer(right);
3290 return ret;
3291 }
3292 if (path->slots[0] == left_nritems && !empty) {
3293 /* Key greater than all keys in the leaf, right neighbor has
3294 * enough room for it and we're not emptying our leaf to delete
3295 * it, therefore use right neighbor to insert the new item and
3296 * no need to touch/dirty our left leaf. */
3297 btrfs_tree_unlock(left);
3298 free_extent_buffer(left);
3299 path->nodes[0] = right;
3300 path->slots[0] = 0;
3301 path->slots[1]++;
3302 return 0;
3303 }
3304
3305 return __push_leaf_right(trans, path, min_data_size, empty, right,
3306 free_space, left_nritems, min_slot);
3307out_unlock:
3308 btrfs_tree_unlock(right);
3309 free_extent_buffer(right);
3310 return 1;
3311}
3312
3313/*
3314 * push some data in the path leaf to the left, trying to free up at
3315 * least data_size bytes. returns zero if the push worked, nonzero otherwise
3316 *
3317 * max_slot can put a limit on how far into the leaf we'll push items. The
3318 * item at 'max_slot' won't be touched. Use (u32)-1 to make us do all the
3319 * items
3320 */
3321static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
3322 struct btrfs_path *path, int data_size,
3323 int empty, struct extent_buffer *left,
3324 int free_space, u32 right_nritems,
3325 u32 max_slot)
3326{
3327 struct btrfs_fs_info *fs_info = left->fs_info;
3328 struct btrfs_disk_key disk_key;
3329 struct extent_buffer *right = path->nodes[0];
3330 int i;
3331 int push_space = 0;
3332 int push_items = 0;
3333 u32 old_left_nritems;
3334 u32 nr;
3335 int ret = 0;
3336 u32 this_item_size;
3337 u32 old_left_item_size;
3338 struct btrfs_map_token token;
3339
3340 if (empty)
3341 nr = min(right_nritems, max_slot);
3342 else
3343 nr = min(right_nritems - 1, max_slot);
3344
3345 for (i = 0; i < nr; i++) {
3346 if (!empty && push_items > 0) {
3347 if (path->slots[0] < i)
3348 break;
3349 if (path->slots[0] == i) {
3350 int space = btrfs_leaf_free_space(right);
3351
3352 if (space + push_space * 2 > free_space)
3353 break;
3354 }
3355 }
3356
3357 if (path->slots[0] == i)
3358 push_space += data_size;
3359
3360 this_item_size = btrfs_item_size(right, i);
3361 if (this_item_size + sizeof(struct btrfs_item) + push_space >
3362 free_space)
3363 break;
3364
3365 push_items++;
3366 push_space += this_item_size + sizeof(struct btrfs_item);
3367 }
3368
3369 if (push_items == 0) {
3370 ret = 1;
3371 goto out;
3372 }
3373 WARN_ON(!empty && push_items == btrfs_header_nritems(right));
3374
3375 /* push data from right to left */
3376 copy_leaf_items(left, right, btrfs_header_nritems(left), 0, push_items);
3377
3378 push_space = BTRFS_LEAF_DATA_SIZE(fs_info) -
3379 btrfs_item_offset(right, push_items - 1);
3380
3381 copy_leaf_data(left, right, leaf_data_end(left) - push_space,
3382 btrfs_item_offset(right, push_items - 1), push_space);
3383 old_left_nritems = btrfs_header_nritems(left);
3384 BUG_ON(old_left_nritems <= 0);
3385
3386 btrfs_init_map_token(&token, left);
3387 old_left_item_size = btrfs_item_offset(left, old_left_nritems - 1);
3388 for (i = old_left_nritems; i < old_left_nritems + push_items; i++) {
3389 u32 ioff;
3390
3391 ioff = btrfs_token_item_offset(&token, i);
3392 btrfs_set_token_item_offset(&token, i,
3393 ioff - (BTRFS_LEAF_DATA_SIZE(fs_info) - old_left_item_size));
3394 }
3395 btrfs_set_header_nritems(left, old_left_nritems + push_items);
3396
3397 /* fixup right node */
3398 if (push_items > right_nritems)
3399 WARN(1, KERN_CRIT "push items %d nr %u\n", push_items,
3400 right_nritems);
3401
3402 if (push_items < right_nritems) {
3403 push_space = btrfs_item_offset(right, push_items - 1) -
3404 leaf_data_end(right);
3405 memmove_leaf_data(right,
3406 BTRFS_LEAF_DATA_SIZE(fs_info) - push_space,
3407 leaf_data_end(right), push_space);
3408
3409 memmove_leaf_items(right, 0, push_items,
3410 btrfs_header_nritems(right) - push_items);
3411 }
3412
3413 btrfs_init_map_token(&token, right);
3414 right_nritems -= push_items;
3415 btrfs_set_header_nritems(right, right_nritems);
3416 push_space = BTRFS_LEAF_DATA_SIZE(fs_info);
3417 for (i = 0; i < right_nritems; i++) {
3418 push_space = push_space - btrfs_token_item_size(&token, i);
3419 btrfs_set_token_item_offset(&token, i, push_space);
3420 }
3421
3422 btrfs_mark_buffer_dirty(trans, left);
3423 if (right_nritems)
3424 btrfs_mark_buffer_dirty(trans, right);
3425 else
3426 btrfs_clear_buffer_dirty(trans, right);
3427
3428 btrfs_item_key(right, &disk_key, 0);
3429 fixup_low_keys(trans, path, &disk_key, 1);
3430
3431 /* then fixup the leaf pointer in the path */
3432 if (path->slots[0] < push_items) {
3433 path->slots[0] += old_left_nritems;
3434 btrfs_tree_unlock(path->nodes[0]);
3435 free_extent_buffer(path->nodes[0]);
3436 path->nodes[0] = left;
3437 path->slots[1] -= 1;
3438 } else {
3439 btrfs_tree_unlock(left);
3440 free_extent_buffer(left);
3441 path->slots[0] -= push_items;
3442 }
3443 BUG_ON(path->slots[0] < 0);
3444 return ret;
3445out:
3446 btrfs_tree_unlock(left);
3447 free_extent_buffer(left);
3448 return ret;
3449}
3450
3451/*
3452 * push some data in the path leaf to the left, trying to free up at
3453 * least data_size bytes. returns zero if the push worked, nonzero otherwise
3454 *
3455 * max_slot can put a limit on how far into the leaf we'll push items. The
3456 * item at 'max_slot' won't be touched. Use (u32)-1 to make us push all the
3457 * items
3458 */
3459static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
3460 *root, struct btrfs_path *path, int min_data_size,
3461 int data_size, int empty, u32 max_slot)
3462{
3463 struct extent_buffer *right = path->nodes[0];
3464 struct extent_buffer *left;
3465 int slot;
3466 int free_space;
3467 u32 right_nritems;
3468 int ret = 0;
3469
3470 slot = path->slots[1];
3471 if (slot == 0)
3472 return 1;
3473 if (!path->nodes[1])
3474 return 1;
3475
3476 right_nritems = btrfs_header_nritems(right);
3477 if (right_nritems == 0)
3478 return 1;
3479
3480 btrfs_assert_tree_write_locked(path->nodes[1]);
3481
3482 left = btrfs_read_node_slot(path->nodes[1], slot - 1);
3483 if (IS_ERR(left))
3484 return PTR_ERR(left);
3485
3486 __btrfs_tree_lock(left, BTRFS_NESTING_LEFT);
3487
3488 free_space = btrfs_leaf_free_space(left);
3489 if (free_space < data_size) {
3490 ret = 1;
3491 goto out;
3492 }
3493
3494 ret = btrfs_cow_block(trans, root, left,
3495 path->nodes[1], slot - 1, &left,
3496 BTRFS_NESTING_LEFT_COW);
3497 if (ret) {
3498 /* we hit -ENOSPC, but it isn't fatal here */
3499 if (ret == -ENOSPC)
3500 ret = 1;
3501 goto out;
3502 }
3503
3504 if (check_sibling_keys(left, right)) {
3505 ret = -EUCLEAN;
3506 btrfs_abort_transaction(trans, ret);
3507 goto out;
3508 }
3509 return __push_leaf_left(trans, path, min_data_size, empty, left,
3510 free_space, right_nritems, max_slot);
3511out:
3512 btrfs_tree_unlock(left);
3513 free_extent_buffer(left);
3514 return ret;
3515}
3516
3517/*
3518 * split the path's leaf in two, making sure there is at least data_size
3519 * available for the resulting leaf level of the path.
3520 */
3521static noinline int copy_for_split(struct btrfs_trans_handle *trans,
3522 struct btrfs_path *path,
3523 struct extent_buffer *l,
3524 struct extent_buffer *right,
3525 int slot, int mid, int nritems)
3526{
3527 struct btrfs_fs_info *fs_info = trans->fs_info;
3528 int data_copy_size;
3529 int rt_data_off;
3530 int i;
3531 int ret;
3532 struct btrfs_disk_key disk_key;
3533 struct btrfs_map_token token;
3534
3535 nritems = nritems - mid;
3536 btrfs_set_header_nritems(right, nritems);
3537 data_copy_size = btrfs_item_data_end(l, mid) - leaf_data_end(l);
3538
3539 copy_leaf_items(right, l, 0, mid, nritems);
3540
3541 copy_leaf_data(right, l, BTRFS_LEAF_DATA_SIZE(fs_info) - data_copy_size,
3542 leaf_data_end(l), data_copy_size);
3543
3544 rt_data_off = BTRFS_LEAF_DATA_SIZE(fs_info) - btrfs_item_data_end(l, mid);
3545
3546 btrfs_init_map_token(&token, right);
3547 for (i = 0; i < nritems; i++) {
3548 u32 ioff;
3549
3550 ioff = btrfs_token_item_offset(&token, i);
3551 btrfs_set_token_item_offset(&token, i, ioff + rt_data_off);
3552 }
3553
3554 btrfs_set_header_nritems(l, mid);
3555 btrfs_item_key(right, &disk_key, 0);
3556 ret = insert_ptr(trans, path, &disk_key, right->start, path->slots[1] + 1, 1);
3557 if (ret < 0)
3558 return ret;
3559
3560 btrfs_mark_buffer_dirty(trans, right);
3561 btrfs_mark_buffer_dirty(trans, l);
3562 BUG_ON(path->slots[0] != slot);
3563
3564 if (mid <= slot) {
3565 btrfs_tree_unlock(path->nodes[0]);
3566 free_extent_buffer(path->nodes[0]);
3567 path->nodes[0] = right;
3568 path->slots[0] -= mid;
3569 path->slots[1] += 1;
3570 } else {
3571 btrfs_tree_unlock(right);
3572 free_extent_buffer(right);
3573 }
3574
3575 BUG_ON(path->slots[0] < 0);
3576
3577 return 0;
3578}
3579
3580/*
3581 * double splits happen when we need to insert a big item in the middle
3582 * of a leaf. A double split can leave us with 3 mostly empty leaves:
3583 * leaf: [ slots 0 - N] [ our target ] [ N + 1 - total in leaf ]
3584 * A B C
3585 *
3586 * We avoid this by trying to push the items on either side of our target
3587 * into the adjacent leaves. If all goes well we can avoid the double split
3588 * completely.
3589 */
3590static noinline int push_for_double_split(struct btrfs_trans_handle *trans,
3591 struct btrfs_root *root,
3592 struct btrfs_path *path,
3593 int data_size)
3594{
3595 int ret;
3596 int progress = 0;
3597 int slot;
3598 u32 nritems;
3599 int space_needed = data_size;
3600
3601 slot = path->slots[0];
3602 if (slot < btrfs_header_nritems(path->nodes[0]))
3603 space_needed -= btrfs_leaf_free_space(path->nodes[0]);
3604
3605 /*
3606 * try to push all the items after our slot into the
3607 * right leaf
3608 */
3609 ret = push_leaf_right(trans, root, path, 1, space_needed, 0, slot);
3610 if (ret < 0)
3611 return ret;
3612
3613 if (ret == 0)
3614 progress++;
3615
3616 nritems = btrfs_header_nritems(path->nodes[0]);
3617 /*
3618 * our goal is to get our slot at the start or end of a leaf. If
3619 * we've done so we're done
3620 */
3621 if (path->slots[0] == 0 || path->slots[0] == nritems)
3622 return 0;
3623
3624 if (btrfs_leaf_free_space(path->nodes[0]) >= data_size)
3625 return 0;
3626
3627 /* try to push all the items before our slot into the next leaf */
3628 slot = path->slots[0];
3629 space_needed = data_size;
3630 if (slot > 0)
3631 space_needed -= btrfs_leaf_free_space(path->nodes[0]);
3632 ret = push_leaf_left(trans, root, path, 1, space_needed, 0, slot);
3633 if (ret < 0)
3634 return ret;
3635
3636 if (ret == 0)
3637 progress++;
3638
3639 if (progress)
3640 return 0;
3641 return 1;
3642}
3643
3644/*
3645 * split the path's leaf in two, making sure there is at least data_size
3646 * available for the resulting leaf level of the path.
3647 *
3648 * returns 0 if all went well and < 0 on failure.
3649 */
3650static noinline int split_leaf(struct btrfs_trans_handle *trans,
3651 struct btrfs_root *root,
3652 const struct btrfs_key *ins_key,
3653 struct btrfs_path *path, int data_size,
3654 int extend)
3655{
3656 struct btrfs_disk_key disk_key;
3657 struct extent_buffer *l;
3658 u32 nritems;
3659 int mid;
3660 int slot;
3661 struct extent_buffer *right;
3662 struct btrfs_fs_info *fs_info = root->fs_info;
3663 int ret = 0;
3664 int wret;
3665 int split;
3666 int num_doubles = 0;
3667 int tried_avoid_double = 0;
3668
3669 l = path->nodes[0];
3670 slot = path->slots[0];
3671 if (extend && data_size + btrfs_item_size(l, slot) +
3672 sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(fs_info))
3673 return -EOVERFLOW;
3674
3675 /* first try to make some room by pushing left and right */
3676 if (data_size && path->nodes[1]) {
3677 int space_needed = data_size;
3678
3679 if (slot < btrfs_header_nritems(l))
3680 space_needed -= btrfs_leaf_free_space(l);
3681
3682 wret = push_leaf_right(trans, root, path, space_needed,
3683 space_needed, 0, 0);
3684 if (wret < 0)
3685 return wret;
3686 if (wret) {
3687 space_needed = data_size;
3688 if (slot > 0)
3689 space_needed -= btrfs_leaf_free_space(l);
3690 wret = push_leaf_left(trans, root, path, space_needed,
3691 space_needed, 0, (u32)-1);
3692 if (wret < 0)
3693 return wret;
3694 }
3695 l = path->nodes[0];
3696
3697 /* did the pushes work? */
3698 if (btrfs_leaf_free_space(l) >= data_size)
3699 return 0;
3700 }
3701
3702 if (!path->nodes[1]) {
3703 ret = insert_new_root(trans, root, path, 1);
3704 if (ret)
3705 return ret;
3706 }
3707again:
3708 split = 1;
3709 l = path->nodes[0];
3710 slot = path->slots[0];
3711 nritems = btrfs_header_nritems(l);
3712 mid = (nritems + 1) / 2;
3713
3714 if (mid <= slot) {
3715 if (nritems == 1 ||
3716 leaf_space_used(l, mid, nritems - mid) + data_size >
3717 BTRFS_LEAF_DATA_SIZE(fs_info)) {
3718 if (slot >= nritems) {
3719 split = 0;
3720 } else {
3721 mid = slot;
3722 if (mid != nritems &&
3723 leaf_space_used(l, mid, nritems - mid) +
3724 data_size > BTRFS_LEAF_DATA_SIZE(fs_info)) {
3725 if (data_size && !tried_avoid_double)
3726 goto push_for_double;
3727 split = 2;
3728 }
3729 }
3730 }
3731 } else {
3732 if (leaf_space_used(l, 0, mid) + data_size >
3733 BTRFS_LEAF_DATA_SIZE(fs_info)) {
3734 if (!extend && data_size && slot == 0) {
3735 split = 0;
3736 } else if ((extend || !data_size) && slot == 0) {
3737 mid = 1;
3738 } else {
3739 mid = slot;
3740 if (mid != nritems &&
3741 leaf_space_used(l, mid, nritems - mid) +
3742 data_size > BTRFS_LEAF_DATA_SIZE(fs_info)) {
3743 if (data_size && !tried_avoid_double)
3744 goto push_for_double;
3745 split = 2;
3746 }
3747 }
3748 }
3749 }
3750
3751 if (split == 0)
3752 btrfs_cpu_key_to_disk(&disk_key, ins_key);
3753 else
3754 btrfs_item_key(l, &disk_key, mid);
3755
3756 /*
3757 * We have to about BTRFS_NESTING_NEW_ROOT here if we've done a double
3758 * split, because we're only allowed to have MAX_LOCKDEP_SUBCLASSES
3759 * subclasses, which is 8 at the time of this patch, and we've maxed it
3760 * out. In the future we could add a
3761 * BTRFS_NESTING_SPLIT_THE_SPLITTENING if we need to, but for now just
3762 * use BTRFS_NESTING_NEW_ROOT.
3763 */
3764 right = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid,
3765 &disk_key, 0, l->start, 0, 0,
3766 num_doubles ? BTRFS_NESTING_NEW_ROOT :
3767 BTRFS_NESTING_SPLIT);
3768 if (IS_ERR(right))
3769 return PTR_ERR(right);
3770
3771 root_add_used_bytes(root);
3772
3773 if (split == 0) {
3774 if (mid <= slot) {
3775 btrfs_set_header_nritems(right, 0);
3776 ret = insert_ptr(trans, path, &disk_key,
3777 right->start, path->slots[1] + 1, 1);
3778 if (ret < 0) {
3779 btrfs_tree_unlock(right);
3780 free_extent_buffer(right);
3781 return ret;
3782 }
3783 btrfs_tree_unlock(path->nodes[0]);
3784 free_extent_buffer(path->nodes[0]);
3785 path->nodes[0] = right;
3786 path->slots[0] = 0;
3787 path->slots[1] += 1;
3788 } else {
3789 btrfs_set_header_nritems(right, 0);
3790 ret = insert_ptr(trans, path, &disk_key,
3791 right->start, path->slots[1], 1);
3792 if (ret < 0) {
3793 btrfs_tree_unlock(right);
3794 free_extent_buffer(right);
3795 return ret;
3796 }
3797 btrfs_tree_unlock(path->nodes[0]);
3798 free_extent_buffer(path->nodes[0]);
3799 path->nodes[0] = right;
3800 path->slots[0] = 0;
3801 if (path->slots[1] == 0)
3802 fixup_low_keys(trans, path, &disk_key, 1);
3803 }
3804 /*
3805 * We create a new leaf 'right' for the required ins_len and
3806 * we'll do btrfs_mark_buffer_dirty() on this leaf after copying
3807 * the content of ins_len to 'right'.
3808 */
3809 return ret;
3810 }
3811
3812 ret = copy_for_split(trans, path, l, right, slot, mid, nritems);
3813 if (ret < 0) {
3814 btrfs_tree_unlock(right);
3815 free_extent_buffer(right);
3816 return ret;
3817 }
3818
3819 if (split == 2) {
3820 BUG_ON(num_doubles != 0);
3821 num_doubles++;
3822 goto again;
3823 }
3824
3825 return 0;
3826
3827push_for_double:
3828 push_for_double_split(trans, root, path, data_size);
3829 tried_avoid_double = 1;
3830 if (btrfs_leaf_free_space(path->nodes[0]) >= data_size)
3831 return 0;
3832 goto again;
3833}
3834
3835static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans,
3836 struct btrfs_root *root,
3837 struct btrfs_path *path, int ins_len)
3838{
3839 struct btrfs_key key;
3840 struct extent_buffer *leaf;
3841 struct btrfs_file_extent_item *fi;
3842 u64 extent_len = 0;
3843 u32 item_size;
3844 int ret;
3845
3846 leaf = path->nodes[0];
3847 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
3848
3849 BUG_ON(key.type != BTRFS_EXTENT_DATA_KEY &&
3850 key.type != BTRFS_EXTENT_CSUM_KEY);
3851
3852 if (btrfs_leaf_free_space(leaf) >= ins_len)
3853 return 0;
3854
3855 item_size = btrfs_item_size(leaf, path->slots[0]);
3856 if (key.type == BTRFS_EXTENT_DATA_KEY) {
3857 fi = btrfs_item_ptr(leaf, path->slots[0],
3858 struct btrfs_file_extent_item);
3859 extent_len = btrfs_file_extent_num_bytes(leaf, fi);
3860 }
3861 btrfs_release_path(path);
3862
3863 path->keep_locks = 1;
3864 path->search_for_split = 1;
3865 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
3866 path->search_for_split = 0;
3867 if (ret > 0)
3868 ret = -EAGAIN;
3869 if (ret < 0)
3870 goto err;
3871
3872 ret = -EAGAIN;
3873 leaf = path->nodes[0];
3874 /* if our item isn't there, return now */
3875 if (item_size != btrfs_item_size(leaf, path->slots[0]))
3876 goto err;
3877
3878 /* the leaf has changed, it now has room. return now */
3879 if (btrfs_leaf_free_space(path->nodes[0]) >= ins_len)
3880 goto err;
3881
3882 if (key.type == BTRFS_EXTENT_DATA_KEY) {
3883 fi = btrfs_item_ptr(leaf, path->slots[0],
3884 struct btrfs_file_extent_item);
3885 if (extent_len != btrfs_file_extent_num_bytes(leaf, fi))
3886 goto err;
3887 }
3888
3889 ret = split_leaf(trans, root, &key, path, ins_len, 1);
3890 if (ret)
3891 goto err;
3892
3893 path->keep_locks = 0;
3894 btrfs_unlock_up_safe(path, 1);
3895 return 0;
3896err:
3897 path->keep_locks = 0;
3898 return ret;
3899}
3900
3901static noinline int split_item(struct btrfs_trans_handle *trans,
3902 struct btrfs_path *path,
3903 const struct btrfs_key *new_key,
3904 unsigned long split_offset)
3905{
3906 struct extent_buffer *leaf;
3907 int orig_slot, slot;
3908 char *buf;
3909 u32 nritems;
3910 u32 item_size;
3911 u32 orig_offset;
3912 struct btrfs_disk_key disk_key;
3913
3914 leaf = path->nodes[0];
3915 /*
3916 * Shouldn't happen because the caller must have previously called
3917 * setup_leaf_for_split() to make room for the new item in the leaf.
3918 */
3919 if (WARN_ON(btrfs_leaf_free_space(leaf) < sizeof(struct btrfs_item)))
3920 return -ENOSPC;
3921
3922 orig_slot = path->slots[0];
3923 orig_offset = btrfs_item_offset(leaf, path->slots[0]);
3924 item_size = btrfs_item_size(leaf, path->slots[0]);
3925
3926 buf = kmalloc(item_size, GFP_NOFS);
3927 if (!buf)
3928 return -ENOMEM;
3929
3930 read_extent_buffer(leaf, buf, btrfs_item_ptr_offset(leaf,
3931 path->slots[0]), item_size);
3932
3933 slot = path->slots[0] + 1;
3934 nritems = btrfs_header_nritems(leaf);
3935 if (slot != nritems) {
3936 /* shift the items */
3937 memmove_leaf_items(leaf, slot + 1, slot, nritems - slot);
3938 }
3939
3940 btrfs_cpu_key_to_disk(&disk_key, new_key);
3941 btrfs_set_item_key(leaf, &disk_key, slot);
3942
3943 btrfs_set_item_offset(leaf, slot, orig_offset);
3944 btrfs_set_item_size(leaf, slot, item_size - split_offset);
3945
3946 btrfs_set_item_offset(leaf, orig_slot,
3947 orig_offset + item_size - split_offset);
3948 btrfs_set_item_size(leaf, orig_slot, split_offset);
3949
3950 btrfs_set_header_nritems(leaf, nritems + 1);
3951
3952 /* write the data for the start of the original item */
3953 write_extent_buffer(leaf, buf,
3954 btrfs_item_ptr_offset(leaf, path->slots[0]),
3955 split_offset);
3956
3957 /* write the data for the new item */
3958 write_extent_buffer(leaf, buf + split_offset,
3959 btrfs_item_ptr_offset(leaf, slot),
3960 item_size - split_offset);
3961 btrfs_mark_buffer_dirty(trans, leaf);
3962
3963 BUG_ON(btrfs_leaf_free_space(leaf) < 0);
3964 kfree(buf);
3965 return 0;
3966}
3967
3968/*
3969 * This function splits a single item into two items,
3970 * giving 'new_key' to the new item and splitting the
3971 * old one at split_offset (from the start of the item).
3972 *
3973 * The path may be released by this operation. After
3974 * the split, the path is pointing to the old item. The
3975 * new item is going to be in the same node as the old one.
3976 *
3977 * Note, the item being split must be smaller enough to live alone on
3978 * a tree block with room for one extra struct btrfs_item
3979 *
3980 * This allows us to split the item in place, keeping a lock on the
3981 * leaf the entire time.
3982 */
3983int btrfs_split_item(struct btrfs_trans_handle *trans,
3984 struct btrfs_root *root,
3985 struct btrfs_path *path,
3986 const struct btrfs_key *new_key,
3987 unsigned long split_offset)
3988{
3989 int ret;
3990 ret = setup_leaf_for_split(trans, root, path,
3991 sizeof(struct btrfs_item));
3992 if (ret)
3993 return ret;
3994
3995 ret = split_item(trans, path, new_key, split_offset);
3996 return ret;
3997}
3998
3999/*
4000 * make the item pointed to by the path smaller. new_size indicates
4001 * how small to make it, and from_end tells us if we just chop bytes
4002 * off the end of the item or if we shift the item to chop bytes off
4003 * the front.
4004 */
4005void btrfs_truncate_item(struct btrfs_trans_handle *trans,
4006 struct btrfs_path *path, u32 new_size, int from_end)
4007{
4008 int slot;
4009 struct extent_buffer *leaf;
4010 u32 nritems;
4011 unsigned int data_end;
4012 unsigned int old_data_start;
4013 unsigned int old_size;
4014 unsigned int size_diff;
4015 int i;
4016 struct btrfs_map_token token;
4017
4018 leaf = path->nodes[0];
4019 slot = path->slots[0];
4020
4021 old_size = btrfs_item_size(leaf, slot);
4022 if (old_size == new_size)
4023 return;
4024
4025 nritems = btrfs_header_nritems(leaf);
4026 data_end = leaf_data_end(leaf);
4027
4028 old_data_start = btrfs_item_offset(leaf, slot);
4029
4030 size_diff = old_size - new_size;
4031
4032 BUG_ON(slot < 0);
4033 BUG_ON(slot >= nritems);
4034
4035 /*
4036 * item0..itemN ... dataN.offset..dataN.size .. data0.size
4037 */
4038 /* first correct the data pointers */
4039 btrfs_init_map_token(&token, leaf);
4040 for (i = slot; i < nritems; i++) {
4041 u32 ioff;
4042
4043 ioff = btrfs_token_item_offset(&token, i);
4044 btrfs_set_token_item_offset(&token, i, ioff + size_diff);
4045 }
4046
4047 /* shift the data */
4048 if (from_end) {
4049 memmove_leaf_data(leaf, data_end + size_diff, data_end,
4050 old_data_start + new_size - data_end);
4051 } else {
4052 struct btrfs_disk_key disk_key;
4053 u64 offset;
4054
4055 btrfs_item_key(leaf, &disk_key, slot);
4056
4057 if (btrfs_disk_key_type(&disk_key) == BTRFS_EXTENT_DATA_KEY) {
4058 unsigned long ptr;
4059 struct btrfs_file_extent_item *fi;
4060
4061 fi = btrfs_item_ptr(leaf, slot,
4062 struct btrfs_file_extent_item);
4063 fi = (struct btrfs_file_extent_item *)(
4064 (unsigned long)fi - size_diff);
4065
4066 if (btrfs_file_extent_type(leaf, fi) ==
4067 BTRFS_FILE_EXTENT_INLINE) {
4068 ptr = btrfs_item_ptr_offset(leaf, slot);
4069 memmove_extent_buffer(leaf, ptr,
4070 (unsigned long)fi,
4071 BTRFS_FILE_EXTENT_INLINE_DATA_START);
4072 }
4073 }
4074
4075 memmove_leaf_data(leaf, data_end + size_diff, data_end,
4076 old_data_start - data_end);
4077
4078 offset = btrfs_disk_key_offset(&disk_key);
4079 btrfs_set_disk_key_offset(&disk_key, offset + size_diff);
4080 btrfs_set_item_key(leaf, &disk_key, slot);
4081 if (slot == 0)
4082 fixup_low_keys(trans, path, &disk_key, 1);
4083 }
4084
4085 btrfs_set_item_size(leaf, slot, new_size);
4086 btrfs_mark_buffer_dirty(trans, leaf);
4087
4088 if (btrfs_leaf_free_space(leaf) < 0) {
4089 btrfs_print_leaf(leaf);
4090 BUG();
4091 }
4092}
4093
4094/*
4095 * make the item pointed to by the path bigger, data_size is the added size.
4096 */
4097void btrfs_extend_item(struct btrfs_trans_handle *trans,
4098 struct btrfs_path *path, u32 data_size)
4099{
4100 int slot;
4101 struct extent_buffer *leaf;
4102 u32 nritems;
4103 unsigned int data_end;
4104 unsigned int old_data;
4105 unsigned int old_size;
4106 int i;
4107 struct btrfs_map_token token;
4108
4109 leaf = path->nodes[0];
4110
4111 nritems = btrfs_header_nritems(leaf);
4112 data_end = leaf_data_end(leaf);
4113
4114 if (btrfs_leaf_free_space(leaf) < data_size) {
4115 btrfs_print_leaf(leaf);
4116 BUG();
4117 }
4118 slot = path->slots[0];
4119 old_data = btrfs_item_data_end(leaf, slot);
4120
4121 BUG_ON(slot < 0);
4122 if (slot >= nritems) {
4123 btrfs_print_leaf(leaf);
4124 btrfs_crit(leaf->fs_info, "slot %d too large, nritems %d",
4125 slot, nritems);
4126 BUG();
4127 }
4128
4129 /*
4130 * item0..itemN ... dataN.offset..dataN.size .. data0.size
4131 */
4132 /* first correct the data pointers */
4133 btrfs_init_map_token(&token, leaf);
4134 for (i = slot; i < nritems; i++) {
4135 u32 ioff;
4136
4137 ioff = btrfs_token_item_offset(&token, i);
4138 btrfs_set_token_item_offset(&token, i, ioff - data_size);
4139 }
4140
4141 /* shift the data */
4142 memmove_leaf_data(leaf, data_end - data_size, data_end,
4143 old_data - data_end);
4144
4145 data_end = old_data;
4146 old_size = btrfs_item_size(leaf, slot);
4147 btrfs_set_item_size(leaf, slot, old_size + data_size);
4148 btrfs_mark_buffer_dirty(trans, leaf);
4149
4150 if (btrfs_leaf_free_space(leaf) < 0) {
4151 btrfs_print_leaf(leaf);
4152 BUG();
4153 }
4154}
4155
4156/*
4157 * Make space in the node before inserting one or more items.
4158 *
4159 * @trans: transaction handle
4160 * @root: root we are inserting items to
4161 * @path: points to the leaf/slot where we are going to insert new items
4162 * @batch: information about the batch of items to insert
4163 *
4164 * Main purpose is to save stack depth by doing the bulk of the work in a
4165 * function that doesn't call btrfs_search_slot
4166 */
4167static void setup_items_for_insert(struct btrfs_trans_handle *trans,
4168 struct btrfs_root *root, struct btrfs_path *path,
4169 const struct btrfs_item_batch *batch)
4170{
4171 struct btrfs_fs_info *fs_info = root->fs_info;
4172 int i;
4173 u32 nritems;
4174 unsigned int data_end;
4175 struct btrfs_disk_key disk_key;
4176 struct extent_buffer *leaf;
4177 int slot;
4178 struct btrfs_map_token token;
4179 u32 total_size;
4180
4181 /*
4182 * Before anything else, update keys in the parent and other ancestors
4183 * if needed, then release the write locks on them, so that other tasks
4184 * can use them while we modify the leaf.
4185 */
4186 if (path->slots[0] == 0) {
4187 btrfs_cpu_key_to_disk(&disk_key, &batch->keys[0]);
4188 fixup_low_keys(trans, path, &disk_key, 1);
4189 }
4190 btrfs_unlock_up_safe(path, 1);
4191
4192 leaf = path->nodes[0];
4193 slot = path->slots[0];
4194
4195 nritems = btrfs_header_nritems(leaf);
4196 data_end = leaf_data_end(leaf);
4197 total_size = batch->total_data_size + (batch->nr * sizeof(struct btrfs_item));
4198
4199 if (btrfs_leaf_free_space(leaf) < total_size) {
4200 btrfs_print_leaf(leaf);
4201 btrfs_crit(fs_info, "not enough freespace need %u have %d",
4202 total_size, btrfs_leaf_free_space(leaf));
4203 BUG();
4204 }
4205
4206 btrfs_init_map_token(&token, leaf);
4207 if (slot != nritems) {
4208 unsigned int old_data = btrfs_item_data_end(leaf, slot);
4209
4210 if (old_data < data_end) {
4211 btrfs_print_leaf(leaf);
4212 btrfs_crit(fs_info,
4213 "item at slot %d with data offset %u beyond data end of leaf %u",
4214 slot, old_data, data_end);
4215 BUG();
4216 }
4217 /*
4218 * item0..itemN ... dataN.offset..dataN.size .. data0.size
4219 */
4220 /* first correct the data pointers */
4221 for (i = slot; i < nritems; i++) {
4222 u32 ioff;
4223
4224 ioff = btrfs_token_item_offset(&token, i);
4225 btrfs_set_token_item_offset(&token, i,
4226 ioff - batch->total_data_size);
4227 }
4228 /* shift the items */
4229 memmove_leaf_items(leaf, slot + batch->nr, slot, nritems - slot);
4230
4231 /* shift the data */
4232 memmove_leaf_data(leaf, data_end - batch->total_data_size,
4233 data_end, old_data - data_end);
4234 data_end = old_data;
4235 }
4236
4237 /* setup the item for the new data */
4238 for (i = 0; i < batch->nr; i++) {
4239 btrfs_cpu_key_to_disk(&disk_key, &batch->keys[i]);
4240 btrfs_set_item_key(leaf, &disk_key, slot + i);
4241 data_end -= batch->data_sizes[i];
4242 btrfs_set_token_item_offset(&token, slot + i, data_end);
4243 btrfs_set_token_item_size(&token, slot + i, batch->data_sizes[i]);
4244 }
4245
4246 btrfs_set_header_nritems(leaf, nritems + batch->nr);
4247 btrfs_mark_buffer_dirty(trans, leaf);
4248
4249 if (btrfs_leaf_free_space(leaf) < 0) {
4250 btrfs_print_leaf(leaf);
4251 BUG();
4252 }
4253}
4254
4255/*
4256 * Insert a new item into a leaf.
4257 *
4258 * @trans: Transaction handle.
4259 * @root: The root of the btree.
4260 * @path: A path pointing to the target leaf and slot.
4261 * @key: The key of the new item.
4262 * @data_size: The size of the data associated with the new key.
4263 */
4264void btrfs_setup_item_for_insert(struct btrfs_trans_handle *trans,
4265 struct btrfs_root *root,
4266 struct btrfs_path *path,
4267 const struct btrfs_key *key,
4268 u32 data_size)
4269{
4270 struct btrfs_item_batch batch;
4271
4272 batch.keys = key;
4273 batch.data_sizes = &data_size;
4274 batch.total_data_size = data_size;
4275 batch.nr = 1;
4276
4277 setup_items_for_insert(trans, root, path, &batch);
4278}
4279
4280/*
4281 * Given a key and some data, insert items into the tree.
4282 * This does all the path init required, making room in the tree if needed.
4283 *
4284 * Returns: 0 on success
4285 * -EEXIST if the first key already exists
4286 * < 0 on other errors
4287 */
4288int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
4289 struct btrfs_root *root,
4290 struct btrfs_path *path,
4291 const struct btrfs_item_batch *batch)
4292{
4293 int ret = 0;
4294 int slot;
4295 u32 total_size;
4296
4297 total_size = batch->total_data_size + (batch->nr * sizeof(struct btrfs_item));
4298 ret = btrfs_search_slot(trans, root, &batch->keys[0], path, total_size, 1);
4299 if (ret == 0)
4300 return -EEXIST;
4301 if (ret < 0)
4302 return ret;
4303
4304 slot = path->slots[0];
4305 BUG_ON(slot < 0);
4306
4307 setup_items_for_insert(trans, root, path, batch);
4308 return 0;
4309}
4310
4311/*
4312 * Given a key and some data, insert an item into the tree.
4313 * This does all the path init required, making room in the tree if needed.
4314 */
4315int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
4316 const struct btrfs_key *cpu_key, void *data,
4317 u32 data_size)
4318{
4319 int ret = 0;
4320 struct btrfs_path *path;
4321 struct extent_buffer *leaf;
4322 unsigned long ptr;
4323
4324 path = btrfs_alloc_path();
4325 if (!path)
4326 return -ENOMEM;
4327 ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
4328 if (!ret) {
4329 leaf = path->nodes[0];
4330 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
4331 write_extent_buffer(leaf, data, ptr, data_size);
4332 btrfs_mark_buffer_dirty(trans, leaf);
4333 }
4334 btrfs_free_path(path);
4335 return ret;
4336}
4337
4338/*
4339 * This function duplicates an item, giving 'new_key' to the new item.
4340 * It guarantees both items live in the same tree leaf and the new item is
4341 * contiguous with the original item.
4342 *
4343 * This allows us to split a file extent in place, keeping a lock on the leaf
4344 * the entire time.
4345 */
4346int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
4347 struct btrfs_root *root,
4348 struct btrfs_path *path,
4349 const struct btrfs_key *new_key)
4350{
4351 struct extent_buffer *leaf;
4352 int ret;
4353 u32 item_size;
4354
4355 leaf = path->nodes[0];
4356 item_size = btrfs_item_size(leaf, path->slots[0]);
4357 ret = setup_leaf_for_split(trans, root, path,
4358 item_size + sizeof(struct btrfs_item));
4359 if (ret)
4360 return ret;
4361
4362 path->slots[0]++;
4363 btrfs_setup_item_for_insert(trans, root, path, new_key, item_size);
4364 leaf = path->nodes[0];
4365 memcpy_extent_buffer(leaf,
4366 btrfs_item_ptr_offset(leaf, path->slots[0]),
4367 btrfs_item_ptr_offset(leaf, path->slots[0] - 1),
4368 item_size);
4369 return 0;
4370}
4371
4372/*
4373 * delete the pointer from a given node.
4374 *
4375 * the tree should have been previously balanced so the deletion does not
4376 * empty a node.
4377 *
4378 * This is exported for use inside btrfs-progs, don't un-export it.
4379 */
4380int btrfs_del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
4381 struct btrfs_path *path, int level, int slot)
4382{
4383 struct extent_buffer *parent = path->nodes[level];
4384 u32 nritems;
4385 int ret;
4386
4387 nritems = btrfs_header_nritems(parent);
4388 if (slot != nritems - 1) {
4389 if (level) {
4390 ret = btrfs_tree_mod_log_insert_move(parent, slot,
4391 slot + 1, nritems - slot - 1);
4392 if (ret < 0) {
4393 btrfs_abort_transaction(trans, ret);
4394 return ret;
4395 }
4396 }
4397 memmove_extent_buffer(parent,
4398 btrfs_node_key_ptr_offset(parent, slot),
4399 btrfs_node_key_ptr_offset(parent, slot + 1),
4400 sizeof(struct btrfs_key_ptr) *
4401 (nritems - slot - 1));
4402 } else if (level) {
4403 ret = btrfs_tree_mod_log_insert_key(parent, slot,
4404 BTRFS_MOD_LOG_KEY_REMOVE);
4405 if (ret < 0) {
4406 btrfs_abort_transaction(trans, ret);
4407 return ret;
4408 }
4409 }
4410
4411 nritems--;
4412 btrfs_set_header_nritems(parent, nritems);
4413 if (nritems == 0 && parent == root->node) {
4414 BUG_ON(btrfs_header_level(root->node) != 1);
4415 /* just turn the root into a leaf and break */
4416 btrfs_set_header_level(root->node, 0);
4417 } else if (slot == 0) {
4418 struct btrfs_disk_key disk_key;
4419
4420 btrfs_node_key(parent, &disk_key, 0);
4421 fixup_low_keys(trans, path, &disk_key, level + 1);
4422 }
4423 btrfs_mark_buffer_dirty(trans, parent);
4424 return 0;
4425}
4426
4427/*
4428 * a helper function to delete the leaf pointed to by path->slots[1] and
4429 * path->nodes[1].
4430 *
4431 * This deletes the pointer in path->nodes[1] and frees the leaf
4432 * block extent. zero is returned if it all worked out, < 0 otherwise.
4433 *
4434 * The path must have already been setup for deleting the leaf, including
4435 * all the proper balancing. path->nodes[1] must be locked.
4436 */
4437static noinline int btrfs_del_leaf(struct btrfs_trans_handle *trans,
4438 struct btrfs_root *root,
4439 struct btrfs_path *path,
4440 struct extent_buffer *leaf)
4441{
4442 int ret;
4443
4444 WARN_ON(btrfs_header_generation(leaf) != trans->transid);
4445 ret = btrfs_del_ptr(trans, root, path, 1, path->slots[1]);
4446 if (ret < 0)
4447 return ret;
4448
4449 /*
4450 * btrfs_free_extent is expensive, we want to make sure we
4451 * aren't holding any locks when we call it
4452 */
4453 btrfs_unlock_up_safe(path, 0);
4454
4455 root_sub_used_bytes(root);
4456
4457 atomic_inc(&leaf->refs);
4458 btrfs_free_tree_block(trans, btrfs_root_id(root), leaf, 0, 1);
4459 free_extent_buffer_stale(leaf);
4460 return 0;
4461}
4462/*
4463 * delete the item at the leaf level in path. If that empties
4464 * the leaf, remove it from the tree
4465 */
4466int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
4467 struct btrfs_path *path, int slot, int nr)
4468{
4469 struct btrfs_fs_info *fs_info = root->fs_info;
4470 struct extent_buffer *leaf;
4471 int ret = 0;
4472 int wret;
4473 u32 nritems;
4474
4475 leaf = path->nodes[0];
4476 nritems = btrfs_header_nritems(leaf);
4477
4478 if (slot + nr != nritems) {
4479 const u32 last_off = btrfs_item_offset(leaf, slot + nr - 1);
4480 const int data_end = leaf_data_end(leaf);
4481 struct btrfs_map_token token;
4482 u32 dsize = 0;
4483 int i;
4484
4485 for (i = 0; i < nr; i++)
4486 dsize += btrfs_item_size(leaf, slot + i);
4487
4488 memmove_leaf_data(leaf, data_end + dsize, data_end,
4489 last_off - data_end);
4490
4491 btrfs_init_map_token(&token, leaf);
4492 for (i = slot + nr; i < nritems; i++) {
4493 u32 ioff;
4494
4495 ioff = btrfs_token_item_offset(&token, i);
4496 btrfs_set_token_item_offset(&token, i, ioff + dsize);
4497 }
4498
4499 memmove_leaf_items(leaf, slot, slot + nr, nritems - slot - nr);
4500 }
4501 btrfs_set_header_nritems(leaf, nritems - nr);
4502 nritems -= nr;
4503
4504 /* delete the leaf if we've emptied it */
4505 if (nritems == 0) {
4506 if (leaf == root->node) {
4507 btrfs_set_header_level(leaf, 0);
4508 } else {
4509 btrfs_clear_buffer_dirty(trans, leaf);
4510 ret = btrfs_del_leaf(trans, root, path, leaf);
4511 if (ret < 0)
4512 return ret;
4513 }
4514 } else {
4515 int used = leaf_space_used(leaf, 0, nritems);
4516 if (slot == 0) {
4517 struct btrfs_disk_key disk_key;
4518
4519 btrfs_item_key(leaf, &disk_key, 0);
4520 fixup_low_keys(trans, path, &disk_key, 1);
4521 }
4522
4523 /*
4524 * Try to delete the leaf if it is mostly empty. We do this by
4525 * trying to move all its items into its left and right neighbours.
4526 * If we can't move all the items, then we don't delete it - it's
4527 * not ideal, but future insertions might fill the leaf with more
4528 * items, or items from other leaves might be moved later into our
4529 * leaf due to deletions on those leaves.
4530 */
4531 if (used < BTRFS_LEAF_DATA_SIZE(fs_info) / 3) {
4532 u32 min_push_space;
4533
4534 /* push_leaf_left fixes the path.
4535 * make sure the path still points to our leaf
4536 * for possible call to btrfs_del_ptr below
4537 */
4538 slot = path->slots[1];
4539 atomic_inc(&leaf->refs);
4540 /*
4541 * We want to be able to at least push one item to the
4542 * left neighbour leaf, and that's the first item.
4543 */
4544 min_push_space = sizeof(struct btrfs_item) +
4545 btrfs_item_size(leaf, 0);
4546 wret = push_leaf_left(trans, root, path, 0,
4547 min_push_space, 1, (u32)-1);
4548 if (wret < 0 && wret != -ENOSPC)
4549 ret = wret;
4550
4551 if (path->nodes[0] == leaf &&
4552 btrfs_header_nritems(leaf)) {
4553 /*
4554 * If we were not able to push all items from our
4555 * leaf to its left neighbour, then attempt to
4556 * either push all the remaining items to the
4557 * right neighbour or none. There's no advantage
4558 * in pushing only some items, instead of all, as
4559 * it's pointless to end up with a leaf having
4560 * too few items while the neighbours can be full
4561 * or nearly full.
4562 */
4563 nritems = btrfs_header_nritems(leaf);
4564 min_push_space = leaf_space_used(leaf, 0, nritems);
4565 wret = push_leaf_right(trans, root, path, 0,
4566 min_push_space, 1, 0);
4567 if (wret < 0 && wret != -ENOSPC)
4568 ret = wret;
4569 }
4570
4571 if (btrfs_header_nritems(leaf) == 0) {
4572 path->slots[1] = slot;
4573 ret = btrfs_del_leaf(trans, root, path, leaf);
4574 if (ret < 0)
4575 return ret;
4576 free_extent_buffer(leaf);
4577 ret = 0;
4578 } else {
4579 /* if we're still in the path, make sure
4580 * we're dirty. Otherwise, one of the
4581 * push_leaf functions must have already
4582 * dirtied this buffer
4583 */
4584 if (path->nodes[0] == leaf)
4585 btrfs_mark_buffer_dirty(trans, leaf);
4586 free_extent_buffer(leaf);
4587 }
4588 } else {
4589 btrfs_mark_buffer_dirty(trans, leaf);
4590 }
4591 }
4592 return ret;
4593}
4594
4595/*
4596 * A helper function to walk down the tree starting at min_key, and looking
4597 * for nodes or leaves that are have a minimum transaction id.
4598 * This is used by the btree defrag code, and tree logging
4599 *
4600 * This does not cow, but it does stuff the starting key it finds back
4601 * into min_key, so you can call btrfs_search_slot with cow=1 on the
4602 * key and get a writable path.
4603 *
4604 * This honors path->lowest_level to prevent descent past a given level
4605 * of the tree.
4606 *
4607 * min_trans indicates the oldest transaction that you are interested
4608 * in walking through. Any nodes or leaves older than min_trans are
4609 * skipped over (without reading them).
4610 *
4611 * returns zero if something useful was found, < 0 on error and 1 if there
4612 * was nothing in the tree that matched the search criteria.
4613 */
4614int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
4615 struct btrfs_path *path,
4616 u64 min_trans)
4617{
4618 struct extent_buffer *cur;
4619 struct btrfs_key found_key;
4620 int slot;
4621 int sret;
4622 u32 nritems;
4623 int level;
4624 int ret = 1;
4625 int keep_locks = path->keep_locks;
4626
4627 ASSERT(!path->nowait);
4628 path->keep_locks = 1;
4629again:
4630 cur = btrfs_read_lock_root_node(root);
4631 level = btrfs_header_level(cur);
4632 WARN_ON(path->nodes[level]);
4633 path->nodes[level] = cur;
4634 path->locks[level] = BTRFS_READ_LOCK;
4635
4636 if (btrfs_header_generation(cur) < min_trans) {
4637 ret = 1;
4638 goto out;
4639 }
4640 while (1) {
4641 nritems = btrfs_header_nritems(cur);
4642 level = btrfs_header_level(cur);
4643 sret = btrfs_bin_search(cur, 0, min_key, &slot);
4644 if (sret < 0) {
4645 ret = sret;
4646 goto out;
4647 }
4648
4649 /* at the lowest level, we're done, setup the path and exit */
4650 if (level == path->lowest_level) {
4651 if (slot >= nritems)
4652 goto find_next_key;
4653 ret = 0;
4654 path->slots[level] = slot;
4655 btrfs_item_key_to_cpu(cur, &found_key, slot);
4656 goto out;
4657 }
4658 if (sret && slot > 0)
4659 slot--;
4660 /*
4661 * check this node pointer against the min_trans parameters.
4662 * If it is too old, skip to the next one.
4663 */
4664 while (slot < nritems) {
4665 u64 gen;
4666
4667 gen = btrfs_node_ptr_generation(cur, slot);
4668 if (gen < min_trans) {
4669 slot++;
4670 continue;
4671 }
4672 break;
4673 }
4674find_next_key:
4675 /*
4676 * we didn't find a candidate key in this node, walk forward
4677 * and find another one
4678 */
4679 if (slot >= nritems) {
4680 path->slots[level] = slot;
4681 sret = btrfs_find_next_key(root, path, min_key, level,
4682 min_trans);
4683 if (sret == 0) {
4684 btrfs_release_path(path);
4685 goto again;
4686 } else {
4687 goto out;
4688 }
4689 }
4690 /* save our key for returning back */
4691 btrfs_node_key_to_cpu(cur, &found_key, slot);
4692 path->slots[level] = slot;
4693 if (level == path->lowest_level) {
4694 ret = 0;
4695 goto out;
4696 }
4697 cur = btrfs_read_node_slot(cur, slot);
4698 if (IS_ERR(cur)) {
4699 ret = PTR_ERR(cur);
4700 goto out;
4701 }
4702
4703 btrfs_tree_read_lock(cur);
4704
4705 path->locks[level - 1] = BTRFS_READ_LOCK;
4706 path->nodes[level - 1] = cur;
4707 unlock_up(path, level, 1, 0, NULL);
4708 }
4709out:
4710 path->keep_locks = keep_locks;
4711 if (ret == 0) {
4712 btrfs_unlock_up_safe(path, path->lowest_level + 1);
4713 memcpy(min_key, &found_key, sizeof(found_key));
4714 }
4715 return ret;
4716}
4717
4718/*
4719 * this is similar to btrfs_next_leaf, but does not try to preserve
4720 * and fixup the path. It looks for and returns the next key in the
4721 * tree based on the current path and the min_trans parameters.
4722 *
4723 * 0 is returned if another key is found, < 0 if there are any errors
4724 * and 1 is returned if there are no higher keys in the tree
4725 *
4726 * path->keep_locks should be set to 1 on the search made before
4727 * calling this function.
4728 */
4729int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
4730 struct btrfs_key *key, int level, u64 min_trans)
4731{
4732 int slot;
4733 struct extent_buffer *c;
4734
4735 WARN_ON(!path->keep_locks && !path->skip_locking);
4736 while (level < BTRFS_MAX_LEVEL) {
4737 if (!path->nodes[level])
4738 return 1;
4739
4740 slot = path->slots[level] + 1;
4741 c = path->nodes[level];
4742next:
4743 if (slot >= btrfs_header_nritems(c)) {
4744 int ret;
4745 int orig_lowest;
4746 struct btrfs_key cur_key;
4747 if (level + 1 >= BTRFS_MAX_LEVEL ||
4748 !path->nodes[level + 1])
4749 return 1;
4750
4751 if (path->locks[level + 1] || path->skip_locking) {
4752 level++;
4753 continue;
4754 }
4755
4756 slot = btrfs_header_nritems(c) - 1;
4757 if (level == 0)
4758 btrfs_item_key_to_cpu(c, &cur_key, slot);
4759 else
4760 btrfs_node_key_to_cpu(c, &cur_key, slot);
4761
4762 orig_lowest = path->lowest_level;
4763 btrfs_release_path(path);
4764 path->lowest_level = level;
4765 ret = btrfs_search_slot(NULL, root, &cur_key, path,
4766 0, 0);
4767 path->lowest_level = orig_lowest;
4768 if (ret < 0)
4769 return ret;
4770
4771 c = path->nodes[level];
4772 slot = path->slots[level];
4773 if (ret == 0)
4774 slot++;
4775 goto next;
4776 }
4777
4778 if (level == 0)
4779 btrfs_item_key_to_cpu(c, key, slot);
4780 else {
4781 u64 gen = btrfs_node_ptr_generation(c, slot);
4782
4783 if (gen < min_trans) {
4784 slot++;
4785 goto next;
4786 }
4787 btrfs_node_key_to_cpu(c, key, slot);
4788 }
4789 return 0;
4790 }
4791 return 1;
4792}
4793
4794int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
4795 u64 time_seq)
4796{
4797 int slot;
4798 int level;
4799 struct extent_buffer *c;
4800 struct extent_buffer *next;
4801 struct btrfs_fs_info *fs_info = root->fs_info;
4802 struct btrfs_key key;
4803 bool need_commit_sem = false;
4804 u32 nritems;
4805 int ret;
4806 int i;
4807
4808 /*
4809 * The nowait semantics are used only for write paths, where we don't
4810 * use the tree mod log and sequence numbers.
4811 */
4812 if (time_seq)
4813 ASSERT(!path->nowait);
4814
4815 nritems = btrfs_header_nritems(path->nodes[0]);
4816 if (nritems == 0)
4817 return 1;
4818
4819 btrfs_item_key_to_cpu(path->nodes[0], &key, nritems - 1);
4820again:
4821 level = 1;
4822 next = NULL;
4823 btrfs_release_path(path);
4824
4825 path->keep_locks = 1;
4826
4827 if (time_seq) {
4828 ret = btrfs_search_old_slot(root, &key, path, time_seq);
4829 } else {
4830 if (path->need_commit_sem) {
4831 path->need_commit_sem = 0;
4832 need_commit_sem = true;
4833 if (path->nowait) {
4834 if (!down_read_trylock(&fs_info->commit_root_sem)) {
4835 ret = -EAGAIN;
4836 goto done;
4837 }
4838 } else {
4839 down_read(&fs_info->commit_root_sem);
4840 }
4841 }
4842 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4843 }
4844 path->keep_locks = 0;
4845
4846 if (ret < 0)
4847 goto done;
4848
4849 nritems = btrfs_header_nritems(path->nodes[0]);
4850 /*
4851 * by releasing the path above we dropped all our locks. A balance
4852 * could have added more items next to the key that used to be
4853 * at the very end of the block. So, check again here and
4854 * advance the path if there are now more items available.
4855 */
4856 if (nritems > 0 && path->slots[0] < nritems - 1) {
4857 if (ret == 0)
4858 path->slots[0]++;
4859 ret = 0;
4860 goto done;
4861 }
4862 /*
4863 * So the above check misses one case:
4864 * - after releasing the path above, someone has removed the item that
4865 * used to be at the very end of the block, and balance between leafs
4866 * gets another one with bigger key.offset to replace it.
4867 *
4868 * This one should be returned as well, or we can get leaf corruption
4869 * later(esp. in __btrfs_drop_extents()).
4870 *
4871 * And a bit more explanation about this check,
4872 * with ret > 0, the key isn't found, the path points to the slot
4873 * where it should be inserted, so the path->slots[0] item must be the
4874 * bigger one.
4875 */
4876 if (nritems > 0 && ret > 0 && path->slots[0] == nritems - 1) {
4877 ret = 0;
4878 goto done;
4879 }
4880
4881 while (level < BTRFS_MAX_LEVEL) {
4882 if (!path->nodes[level]) {
4883 ret = 1;
4884 goto done;
4885 }
4886
4887 slot = path->slots[level] + 1;
4888 c = path->nodes[level];
4889 if (slot >= btrfs_header_nritems(c)) {
4890 level++;
4891 if (level == BTRFS_MAX_LEVEL) {
4892 ret = 1;
4893 goto done;
4894 }
4895 continue;
4896 }
4897
4898
4899 /*
4900 * Our current level is where we're going to start from, and to
4901 * make sure lockdep doesn't complain we need to drop our locks
4902 * and nodes from 0 to our current level.
4903 */
4904 for (i = 0; i < level; i++) {
4905 if (path->locks[level]) {
4906 btrfs_tree_read_unlock(path->nodes[i]);
4907 path->locks[i] = 0;
4908 }
4909 free_extent_buffer(path->nodes[i]);
4910 path->nodes[i] = NULL;
4911 }
4912
4913 next = c;
4914 ret = read_block_for_search(root, path, &next, level,
4915 slot, &key);
4916 if (ret == -EAGAIN && !path->nowait)
4917 goto again;
4918
4919 if (ret < 0) {
4920 btrfs_release_path(path);
4921 goto done;
4922 }
4923
4924 if (!path->skip_locking) {
4925 ret = btrfs_try_tree_read_lock(next);
4926 if (!ret && path->nowait) {
4927 ret = -EAGAIN;
4928 goto done;
4929 }
4930 if (!ret && time_seq) {
4931 /*
4932 * If we don't get the lock, we may be racing
4933 * with push_leaf_left, holding that lock while
4934 * itself waiting for the leaf we've currently
4935 * locked. To solve this situation, we give up
4936 * on our lock and cycle.
4937 */
4938 free_extent_buffer(next);
4939 btrfs_release_path(path);
4940 cond_resched();
4941 goto again;
4942 }
4943 if (!ret)
4944 btrfs_tree_read_lock(next);
4945 }
4946 break;
4947 }
4948 path->slots[level] = slot;
4949 while (1) {
4950 level--;
4951 path->nodes[level] = next;
4952 path->slots[level] = 0;
4953 if (!path->skip_locking)
4954 path->locks[level] = BTRFS_READ_LOCK;
4955 if (!level)
4956 break;
4957
4958 ret = read_block_for_search(root, path, &next, level,
4959 0, &key);
4960 if (ret == -EAGAIN && !path->nowait)
4961 goto again;
4962
4963 if (ret < 0) {
4964 btrfs_release_path(path);
4965 goto done;
4966 }
4967
4968 if (!path->skip_locking) {
4969 if (path->nowait) {
4970 if (!btrfs_try_tree_read_lock(next)) {
4971 ret = -EAGAIN;
4972 goto done;
4973 }
4974 } else {
4975 btrfs_tree_read_lock(next);
4976 }
4977 }
4978 }
4979 ret = 0;
4980done:
4981 unlock_up(path, 0, 1, 0, NULL);
4982 if (need_commit_sem) {
4983 int ret2;
4984
4985 path->need_commit_sem = 1;
4986 ret2 = finish_need_commit_sem_search(path);
4987 up_read(&fs_info->commit_root_sem);
4988 if (ret2)
4989 ret = ret2;
4990 }
4991
4992 return ret;
4993}
4994
4995int btrfs_next_old_item(struct btrfs_root *root, struct btrfs_path *path, u64 time_seq)
4996{
4997 path->slots[0]++;
4998 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0]))
4999 return btrfs_next_old_leaf(root, path, time_seq);
5000 return 0;
5001}
5002
5003/*
5004 * this uses btrfs_prev_leaf to walk backwards in the tree, and keeps
5005 * searching until it gets past min_objectid or finds an item of 'type'
5006 *
5007 * returns 0 if something is found, 1 if nothing was found and < 0 on error
5008 */
5009int btrfs_previous_item(struct btrfs_root *root,
5010 struct btrfs_path *path, u64 min_objectid,
5011 int type)
5012{
5013 struct btrfs_key found_key;
5014 struct extent_buffer *leaf;
5015 u32 nritems;
5016 int ret;
5017
5018 while (1) {
5019 if (path->slots[0] == 0) {
5020 ret = btrfs_prev_leaf(root, path);
5021 if (ret != 0)
5022 return ret;
5023 } else {
5024 path->slots[0]--;
5025 }
5026 leaf = path->nodes[0];
5027 nritems = btrfs_header_nritems(leaf);
5028 if (nritems == 0)
5029 return 1;
5030 if (path->slots[0] == nritems)
5031 path->slots[0]--;
5032
5033 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
5034 if (found_key.objectid < min_objectid)
5035 break;
5036 if (found_key.type == type)
5037 return 0;
5038 if (found_key.objectid == min_objectid &&
5039 found_key.type < type)
5040 break;
5041 }
5042 return 1;
5043}
5044
5045/*
5046 * search in extent tree to find a previous Metadata/Data extent item with
5047 * min objecitd.
5048 *
5049 * returns 0 if something is found, 1 if nothing was found and < 0 on error
5050 */
5051int btrfs_previous_extent_item(struct btrfs_root *root,
5052 struct btrfs_path *path, u64 min_objectid)
5053{
5054 struct btrfs_key found_key;
5055 struct extent_buffer *leaf;
5056 u32 nritems;
5057 int ret;
5058
5059 while (1) {
5060 if (path->slots[0] == 0) {
5061 ret = btrfs_prev_leaf(root, path);
5062 if (ret != 0)
5063 return ret;
5064 } else {
5065 path->slots[0]--;
5066 }
5067 leaf = path->nodes[0];
5068 nritems = btrfs_header_nritems(leaf);
5069 if (nritems == 0)
5070 return 1;
5071 if (path->slots[0] == nritems)
5072 path->slots[0]--;
5073
5074 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
5075 if (found_key.objectid < min_objectid)
5076 break;
5077 if (found_key.type == BTRFS_EXTENT_ITEM_KEY ||
5078 found_key.type == BTRFS_METADATA_ITEM_KEY)
5079 return 0;
5080 if (found_key.objectid == min_objectid &&
5081 found_key.type < BTRFS_EXTENT_ITEM_KEY)
5082 break;
5083 }
5084 return 1;
5085}
5086
5087int __init btrfs_ctree_init(void)
5088{
5089 btrfs_path_cachep = KMEM_CACHE(btrfs_path, 0);
5090 if (!btrfs_path_cachep)
5091 return -ENOMEM;
5092 return 0;
5093}
5094
5095void __cold btrfs_ctree_exit(void)
5096{
5097 kmem_cache_destroy(btrfs_path_cachep);
5098}