1 /* SPDX-License-Identifier: GPL-2.0 */
3 * Copyright (C) 2007 Oracle. All rights reserved.
9 #include <linux/pagemap.h>
12 #include "accessors.h"
14 struct btrfs_trans_handle
;
15 struct btrfs_transaction
;
16 struct btrfs_pending_snapshot
;
17 struct btrfs_delayed_ref_root
;
18 struct btrfs_space_info
;
19 struct btrfs_block_group
;
20 struct btrfs_ordered_sum
;
23 struct btrfs_ioctl_encoded_io_args
;
25 struct btrfs_fs_devices
;
26 struct btrfs_balance_control
;
27 struct btrfs_delayed_root
;
30 /* Read ahead values for struct btrfs_path.reada */
36 * Similar to READA_FORWARD but unlike it:
38 * 1) It will trigger readahead even for leaves that are not close to
40 * 2) It also triggers readahead for nodes;
41 * 3) During a search, even when a node or leaf is already in memory, it
42 * will still trigger readahead for other nodes and leaves that follow
45 * This is meant to be used only when we know we are iterating over the
46 * entire tree or a very large part of it.
52 * btrfs_paths remember the path taken from the root down to the leaf.
53 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
54 * to any other levels that are present.
56 * The slots array records the index of the item or block pointer
57 * used while walking the tree.
60 struct extent_buffer
*nodes
[BTRFS_MAX_LEVEL
];
61 int slots
[BTRFS_MAX_LEVEL
];
62 /* if there is real range locking, this locks field will change */
63 u8 locks
[BTRFS_MAX_LEVEL
];
65 /* keep some upper locks as we walk down */
69 * set by btrfs_split_item, tells search_slot to keep all locks
70 * and to force calls to keep space in the nodes
72 unsigned int search_for_split
:1;
73 unsigned int keep_locks
:1;
74 unsigned int skip_locking
:1;
75 unsigned int search_commit_root
:1;
76 unsigned int need_commit_sem
:1;
77 unsigned int skip_release_on_error
:1;
79 * Indicate that new item (btrfs_search_slot) is extending already
80 * existing item and ins_len contains only the data size and not item
81 * header (ie. sizeof(struct btrfs_item) is not included).
83 unsigned int search_for_extension
:1;
84 /* Stop search if any locks need to be taken (for read) */
85 unsigned int nowait
:1;
89 * The state of btrfs root
93 * btrfs_record_root_in_trans is a multi-step process, and it can race
94 * with the balancing code. But the race is very small, and only the
95 * first time the root is added to each transaction. So IN_TRANS_SETUP
96 * is used to tell us when more checks are required
98 BTRFS_ROOT_IN_TRANS_SETUP
,
101 * Set if tree blocks of this root can be shared by other roots.
102 * Only subvolume trees and their reloc trees have this bit set.
103 * Conflicts with TRACK_DIRTY bit.
105 * This affects two things:
107 * - How balance works
108 * For shareable roots, we need to use reloc tree and do path
109 * replacement for balance, and need various pre/post hooks for
110 * snapshot creation to handle them.
112 * While for non-shareable trees, we just simply do a tree search
115 * - How dirty roots are tracked
116 * For shareable roots, btrfs_record_root_in_trans() is needed to
117 * track them, while non-subvolume roots have TRACK_DIRTY bit, they
118 * don't need to set this manually.
120 BTRFS_ROOT_SHAREABLE
,
121 BTRFS_ROOT_TRACK_DIRTY
,
123 BTRFS_ROOT_ORPHAN_ITEM_INSERTED
,
124 BTRFS_ROOT_DEFRAG_RUNNING
,
125 BTRFS_ROOT_FORCE_COW
,
126 BTRFS_ROOT_MULTI_LOG_TASKS
,
131 * Reloc tree is orphan, only kept here for qgroup delayed subtree scan
133 * Set for the subvolume tree owning the reloc tree.
135 BTRFS_ROOT_DEAD_RELOC_TREE
,
136 /* Mark dead root stored on device whose cleanup needs to be resumed */
137 BTRFS_ROOT_DEAD_TREE
,
138 /* The root has a log tree. Used for subvolume roots and the tree root. */
139 BTRFS_ROOT_HAS_LOG_TREE
,
140 /* Qgroup flushing is in progress */
141 BTRFS_ROOT_QGROUP_FLUSHING
,
142 /* We started the orphan cleanup for this root. */
143 BTRFS_ROOT_ORPHAN_CLEANUP
,
144 /* This root has a drop operation that was started previously. */
145 BTRFS_ROOT_UNFINISHED_DROP
,
146 /* This reloc root needs to have its buffers lockdep class reset. */
147 BTRFS_ROOT_RESET_LOCKDEP_CLASS
,
151 * Record swapped tree blocks of a subvolume tree for delayed subtree trace
152 * code. For detail check comment in fs/btrfs/qgroup.c.
154 struct btrfs_qgroup_swapped_blocks
{
156 /* RM_EMPTY_ROOT() of above blocks[] */
158 struct rb_root blocks
[BTRFS_MAX_LEVEL
];
162 * in ram representation of the tree. extent_root is used for all allocations
163 * and for the extent tree extent_root root.
166 struct rb_node rb_node
;
168 struct extent_buffer
*node
;
170 struct extent_buffer
*commit_root
;
171 struct btrfs_root
*log_root
;
172 struct btrfs_root
*reloc_root
;
175 struct btrfs_root_item root_item
;
176 struct btrfs_key root_key
;
177 struct btrfs_fs_info
*fs_info
;
178 struct extent_io_tree dirty_log_pages
;
180 struct mutex objectid_mutex
;
182 spinlock_t accounting_lock
;
183 struct btrfs_block_rsv
*block_rsv
;
185 struct mutex log_mutex
;
186 wait_queue_head_t log_writer_wait
;
187 wait_queue_head_t log_commit_wait
[2];
188 struct list_head log_ctxs
[2];
189 /* Used only for log trees of subvolumes, not for the log root tree */
190 atomic_t log_writers
;
191 atomic_t log_commit
[2];
192 /* Used only for log trees of subvolumes, not for the log root tree */
195 * Protected by the 'log_mutex' lock but can be read without holding
196 * that lock to avoid unnecessary lock contention, in which case it
197 * should be read using btrfs_get_root_log_transid() except if it's a
198 * log tree in which case it can be directly accessed. Updates to this
199 * field should always use btrfs_set_root_log_transid(), except for log
200 * trees where the field can be updated directly.
203 /* No matter the commit succeeds or not*/
204 int log_transid_committed
;
206 * Just be updated when the commit succeeds. Use
207 * btrfs_get_root_last_log_commit() and btrfs_set_root_last_log_commit()
208 * to access this field.
219 struct btrfs_key defrag_progress
;
220 struct btrfs_key defrag_max
;
222 /* The dirty list is only used by non-shareable roots */
223 struct list_head dirty_list
;
225 struct list_head root_list
;
227 spinlock_t inode_lock
;
228 /* red-black tree that keeps track of in-memory inodes */
229 struct rb_root inode_tree
;
232 * radix tree that keeps track of delayed nodes of every inode,
233 * protected by inode_lock
235 struct radix_tree_root delayed_nodes_tree
;
237 * right now this just gets used so that a root has its own devid
238 * for stat. It may be used for more later
242 spinlock_t root_item_lock
;
245 struct mutex delalloc_mutex
;
246 spinlock_t delalloc_lock
;
248 * all of the inodes that have delalloc bytes. It is possible for
249 * this list to be empty even when there is still dirty data=ordered
250 * extents waiting to finish IO.
252 struct list_head delalloc_inodes
;
253 struct list_head delalloc_root
;
254 u64 nr_delalloc_inodes
;
256 struct mutex ordered_extent_mutex
;
258 * this is used by the balancing code to wait for all the pending
261 spinlock_t ordered_extent_lock
;
264 * all of the data=ordered extents pending writeback
265 * these can span multiple transactions and basically include
266 * every dirty data page that isn't from nodatacow
268 struct list_head ordered_extents
;
269 struct list_head ordered_root
;
270 u64 nr_ordered_extents
;
273 * Not empty if this subvolume root has gone through tree block swap
276 * Will be used by reloc_control::dirty_subvol_roots.
278 struct list_head reloc_dirty_list
;
281 * Number of currently running SEND ioctls to prevent
282 * manipulation with the read-only status via SUBVOL_SETFLAGS
284 int send_in_progress
;
286 * Number of currently running deduplication operations that have a
287 * destination inode belonging to this root. Protected by the lock
290 int dedupe_in_progress
;
291 /* For exclusion of snapshot creation and nocow writes */
292 struct btrfs_drew_lock snapshot_lock
;
294 atomic_t snapshot_force_cow
;
296 /* For qgroup metadata reserved space */
297 spinlock_t qgroup_meta_rsv_lock
;
298 u64 qgroup_meta_rsv_pertrans
;
299 u64 qgroup_meta_rsv_prealloc
;
300 wait_queue_head_t qgroup_flush_wait
;
302 /* Number of active swapfiles */
303 atomic_t nr_swapfiles
;
305 /* Record pairs of swapped blocks for qgroup */
306 struct btrfs_qgroup_swapped_blocks swapped_blocks
;
308 /* Used only by log trees, when logging csum items */
309 struct extent_io_tree log_csum_range
;
311 /* Used in simple quotas, track root during relocation. */
312 u64 relocation_src_root
;
314 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
318 #ifdef CONFIG_BTRFS_DEBUG
319 struct list_head leak_list
;
323 static inline bool btrfs_root_readonly(const struct btrfs_root
*root
)
325 /* Byte-swap the constant at compile time, root_item::flags is LE */
326 return (root
->root_item
.flags
& cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY
)) != 0;
329 static inline bool btrfs_root_dead(const struct btrfs_root
*root
)
331 /* Byte-swap the constant at compile time, root_item::flags is LE */
332 return (root
->root_item
.flags
& cpu_to_le64(BTRFS_ROOT_SUBVOL_DEAD
)) != 0;
335 static inline u64
btrfs_root_id(const struct btrfs_root
*root
)
337 return root
->root_key
.objectid
;
340 static inline int btrfs_get_root_log_transid(const struct btrfs_root
*root
)
342 return READ_ONCE(root
->log_transid
);
345 static inline void btrfs_set_root_log_transid(struct btrfs_root
*root
, int log_transid
)
347 WRITE_ONCE(root
->log_transid
, log_transid
);
350 static inline int btrfs_get_root_last_log_commit(const struct btrfs_root
*root
)
352 return READ_ONCE(root
->last_log_commit
);
355 static inline void btrfs_set_root_last_log_commit(struct btrfs_root
*root
, int commit_id
)
357 WRITE_ONCE(root
->last_log_commit
, commit_id
);
361 * Structure that conveys information about an extent that is going to replace
362 * all the extents in a file range.
364 struct btrfs_replace_extent_info
{
370 /* Pointer to a file extent item of type regular or prealloc. */
373 * Set to true when attempting to replace a file range with a new extent
374 * described by this structure, set to false when attempting to clone an
375 * existing extent into a file range.
378 /* Indicate if we should update the inode's mtime and ctime. */
380 /* Meaningful only if is_new_extent is true. */
383 * Meaningful only if is_new_extent is true.
384 * Used to track how many extent items we have already inserted in a
385 * subvolume tree that refer to the extent described by this structure,
386 * so that we know when to create a new delayed ref or update an existing
392 /* Arguments for btrfs_drop_extents() */
393 struct btrfs_drop_extents_args
{
394 /* Input parameters */
397 * If NULL, btrfs_drop_extents() will allocate and free its own path.
398 * If 'replace_extent' is true, this must not be NULL. Also the path
399 * is always released except if 'replace_extent' is true and
400 * btrfs_drop_extents() sets 'extent_inserted' to true, in which case
401 * the path is kept locked.
403 struct btrfs_path
*path
;
404 /* Start offset of the range to drop extents from */
406 /* End (exclusive, last byte + 1) of the range to drop extents from */
408 /* If true drop all the extent maps in the range */
411 * If true it means we want to insert a new extent after dropping all
412 * the extents in the range. If this is true, the 'extent_item_size'
413 * parameter must be set as well and the 'extent_inserted' field will
414 * be set to true by btrfs_drop_extents() if it could insert the new
416 * Note: when this is set to true the path must not be NULL.
420 * Used if 'replace_extent' is true. Size of the file extent item to
421 * insert after dropping all existing extents in the range
423 u32 extent_item_size
;
425 /* Output parameters */
428 * Set to the minimum between the input parameter 'end' and the end
429 * (exclusive, last byte + 1) of the last dropped extent. This is always
430 * set even if btrfs_drop_extents() returns an error.
434 * The number of allocated bytes found in the range. This can be smaller
435 * than the range's length when there are holes in the range.
439 * Only set if 'replace_extent' is true. Set to true if we were able
440 * to insert a replacement extent after dropping all extents in the
441 * range, otherwise set to false by btrfs_drop_extents().
442 * Also, if btrfs_drop_extents() has set this to true it means it
443 * returned with the path locked, otherwise if it has set this to
444 * false it has returned with the path released.
446 bool extent_inserted
;
449 struct btrfs_file_private
{
452 struct extent_state
*llseek_cached_state
;
455 static inline u32
BTRFS_LEAF_DATA_SIZE(const struct btrfs_fs_info
*info
)
457 return info
->nodesize
- sizeof(struct btrfs_header
);
460 static inline u32
BTRFS_MAX_ITEM_SIZE(const struct btrfs_fs_info
*info
)
462 return BTRFS_LEAF_DATA_SIZE(info
) - sizeof(struct btrfs_item
);
465 static inline u32
BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info
*info
)
467 return BTRFS_LEAF_DATA_SIZE(info
) / sizeof(struct btrfs_key_ptr
);
470 static inline u32
BTRFS_MAX_XATTR_SIZE(const struct btrfs_fs_info
*info
)
472 return BTRFS_MAX_ITEM_SIZE(info
) - sizeof(struct btrfs_dir_item
);
475 #define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \
476 ((bytes) >> (fs_info)->sectorsize_bits)
478 static inline gfp_t
btrfs_alloc_write_mask(struct address_space
*mapping
)
480 return mapping_gfp_constraint(mapping
, ~__GFP_FS
);
483 int btrfs_error_unpin_extent_range(struct btrfs_fs_info
*fs_info
,
485 int btrfs_discard_extent(struct btrfs_fs_info
*fs_info
, u64 bytenr
,
486 u64 num_bytes
, u64
*actual_bytes
);
487 int btrfs_trim_fs(struct btrfs_fs_info
*fs_info
, struct fstrim_range
*range
);
490 int __init
btrfs_ctree_init(void);
491 void __cold
btrfs_ctree_exit(void);
493 int btrfs_bin_search(struct extent_buffer
*eb
, int first_slot
,
494 const struct btrfs_key
*key
, int *slot
);
496 int __pure
btrfs_comp_cpu_keys(const struct btrfs_key
*k1
, const struct btrfs_key
*k2
);
498 #ifdef __LITTLE_ENDIAN
501 * Compare two keys, on little-endian the disk order is same as CPU order and
502 * we can avoid the conversion.
504 static inline int btrfs_comp_keys(const struct btrfs_disk_key
*disk_key
,
505 const struct btrfs_key
*k2
)
507 const struct btrfs_key
*k1
= (const struct btrfs_key
*)disk_key
;
509 return btrfs_comp_cpu_keys(k1
, k2
);
514 /* Compare two keys in a memcmp fashion. */
515 static inline int btrfs_comp_keys(const struct btrfs_disk_key
*disk
,
516 const struct btrfs_key
*k2
)
520 btrfs_disk_key_to_cpu(&k1
, disk
);
522 return btrfs_comp_cpu_keys(&k1
, k2
);
527 int btrfs_previous_item(struct btrfs_root
*root
,
528 struct btrfs_path
*path
, u64 min_objectid
,
530 int btrfs_previous_extent_item(struct btrfs_root
*root
,
531 struct btrfs_path
*path
, u64 min_objectid
);
532 void btrfs_set_item_key_safe(struct btrfs_trans_handle
*trans
,
533 struct btrfs_path
*path
,
534 const struct btrfs_key
*new_key
);
535 struct extent_buffer
*btrfs_root_node(struct btrfs_root
*root
);
536 int btrfs_find_next_key(struct btrfs_root
*root
, struct btrfs_path
*path
,
537 struct btrfs_key
*key
, int lowest_level
,
539 int btrfs_search_forward(struct btrfs_root
*root
, struct btrfs_key
*min_key
,
540 struct btrfs_path
*path
,
542 struct extent_buffer
*btrfs_read_node_slot(struct extent_buffer
*parent
,
545 int btrfs_cow_block(struct btrfs_trans_handle
*trans
,
546 struct btrfs_root
*root
, struct extent_buffer
*buf
,
547 struct extent_buffer
*parent
, int parent_slot
,
548 struct extent_buffer
**cow_ret
,
549 enum btrfs_lock_nesting nest
);
550 int btrfs_force_cow_block(struct btrfs_trans_handle
*trans
,
551 struct btrfs_root
*root
,
552 struct extent_buffer
*buf
,
553 struct extent_buffer
*parent
, int parent_slot
,
554 struct extent_buffer
**cow_ret
,
555 u64 search_start
, u64 empty_size
,
556 enum btrfs_lock_nesting nest
);
557 int btrfs_copy_root(struct btrfs_trans_handle
*trans
,
558 struct btrfs_root
*root
,
559 struct extent_buffer
*buf
,
560 struct extent_buffer
**cow_ret
, u64 new_root_objectid
);
561 int btrfs_block_can_be_shared(struct btrfs_trans_handle
*trans
,
562 struct btrfs_root
*root
,
563 struct extent_buffer
*buf
);
564 int btrfs_del_ptr(struct btrfs_trans_handle
*trans
, struct btrfs_root
*root
,
565 struct btrfs_path
*path
, int level
, int slot
);
566 void btrfs_extend_item(struct btrfs_trans_handle
*trans
,
567 struct btrfs_path
*path
, u32 data_size
);
568 void btrfs_truncate_item(struct btrfs_trans_handle
*trans
,
569 struct btrfs_path
*path
, u32 new_size
, int from_end
);
570 int btrfs_split_item(struct btrfs_trans_handle
*trans
,
571 struct btrfs_root
*root
,
572 struct btrfs_path
*path
,
573 const struct btrfs_key
*new_key
,
574 unsigned long split_offset
);
575 int btrfs_duplicate_item(struct btrfs_trans_handle
*trans
,
576 struct btrfs_root
*root
,
577 struct btrfs_path
*path
,
578 const struct btrfs_key
*new_key
);
579 int btrfs_find_item(struct btrfs_root
*fs_root
, struct btrfs_path
*path
,
580 u64 inum
, u64 ioff
, u8 key_type
, struct btrfs_key
*found_key
);
581 int btrfs_search_slot(struct btrfs_trans_handle
*trans
, struct btrfs_root
*root
,
582 const struct btrfs_key
*key
, struct btrfs_path
*p
,
583 int ins_len
, int cow
);
584 int btrfs_search_old_slot(struct btrfs_root
*root
, const struct btrfs_key
*key
,
585 struct btrfs_path
*p
, u64 time_seq
);
586 int btrfs_search_slot_for_read(struct btrfs_root
*root
,
587 const struct btrfs_key
*key
,
588 struct btrfs_path
*p
, int find_higher
,
590 void btrfs_release_path(struct btrfs_path
*p
);
591 struct btrfs_path
*btrfs_alloc_path(void);
592 void btrfs_free_path(struct btrfs_path
*p
);
594 int btrfs_del_items(struct btrfs_trans_handle
*trans
, struct btrfs_root
*root
,
595 struct btrfs_path
*path
, int slot
, int nr
);
596 static inline int btrfs_del_item(struct btrfs_trans_handle
*trans
,
597 struct btrfs_root
*root
,
598 struct btrfs_path
*path
)
600 return btrfs_del_items(trans
, root
, path
, path
->slots
[0], 1);
604 * Describes a batch of items to insert in a btree. This is used by
605 * btrfs_insert_empty_items().
607 struct btrfs_item_batch
{
609 * Pointer to an array containing the keys of the items to insert (in
612 const struct btrfs_key
*keys
;
613 /* Pointer to an array containing the data size for each item to insert. */
614 const u32
*data_sizes
;
616 * The sum of data sizes for all items. The caller can compute this while
617 * setting up the data_sizes array, so it ends up being more efficient
618 * than having btrfs_insert_empty_items() or setup_item_for_insert()
619 * doing it, as it would avoid an extra loop over a potentially large
620 * array, and in the case of setup_item_for_insert(), we would be doing
621 * it while holding a write lock on a leaf and often on upper level nodes
622 * too, unnecessarily increasing the size of a critical section.
625 /* Size of the keys and data_sizes arrays (number of items in the batch). */
629 void btrfs_setup_item_for_insert(struct btrfs_trans_handle
*trans
,
630 struct btrfs_root
*root
,
631 struct btrfs_path
*path
,
632 const struct btrfs_key
*key
,
634 int btrfs_insert_item(struct btrfs_trans_handle
*trans
, struct btrfs_root
*root
,
635 const struct btrfs_key
*key
, void *data
, u32 data_size
);
636 int btrfs_insert_empty_items(struct btrfs_trans_handle
*trans
,
637 struct btrfs_root
*root
,
638 struct btrfs_path
*path
,
639 const struct btrfs_item_batch
*batch
);
641 static inline int btrfs_insert_empty_item(struct btrfs_trans_handle
*trans
,
642 struct btrfs_root
*root
,
643 struct btrfs_path
*path
,
644 const struct btrfs_key
*key
,
647 struct btrfs_item_batch batch
;
650 batch
.data_sizes
= &data_size
;
651 batch
.total_data_size
= data_size
;
654 return btrfs_insert_empty_items(trans
, root
, path
, &batch
);
657 int btrfs_next_old_leaf(struct btrfs_root
*root
, struct btrfs_path
*path
,
660 int btrfs_search_backwards(struct btrfs_root
*root
, struct btrfs_key
*key
,
661 struct btrfs_path
*path
);
663 int btrfs_get_next_valid_item(struct btrfs_root
*root
, struct btrfs_key
*key
,
664 struct btrfs_path
*path
);
667 * Search in @root for a given @key, and store the slot found in @found_key.
669 * @root: The root node of the tree.
670 * @key: The key we are looking for.
671 * @found_key: Will hold the found item.
672 * @path: Holds the current slot/leaf.
673 * @iter_ret: Contains the value returned from btrfs_search_slot or
674 * btrfs_get_next_valid_item, whichever was executed last.
676 * The @iter_ret is an output variable that will contain the return value of
677 * btrfs_search_slot, if it encountered an error, or the value returned from
678 * btrfs_get_next_valid_item otherwise. That return value can be 0, if a valid
679 * slot was found, 1 if there were no more leaves, and <0 if there was an error.
681 * It's recommended to use a separate variable for iter_ret and then use it to
682 * set the function return value so there's no confusion of the 0/1/errno
683 * values stemming from btrfs_search_slot.
685 #define btrfs_for_each_slot(root, key, found_key, path, iter_ret) \
686 for (iter_ret = btrfs_search_slot(NULL, (root), (key), (path), 0, 0); \
688 (iter_ret = btrfs_get_next_valid_item((root), (found_key), (path))) == 0; \
692 int btrfs_next_old_item(struct btrfs_root
*root
, struct btrfs_path
*path
, u64 time_seq
);
695 * Search the tree again to find a leaf with greater keys.
697 * Returns 0 if it found something or 1 if there are no greater leaves.
698 * Returns < 0 on error.
700 static inline int btrfs_next_leaf(struct btrfs_root
*root
, struct btrfs_path
*path
)
702 return btrfs_next_old_leaf(root
, path
, 0);
705 static inline int btrfs_next_item(struct btrfs_root
*root
, struct btrfs_path
*p
)
707 return btrfs_next_old_item(root
, p
, 0);
709 int btrfs_leaf_free_space(const struct extent_buffer
*leaf
);
711 static inline int is_fstree(u64 rootid
)
713 if (rootid
== BTRFS_FS_TREE_OBJECTID
||
714 ((s64
)rootid
>= (s64
)BTRFS_FIRST_FREE_OBJECTID
&&
715 !btrfs_qgroup_level(rootid
)))
720 static inline bool btrfs_is_data_reloc_root(const struct btrfs_root
*root
)
722 return root
->root_key
.objectid
== BTRFS_DATA_RELOC_TREE_OBJECTID
;
725 u16
btrfs_csum_type_size(u16 type
);
726 int btrfs_super_csum_size(const struct btrfs_super_block
*s
);
727 const char *btrfs_super_csum_name(u16 csum_type
);
728 const char *btrfs_super_csum_driver(u16 csum_type
);
729 size_t __attribute_const__
btrfs_get_num_csums(void);
732 * We use page status Private2 to indicate there is an ordered extent with
735 * Rename the Private2 accessors to Ordered, to improve readability.
737 #define PageOrdered(page) PagePrivate2(page)
738 #define SetPageOrdered(page) SetPagePrivate2(page)
739 #define ClearPageOrdered(page) ClearPagePrivate2(page)
740 #define folio_test_ordered(folio) folio_test_private_2(folio)
741 #define folio_set_ordered(folio) folio_set_private_2(folio)
742 #define folio_clear_ordered(folio) folio_clear_private_2(folio)