1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (C) 2007 Oracle. All rights reserved. 4 */ 5 6 #ifndef BTRFS_CTREE_H 7 #define BTRFS_CTREE_H 8 9 #include <linux/mm.h> 10 #include <linux/sched/signal.h> 11 #include <linux/highmem.h> 12 #include <linux/fs.h> 13 #include <linux/rwsem.h> 14 #include <linux/semaphore.h> 15 #include <linux/completion.h> 16 #include <linux/backing-dev.h> 17 #include <linux/wait.h> 18 #include <linux/slab.h> 19 #include <trace/events/btrfs.h> 20 #include <asm/unaligned.h> 21 #include <linux/pagemap.h> 22 #include <linux/btrfs.h> 23 #include <linux/btrfs_tree.h> 24 #include <linux/workqueue.h> 25 #include <linux/security.h> 26 #include <linux/sizes.h> 27 #include <linux/dynamic_debug.h> 28 #include <linux/refcount.h> 29 #include <linux/crc32c.h> 30 #include <linux/iomap.h> 31 #include <linux/fscrypt.h> 32 #include "extent-io-tree.h" 33 #include "extent_io.h" 34 #include "extent_map.h" 35 #include "async-thread.h" 36 #include "block-rsv.h" 37 #include "locking.h" 38 #include "misc.h" 39 #include "fs.h" 40 41 struct btrfs_trans_handle; 42 struct btrfs_transaction; 43 struct btrfs_pending_snapshot; 44 struct btrfs_delayed_ref_root; 45 struct btrfs_space_info; 46 struct btrfs_block_group; 47 struct btrfs_ordered_sum; 48 struct btrfs_ref; 49 struct btrfs_bio; 50 struct btrfs_ioctl_encoded_io_args; 51 struct btrfs_device; 52 struct btrfs_fs_devices; 53 struct btrfs_balance_control; 54 struct btrfs_delayed_root; 55 struct reloc_control; 56 57 /* Read ahead values for struct btrfs_path.reada */ 58 enum { 59 READA_NONE, 60 READA_BACK, 61 READA_FORWARD, 62 /* 63 * Similar to READA_FORWARD but unlike it: 64 * 65 * 1) It will trigger readahead even for leaves that are not close to 66 * each other on disk; 67 * 2) It also triggers readahead for nodes; 68 * 3) During a search, even when a node or leaf is already in memory, it 69 * will still trigger readahead for other nodes and leaves that follow 70 * it. 71 * 72 * This is meant to be used only when we know we are iterating over the 73 * entire tree or a very large part of it. 74 */ 75 READA_FORWARD_ALWAYS, 76 }; 77 78 /* 79 * btrfs_paths remember the path taken from the root down to the leaf. 80 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point 81 * to any other levels that are present. 82 * 83 * The slots array records the index of the item or block pointer 84 * used while walking the tree. 85 */ 86 struct btrfs_path { 87 struct extent_buffer *nodes[BTRFS_MAX_LEVEL]; 88 int slots[BTRFS_MAX_LEVEL]; 89 /* if there is real range locking, this locks field will change */ 90 u8 locks[BTRFS_MAX_LEVEL]; 91 u8 reada; 92 /* keep some upper locks as we walk down */ 93 u8 lowest_level; 94 95 /* 96 * set by btrfs_split_item, tells search_slot to keep all locks 97 * and to force calls to keep space in the nodes 98 */ 99 unsigned int search_for_split:1; 100 unsigned int keep_locks:1; 101 unsigned int skip_locking:1; 102 unsigned int search_commit_root:1; 103 unsigned int need_commit_sem:1; 104 unsigned int skip_release_on_error:1; 105 /* 106 * Indicate that new item (btrfs_search_slot) is extending already 107 * existing item and ins_len contains only the data size and not item 108 * header (ie. sizeof(struct btrfs_item) is not included). 109 */ 110 unsigned int search_for_extension:1; 111 /* Stop search if any locks need to be taken (for read) */ 112 unsigned int nowait:1; 113 }; 114 115 /* 116 * The state of btrfs root 117 */ 118 enum { 119 /* 120 * btrfs_record_root_in_trans is a multi-step process, and it can race 121 * with the balancing code. But the race is very small, and only the 122 * first time the root is added to each transaction. So IN_TRANS_SETUP 123 * is used to tell us when more checks are required 124 */ 125 BTRFS_ROOT_IN_TRANS_SETUP, 126 127 /* 128 * Set if tree blocks of this root can be shared by other roots. 129 * Only subvolume trees and their reloc trees have this bit set. 130 * Conflicts with TRACK_DIRTY bit. 131 * 132 * This affects two things: 133 * 134 * - How balance works 135 * For shareable roots, we need to use reloc tree and do path 136 * replacement for balance, and need various pre/post hooks for 137 * snapshot creation to handle them. 138 * 139 * While for non-shareable trees, we just simply do a tree search 140 * with COW. 141 * 142 * - How dirty roots are tracked 143 * For shareable roots, btrfs_record_root_in_trans() is needed to 144 * track them, while non-subvolume roots have TRACK_DIRTY bit, they 145 * don't need to set this manually. 146 */ 147 BTRFS_ROOT_SHAREABLE, 148 BTRFS_ROOT_TRACK_DIRTY, 149 BTRFS_ROOT_IN_RADIX, 150 BTRFS_ROOT_ORPHAN_ITEM_INSERTED, 151 BTRFS_ROOT_DEFRAG_RUNNING, 152 BTRFS_ROOT_FORCE_COW, 153 BTRFS_ROOT_MULTI_LOG_TASKS, 154 BTRFS_ROOT_DIRTY, 155 BTRFS_ROOT_DELETING, 156 157 /* 158 * Reloc tree is orphan, only kept here for qgroup delayed subtree scan 159 * 160 * Set for the subvolume tree owning the reloc tree. 161 */ 162 BTRFS_ROOT_DEAD_RELOC_TREE, 163 /* Mark dead root stored on device whose cleanup needs to be resumed */ 164 BTRFS_ROOT_DEAD_TREE, 165 /* The root has a log tree. Used for subvolume roots and the tree root. */ 166 BTRFS_ROOT_HAS_LOG_TREE, 167 /* Qgroup flushing is in progress */ 168 BTRFS_ROOT_QGROUP_FLUSHING, 169 /* We started the orphan cleanup for this root. */ 170 BTRFS_ROOT_ORPHAN_CLEANUP, 171 /* This root has a drop operation that was started previously. */ 172 BTRFS_ROOT_UNFINISHED_DROP, 173 /* This reloc root needs to have its buffers lockdep class reset. */ 174 BTRFS_ROOT_RESET_LOCKDEP_CLASS, 175 }; 176 177 /* 178 * Record swapped tree blocks of a subvolume tree for delayed subtree trace 179 * code. For detail check comment in fs/btrfs/qgroup.c. 180 */ 181 struct btrfs_qgroup_swapped_blocks { 182 spinlock_t lock; 183 /* RM_EMPTY_ROOT() of above blocks[] */ 184 bool swapped; 185 struct rb_root blocks[BTRFS_MAX_LEVEL]; 186 }; 187 188 /* 189 * in ram representation of the tree. extent_root is used for all allocations 190 * and for the extent tree extent_root root. 191 */ 192 struct btrfs_root { 193 struct rb_node rb_node; 194 195 struct extent_buffer *node; 196 197 struct extent_buffer *commit_root; 198 struct btrfs_root *log_root; 199 struct btrfs_root *reloc_root; 200 201 unsigned long state; 202 struct btrfs_root_item root_item; 203 struct btrfs_key root_key; 204 struct btrfs_fs_info *fs_info; 205 struct extent_io_tree dirty_log_pages; 206 207 struct mutex objectid_mutex; 208 209 spinlock_t accounting_lock; 210 struct btrfs_block_rsv *block_rsv; 211 212 struct mutex log_mutex; 213 wait_queue_head_t log_writer_wait; 214 wait_queue_head_t log_commit_wait[2]; 215 struct list_head log_ctxs[2]; 216 /* Used only for log trees of subvolumes, not for the log root tree */ 217 atomic_t log_writers; 218 atomic_t log_commit[2]; 219 /* Used only for log trees of subvolumes, not for the log root tree */ 220 atomic_t log_batch; 221 int log_transid; 222 /* No matter the commit succeeds or not*/ 223 int log_transid_committed; 224 /* Just be updated when the commit succeeds. */ 225 int last_log_commit; 226 pid_t log_start_pid; 227 228 u64 last_trans; 229 230 u32 type; 231 232 u64 free_objectid; 233 234 struct btrfs_key defrag_progress; 235 struct btrfs_key defrag_max; 236 237 /* The dirty list is only used by non-shareable roots */ 238 struct list_head dirty_list; 239 240 struct list_head root_list; 241 242 spinlock_t log_extents_lock[2]; 243 struct list_head logged_list[2]; 244 245 spinlock_t inode_lock; 246 /* red-black tree that keeps track of in-memory inodes */ 247 struct rb_root inode_tree; 248 249 /* 250 * radix tree that keeps track of delayed nodes of every inode, 251 * protected by inode_lock 252 */ 253 struct radix_tree_root delayed_nodes_tree; 254 /* 255 * right now this just gets used so that a root has its own devid 256 * for stat. It may be used for more later 257 */ 258 dev_t anon_dev; 259 260 spinlock_t root_item_lock; 261 refcount_t refs; 262 263 struct mutex delalloc_mutex; 264 spinlock_t delalloc_lock; 265 /* 266 * all of the inodes that have delalloc bytes. It is possible for 267 * this list to be empty even when there is still dirty data=ordered 268 * extents waiting to finish IO. 269 */ 270 struct list_head delalloc_inodes; 271 struct list_head delalloc_root; 272 u64 nr_delalloc_inodes; 273 274 struct mutex ordered_extent_mutex; 275 /* 276 * this is used by the balancing code to wait for all the pending 277 * ordered extents 278 */ 279 spinlock_t ordered_extent_lock; 280 281 /* 282 * all of the data=ordered extents pending writeback 283 * these can span multiple transactions and basically include 284 * every dirty data page that isn't from nodatacow 285 */ 286 struct list_head ordered_extents; 287 struct list_head ordered_root; 288 u64 nr_ordered_extents; 289 290 /* 291 * Not empty if this subvolume root has gone through tree block swap 292 * (relocation) 293 * 294 * Will be used by reloc_control::dirty_subvol_roots. 295 */ 296 struct list_head reloc_dirty_list; 297 298 /* 299 * Number of currently running SEND ioctls to prevent 300 * manipulation with the read-only status via SUBVOL_SETFLAGS 301 */ 302 int send_in_progress; 303 /* 304 * Number of currently running deduplication operations that have a 305 * destination inode belonging to this root. Protected by the lock 306 * root_item_lock. 307 */ 308 int dedupe_in_progress; 309 /* For exclusion of snapshot creation and nocow writes */ 310 struct btrfs_drew_lock snapshot_lock; 311 312 atomic_t snapshot_force_cow; 313 314 /* For qgroup metadata reserved space */ 315 spinlock_t qgroup_meta_rsv_lock; 316 u64 qgroup_meta_rsv_pertrans; 317 u64 qgroup_meta_rsv_prealloc; 318 wait_queue_head_t qgroup_flush_wait; 319 320 /* Number of active swapfiles */ 321 atomic_t nr_swapfiles; 322 323 /* Record pairs of swapped blocks for qgroup */ 324 struct btrfs_qgroup_swapped_blocks swapped_blocks; 325 326 /* Used only by log trees, when logging csum items */ 327 struct extent_io_tree log_csum_range; 328 329 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 330 u64 alloc_bytenr; 331 #endif 332 333 #ifdef CONFIG_BTRFS_DEBUG 334 struct list_head leak_list; 335 #endif 336 }; 337 338 static inline bool btrfs_root_readonly(const struct btrfs_root *root) 339 { 340 /* Byte-swap the constant at compile time, root_item::flags is LE */ 341 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0; 342 } 343 344 static inline bool btrfs_root_dead(const struct btrfs_root *root) 345 { 346 /* Byte-swap the constant at compile time, root_item::flags is LE */ 347 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_DEAD)) != 0; 348 } 349 350 static inline u64 btrfs_root_id(const struct btrfs_root *root) 351 { 352 return root->root_key.objectid; 353 } 354 355 /* 356 * Structure that conveys information about an extent that is going to replace 357 * all the extents in a file range. 358 */ 359 struct btrfs_replace_extent_info { 360 u64 disk_offset; 361 u64 disk_len; 362 u64 data_offset; 363 u64 data_len; 364 u64 file_offset; 365 /* Pointer to a file extent item of type regular or prealloc. */ 366 char *extent_buf; 367 /* 368 * Set to true when attempting to replace a file range with a new extent 369 * described by this structure, set to false when attempting to clone an 370 * existing extent into a file range. 371 */ 372 bool is_new_extent; 373 /* Indicate if we should update the inode's mtime and ctime. */ 374 bool update_times; 375 /* Meaningful only if is_new_extent is true. */ 376 int qgroup_reserved; 377 /* 378 * Meaningful only if is_new_extent is true. 379 * Used to track how many extent items we have already inserted in a 380 * subvolume tree that refer to the extent described by this structure, 381 * so that we know when to create a new delayed ref or update an existing 382 * one. 383 */ 384 int insertions; 385 }; 386 387 /* Arguments for btrfs_drop_extents() */ 388 struct btrfs_drop_extents_args { 389 /* Input parameters */ 390 391 /* 392 * If NULL, btrfs_drop_extents() will allocate and free its own path. 393 * If 'replace_extent' is true, this must not be NULL. Also the path 394 * is always released except if 'replace_extent' is true and 395 * btrfs_drop_extents() sets 'extent_inserted' to true, in which case 396 * the path is kept locked. 397 */ 398 struct btrfs_path *path; 399 /* Start offset of the range to drop extents from */ 400 u64 start; 401 /* End (exclusive, last byte + 1) of the range to drop extents from */ 402 u64 end; 403 /* If true drop all the extent maps in the range */ 404 bool drop_cache; 405 /* 406 * If true it means we want to insert a new extent after dropping all 407 * the extents in the range. If this is true, the 'extent_item_size' 408 * parameter must be set as well and the 'extent_inserted' field will 409 * be set to true by btrfs_drop_extents() if it could insert the new 410 * extent. 411 * Note: when this is set to true the path must not be NULL. 412 */ 413 bool replace_extent; 414 /* 415 * Used if 'replace_extent' is true. Size of the file extent item to 416 * insert after dropping all existing extents in the range 417 */ 418 u32 extent_item_size; 419 420 /* Output parameters */ 421 422 /* 423 * Set to the minimum between the input parameter 'end' and the end 424 * (exclusive, last byte + 1) of the last dropped extent. This is always 425 * set even if btrfs_drop_extents() returns an error. 426 */ 427 u64 drop_end; 428 /* 429 * The number of allocated bytes found in the range. This can be smaller 430 * than the range's length when there are holes in the range. 431 */ 432 u64 bytes_found; 433 /* 434 * Only set if 'replace_extent' is true. Set to true if we were able 435 * to insert a replacement extent after dropping all extents in the 436 * range, otherwise set to false by btrfs_drop_extents(). 437 * Also, if btrfs_drop_extents() has set this to true it means it 438 * returned with the path locked, otherwise if it has set this to 439 * false it has returned with the path released. 440 */ 441 bool extent_inserted; 442 }; 443 444 struct btrfs_file_private { 445 void *filldir_buf; 446 struct extent_state *llseek_cached_state; 447 }; 448 449 static inline u32 BTRFS_LEAF_DATA_SIZE(const struct btrfs_fs_info *info) 450 { 451 return info->nodesize - sizeof(struct btrfs_header); 452 } 453 454 static inline u32 BTRFS_MAX_ITEM_SIZE(const struct btrfs_fs_info *info) 455 { 456 return BTRFS_LEAF_DATA_SIZE(info) - sizeof(struct btrfs_item); 457 } 458 459 static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info) 460 { 461 return BTRFS_LEAF_DATA_SIZE(info) / sizeof(struct btrfs_key_ptr); 462 } 463 464 static inline u32 BTRFS_MAX_XATTR_SIZE(const struct btrfs_fs_info *info) 465 { 466 return BTRFS_MAX_ITEM_SIZE(info) - sizeof(struct btrfs_dir_item); 467 } 468 469 #define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \ 470 ((bytes) >> (fs_info)->sectorsize_bits) 471 472 static inline u32 btrfs_crc32c(u32 crc, const void *address, unsigned length) 473 { 474 return crc32c(crc, address, length); 475 } 476 477 static inline void btrfs_crc32c_final(u32 crc, u8 *result) 478 { 479 put_unaligned_le32(~crc, result); 480 } 481 482 static inline u64 btrfs_name_hash(const char *name, int len) 483 { 484 return crc32c((u32)~1, name, len); 485 } 486 487 /* 488 * Figure the key offset of an extended inode ref 489 */ 490 static inline u64 btrfs_extref_hash(u64 parent_objectid, const char *name, 491 int len) 492 { 493 return (u64) crc32c(parent_objectid, name, len); 494 } 495 496 static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping) 497 { 498 return mapping_gfp_constraint(mapping, ~__GFP_FS); 499 } 500 501 int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info, 502 u64 start, u64 end); 503 int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr, 504 u64 num_bytes, u64 *actual_bytes); 505 int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range); 506 507 /* ctree.c */ 508 int __init btrfs_ctree_init(void); 509 void __cold btrfs_ctree_exit(void); 510 511 int btrfs_bin_search(struct extent_buffer *eb, int first_slot, 512 const struct btrfs_key *key, int *slot); 513 514 int __pure btrfs_comp_cpu_keys(const struct btrfs_key *k1, const struct btrfs_key *k2); 515 int btrfs_previous_item(struct btrfs_root *root, 516 struct btrfs_path *path, u64 min_objectid, 517 int type); 518 int btrfs_previous_extent_item(struct btrfs_root *root, 519 struct btrfs_path *path, u64 min_objectid); 520 void btrfs_set_item_key_safe(struct btrfs_fs_info *fs_info, 521 struct btrfs_path *path, 522 const struct btrfs_key *new_key); 523 struct extent_buffer *btrfs_root_node(struct btrfs_root *root); 524 int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path, 525 struct btrfs_key *key, int lowest_level, 526 u64 min_trans); 527 int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key, 528 struct btrfs_path *path, 529 u64 min_trans); 530 struct extent_buffer *btrfs_read_node_slot(struct extent_buffer *parent, 531 int slot); 532 533 int btrfs_cow_block(struct btrfs_trans_handle *trans, 534 struct btrfs_root *root, struct extent_buffer *buf, 535 struct extent_buffer *parent, int parent_slot, 536 struct extent_buffer **cow_ret, 537 enum btrfs_lock_nesting nest); 538 int btrfs_copy_root(struct btrfs_trans_handle *trans, 539 struct btrfs_root *root, 540 struct extent_buffer *buf, 541 struct extent_buffer **cow_ret, u64 new_root_objectid); 542 int btrfs_block_can_be_shared(struct btrfs_root *root, 543 struct extent_buffer *buf); 544 void btrfs_extend_item(struct btrfs_path *path, u32 data_size); 545 void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end); 546 int btrfs_split_item(struct btrfs_trans_handle *trans, 547 struct btrfs_root *root, 548 struct btrfs_path *path, 549 const struct btrfs_key *new_key, 550 unsigned long split_offset); 551 int btrfs_duplicate_item(struct btrfs_trans_handle *trans, 552 struct btrfs_root *root, 553 struct btrfs_path *path, 554 const struct btrfs_key *new_key); 555 int btrfs_find_item(struct btrfs_root *fs_root, struct btrfs_path *path, 556 u64 inum, u64 ioff, u8 key_type, struct btrfs_key *found_key); 557 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root, 558 const struct btrfs_key *key, struct btrfs_path *p, 559 int ins_len, int cow); 560 int btrfs_search_old_slot(struct btrfs_root *root, const struct btrfs_key *key, 561 struct btrfs_path *p, u64 time_seq); 562 int btrfs_search_slot_for_read(struct btrfs_root *root, 563 const struct btrfs_key *key, 564 struct btrfs_path *p, int find_higher, 565 int return_any); 566 int btrfs_realloc_node(struct btrfs_trans_handle *trans, 567 struct btrfs_root *root, struct extent_buffer *parent, 568 int start_slot, u64 *last_ret, 569 struct btrfs_key *progress); 570 void btrfs_release_path(struct btrfs_path *p); 571 struct btrfs_path *btrfs_alloc_path(void); 572 void btrfs_free_path(struct btrfs_path *p); 573 574 int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 575 struct btrfs_path *path, int slot, int nr); 576 static inline int btrfs_del_item(struct btrfs_trans_handle *trans, 577 struct btrfs_root *root, 578 struct btrfs_path *path) 579 { 580 return btrfs_del_items(trans, root, path, path->slots[0], 1); 581 } 582 583 /* 584 * Describes a batch of items to insert in a btree. This is used by 585 * btrfs_insert_empty_items(). 586 */ 587 struct btrfs_item_batch { 588 /* 589 * Pointer to an array containing the keys of the items to insert (in 590 * sorted order). 591 */ 592 const struct btrfs_key *keys; 593 /* Pointer to an array containing the data size for each item to insert. */ 594 const u32 *data_sizes; 595 /* 596 * The sum of data sizes for all items. The caller can compute this while 597 * setting up the data_sizes array, so it ends up being more efficient 598 * than having btrfs_insert_empty_items() or setup_item_for_insert() 599 * doing it, as it would avoid an extra loop over a potentially large 600 * array, and in the case of setup_item_for_insert(), we would be doing 601 * it while holding a write lock on a leaf and often on upper level nodes 602 * too, unnecessarily increasing the size of a critical section. 603 */ 604 u32 total_data_size; 605 /* Size of the keys and data_sizes arrays (number of items in the batch). */ 606 int nr; 607 }; 608 609 void btrfs_setup_item_for_insert(struct btrfs_root *root, 610 struct btrfs_path *path, 611 const struct btrfs_key *key, 612 u32 data_size); 613 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, 614 const struct btrfs_key *key, void *data, u32 data_size); 615 int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, 616 struct btrfs_root *root, 617 struct btrfs_path *path, 618 const struct btrfs_item_batch *batch); 619 620 static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, 621 struct btrfs_root *root, 622 struct btrfs_path *path, 623 const struct btrfs_key *key, 624 u32 data_size) 625 { 626 struct btrfs_item_batch batch; 627 628 batch.keys = key; 629 batch.data_sizes = &data_size; 630 batch.total_data_size = data_size; 631 batch.nr = 1; 632 633 return btrfs_insert_empty_items(trans, root, path, &batch); 634 } 635 636 int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path); 637 int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path, 638 u64 time_seq); 639 640 int btrfs_search_backwards(struct btrfs_root *root, struct btrfs_key *key, 641 struct btrfs_path *path); 642 643 int btrfs_get_next_valid_item(struct btrfs_root *root, struct btrfs_key *key, 644 struct btrfs_path *path); 645 646 /* 647 * Search in @root for a given @key, and store the slot found in @found_key. 648 * 649 * @root: The root node of the tree. 650 * @key: The key we are looking for. 651 * @found_key: Will hold the found item. 652 * @path: Holds the current slot/leaf. 653 * @iter_ret: Contains the value returned from btrfs_search_slot or 654 * btrfs_get_next_valid_item, whichever was executed last. 655 * 656 * The @iter_ret is an output variable that will contain the return value of 657 * btrfs_search_slot, if it encountered an error, or the value returned from 658 * btrfs_get_next_valid_item otherwise. That return value can be 0, if a valid 659 * slot was found, 1 if there were no more leaves, and <0 if there was an error. 660 * 661 * It's recommended to use a separate variable for iter_ret and then use it to 662 * set the function return value so there's no confusion of the 0/1/errno 663 * values stemming from btrfs_search_slot. 664 */ 665 #define btrfs_for_each_slot(root, key, found_key, path, iter_ret) \ 666 for (iter_ret = btrfs_search_slot(NULL, (root), (key), (path), 0, 0); \ 667 (iter_ret) >= 0 && \ 668 (iter_ret = btrfs_get_next_valid_item((root), (found_key), (path))) == 0; \ 669 (path)->slots[0]++ \ 670 ) 671 672 int btrfs_next_old_item(struct btrfs_root *root, struct btrfs_path *path, u64 time_seq); 673 674 /* 675 * Search the tree again to find a leaf with greater keys. 676 * 677 * Returns 0 if it found something or 1 if there are no greater leaves. 678 * Returns < 0 on error. 679 */ 680 static inline int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path) 681 { 682 return btrfs_next_old_leaf(root, path, 0); 683 } 684 685 static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p) 686 { 687 return btrfs_next_old_item(root, p, 0); 688 } 689 int btrfs_leaf_free_space(struct extent_buffer *leaf); 690 691 static inline int is_fstree(u64 rootid) 692 { 693 if (rootid == BTRFS_FS_TREE_OBJECTID || 694 ((s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID && 695 !btrfs_qgroup_level(rootid))) 696 return 1; 697 return 0; 698 } 699 700 static inline bool btrfs_is_data_reloc_root(const struct btrfs_root *root) 701 { 702 return root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID; 703 } 704 705 int btrfs_super_csum_size(const struct btrfs_super_block *s); 706 const char *btrfs_super_csum_name(u16 csum_type); 707 const char *btrfs_super_csum_driver(u16 csum_type); 708 size_t __attribute_const__ btrfs_get_num_csums(void); 709 710 /* 711 * We use page status Private2 to indicate there is an ordered extent with 712 * unfinished IO. 713 * 714 * Rename the Private2 accessors to Ordered, to improve readability. 715 */ 716 #define PageOrdered(page) PagePrivate2(page) 717 #define SetPageOrdered(page) SetPagePrivate2(page) 718 #define ClearPageOrdered(page) ClearPagePrivate2(page) 719 #define folio_test_ordered(folio) folio_test_private_2(folio) 720 #define folio_set_ordered(folio) folio_set_private_2(folio) 721 #define folio_clear_ordered(folio) folio_clear_private_2(folio) 722 723 #endif 724