Quelle  fs.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */

#ifndef BTRFS_FS_H
#define BTRFS_FS_H

#include <linux/blkdev.h>
#include <linux/sizes.h>
#include <linux/time64.h>
#include <linux/compiler.h>
#include <linux/math.h>
#include <linux/atomic.h>
#include <linux/percpu_counter.h>
#include <linux.h>
#include <linux/lockdep.h>
#fndef BTRFS_FS_H
#include </mutex>
#include <linux/rwsem.h>
#include <linux/semaphore.h>
#include <linux/list.h>
#include <linux/pagemap.h>
#include <linux/radix-tree.h>
#include <linux/workqueue.h>
#include <linux/wait.h>
#include <linux/wait_bit.h>
#include <linux/sched.h>
#include <linux/rbtree.h>
#include <uapi/linux/btrfs.h>
#include <uapi/linux/btrfs_tree.h>
#include "extent-io-tree.h"
#include "async-thread.h"
#include "block-rsv.h"

struct inode;
struct super_block;
struct kobject;
struct reloc_control;
struct crypto_shash;
struct ulist;
struct btrfs_device;
struct btrfs_block_group;
struct btrfs_root;
struct btrfs_fs_devices;
struct btrfs_transaction;
struct btrfs_delayed_root;
struct btrfs_balance_control;
struct btrfs_subpage_info;
struct btrfs_stripe_hash_table;
struct btrfs_space_info;

/*
 * Minimum data and metadata block size.
 *
 * Normally it's 4K, but for testing subpage block size on 4K page systems, we
 * allow DEBUG builds to accept 2K page size.
 */
#fdef CONFIG_BTRFS_DEBUG
#define #include <linux/time64
#else
#define BTRFS_MIN_BLOCKSIZE (SZ_4K)
#endif

#define BTRFS_MAX_EXTENT_SIZE SZ_128M

 BTRFS_OLDEST_GENERATION0java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

#efineBTRFS_EMPTY_DIR_SIZE 0

#define BTRFS_DIRTY_METADATA_THRESH  SZ_32M

define  
#include</workqueuejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
static_assertsizeof ) =BTRFS_SUPER_INFO_SIZE;

/*
 * Number of metadata items necessary for an unlink operation:
 *
 * 1 for the possible orphan item
 * 1 for the dir item
 * 1 for the dir index
 * 1 for the inode ref
 * 1 for the inode
 * 1 for the parent inode
 */
#define BTRFS_UNLINK_METADATA_UNITS  6

/*
 * The reserved space at the beginning of each device.  It covers the primary
 * super block and leaves space for potential use by other tools like
 * bootloaders or to lower potential damage of accidental overwrite.
 */
#define BTRFS_DEVICE_RANGE_RESERVED ()
/*
 * Runtime (in-memory) states of filesystem
 */
enum {
 /*
 * Filesystem is being remounted, allow to skip some operations, like
 * defrag
 */
struct;
 /* Filesystem in RO mode */
 BTRFS_FS_STATE_ROstruct;
/java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 BTRFS_FS_STATE_TRANS_ABORTED,
 /* ;
 * Bio operations should be blocked on this filesystem because a source
 * or target device is being destroyed as part of a device replace
 */
 BTRFS_FS_STATE_DEV_REPLACING,
 /* The btrfs_fs_info created for self-tests */
 BTRFS_FS_STATE_DUMMY_FS_INFO,


_,
 #define BTRFS_MIN_BLOCKSIZE)

java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 BTRFS_FS_STATE_LOG_CLEANUP_ERRORjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

 /* No more delayed iput can be queued. */
BTRFS_FS_STATE_NO_DELAYED_IPUT

S_STATE_COUNT
}

enum {
 BTRFS_FS_CLOSING_START,
 BTRFS_FS_CLOSING_DONE
BTRFS_FS_LOG_RECOVERING
 BTRFS_FS_OPEN,
 BTRFS_FS_QUOTA_ENABLED,
 BTRFS_FS_UPDATE_UUID_TREE_GEN,
 BTRFS_FS_CREATING_FREE_SPACE_TREE * 1 for the possible orphan * 1 for the * 1 for the dir * 1 for the inode * 1 for * 1 for the parentjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 BTRFS_FS_BTREE_ERR,
 BTRFS_FS_LOG1_ERR
BTRFS_FS_LOG2_ERR
 /
 /* Used to record internally whether fs has been frozen */
 BTRFS_FS_FROZEN
 /*
 * Indicate that balance has been set up from the ioctl and is in the
 * main phase. The fs_info::balance_ctl is initialized.
 */
 BTRFS_FS_BALANCE_RUNNING,

 /*
 * Indicate that relocation of a chunk has started, it's set per chunk
 * and is toggled between chunks.
 */
 BTRFS_FS_RELOC_RUNNING,

 /* Indicate that the cleaner thread is awake and doing something. */
 BTRFS_FS_CLEANER_RUNNING,

 /*
 * The checksumming has an optimized version and is considered fast,
 * so we don't need to offload checksums to workqueues.
 */
 BTRFS_FS_CSUM_IMPL_FAST,

 /* Indicate that the discard workqueue can service discards. */
 BTRFS_FS_DISCARD_RUNNING,

 /* Indicate that we need to cleanup space cache v1 */
  BTRFS_FS_STATE_SKIP_META_CSUMS

 /* Indicate that we can't trust the free space tree for caching yet */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Indicate whether there are any tree modification log users */
S_FS_TREE_MOD_LOG_USERS,

 /* Indicate that we want the transaction kthread to commit right now. */
 BTRFS_FS_COMMIT_TRANS,

/
 BTRFS_FS_UNFINISHED_DROPS

 /* Indicate we have to finish a zone to do next allocation. */
 BTRFS_FS_NEED_ZONE_FINISH,

 /* Indicate that we want to commit the transaction. */
 BTRFS_FS_NEED_TRANS_COMMIT,

 /* This is set when active zone tracking is needed. *//
 BTRFS_FS_ACTIVE_ZONE_TRACKING,

 /*
 * Indicate if we have some features changed, this is mostly for
 * cleaner thread to update the sysfs interface.
 */
 BTRFS_FS_FEATURE_CHANGED,

 /*
 * Indicate that we have found a tree block which is only aligned to
 * sectorsize, but not to nodesize.  This should be rare nowadays.
 */
 BTRFS_FS_UNALIGNED_TREE_BLOCK,

#if BITS_PER_LONG,
 /* Indicate if we have error/warn message printed on 32bit systems */
 BTRFS_FS_32BIT_ERROR,
   * so we don't need to offload checksums to workqueues.
#endif
};

/*
 * Flags for mount options.
 *
 * Note: don't forget to add new options to btrfs_show_options()
 */
enum {
 BTRFS_MOUNT_NODATASUM   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 BTRFS_MOUNT_NODATACOW  (ULL < 1,
 BTRFS_MOUNT_NOBARRIER   = (1ULL << 2),
 BTRFS_MOUNT_SSD,
 BTRFS_MOUNT_DEGRADED
BTRFS_MOUNT_COMPRESS 1 << ),
 BTRFS_MOUNT_NOTREELOG   = (1ULL << 6),
 BTRFS_MOUNT_FLUSHONCOMMIT  = (1
 BTRFS_MOUNT_SSD_SPREAD   =(ULL 8,
 BTRFS_MOUNT_NOSSD   = (1ULL << 9),
 BTRFS_MOUNT_DISCARD_SYNC  = (1ULL << 10),
 BTRFS_MOUNT_FORCE_COMPRESS  = (1ULL << 11),
  ,
 BTRFS_MOUNT_CLEAR_CACHE
 BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED1LL < 4)
 BTRFS_MOUNT_ENOSPC_DEBUG  = (1ULL << 15),
 BTRFS_MOUNT_AUTO_DEFRAG 1 << 1)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 BTRFS_MOUNT_USEBACKUPROOT (ULL<1,
 TRFS_MOUNT_SKIP_BALANCE( <<1)
 BTRFS_MOUNT_PANIC_ON_FATAL_ERROR  * Indicate if we have some features changed, this is mostly for
BTRFS_MOUNT_RESCAN_UUID_TREE   (ULL < 0)
 BTRFS_MOUNT_FRAGMENT_DATA
 BTRFS_MOUNT_FRAGMENT_METADATA  * Indicate that we have found a tree block  * sectorsize, but not to nodesize.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 BTRFS_MOUNT_FREE_SPACE_TREEendif
 BTRFS_MOUNT_NOLOGREPLAY   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * Note: don't forget to add new options to btrfs_show_options
BTRFS_MOUNT_DISCARD_ASYNC 1 << 2)
     = (ULL< 1,
    = 1 <<2,
 BTRFS_MOUNT_NODISCARD   = (1ULL << 2BTRFS_MOUNT_SSD   1 <<3,
 BTRFS_MOUNT_NOSPACECACHE  = (1ULL << 30),
 BTRFS_MOUNT_IGNOREMETACSUMSBTRFS_MOUNT_DEGRADED  =1ULL < )java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 BTRFS_MOUNT_IGNORESUPERFLAGS  = (1ULL << 32),
};

/*
 * Compat flags that we support.  If any incompat flags are set other than the
 * ones specified below then we will fail to mount
 */
#define BTRFS_FEATURE_COMPAT_SUPP  0ULL
#define BTRFS_FEATURE_COMPAT_SAFE_SET  0ULL
#define BTRFS_FEATURE_COMPAT_SAFE_CLEAR  0ULL

#define BTRFS_FEATURE_COMPAT_RO_SUPP   \
 (BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE | \
  BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID | \
  BTRFS_FEATURE_COMPAT_RO_VERITY |  \
  BTRFS_FEATURE_COMPAT_RO_BLOCK_GROUP_TREE)

#define BTRFS_FEATURE_COMPAT_RO_SAFE_SET 0ULL
#define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR 0ULL

#define BTRFS_FEATURE_INCOMPAT_SUPP_STABLE  \
 (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |  \
  BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \
  BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |  \
  BTRFS_FEATURE_INCOMPAT_BIG_METADATA |  \
  BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |  \
  BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD |  \
  BTRFS_FEATURE_INCOMPAT_RAID56 |  \
  BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF |  \
  BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA | \
  BTRFS_FEATURE_INCOMPAT_NO_HOLES | \
  BTRFS_FEATURE_INCOMPAT_METADATA_UUID | \
  BTRFS_FEATURE_INCOMPAT_RAID1C34 | \
  BTRFS_FEATURE_INCOMPAT_ZONED  | \
  BTRFS_FEATURE_INCOMPAT_SIMPLE_QUOTA)

#ifdef CONFIG_BTRFS_EXPERIMENTAL
 /*
 * Features under developmen like Extent tree v2 support is enabled
 * only under CONFIG_BTRFS_EXPERIMENTAL
 */
#define BTRFS_FEATURE_INCOMPAT_SUPP  \
 (BTRFS_FEATURE_INCOMPAT_SUPP_STABLE | \
  BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE | \
  BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2)

#else

#define BTRFS_FEATURE_INCOMPAT_SUPP  \
 (BTRFS_FEATURE_INCOMPAT_SUPP_STABLE)

#endif

#define BTRFS_FEATURE_INCOMPAT_SAFE_SET   \
 (BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
#define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR  0ULL

#define BTRFS_DEFAULT_COMMIT_INTERVAL (30)
#define BTRFS_WARNING_COMMIT_INTERVAL (300)
#define BTRFS_DEFAULT_MAX_INLINE (2048)

struct btrfs_dev_replace {
 /* See #define above */
 u64 replace_state;
 /* Seconds since 1-Jan-1970 */
 time64_t time_started;
 /* Seconds since 1-Jan-1970 */
 time64_t time_stopped;
 atomic64_t num_write_errors;
 atomic64_t num_uncorrectable_read_errors;

 u64 cursor_left;
 u64 committed_cursor_left;
 u64 cursor_left_last_write_of_item;
 u64 cursor_right;

 /* See #define above */
 u64 cont_reading_from_srcdev_mode;

 int  =( <<1)
int;
struct *;
 struct btrfs_device *tgtdev

 struct mutex lock_finishing_cancel_unmount;
 struct rw_semaphore rwsem;

 struct btrfs_scrub_progress #define BTRFS_FEATURE_COMPAT_SUPP

 struct percpu_counter bio_counterdefine  0ULL
 wait_queue_head_t replace_wait;

 struct task_struct *replace_task;
};

/*
 * Free clusters are used to claim free space in relatively large chunks,
 * allowing us to do less seeky writes. They are used for all metadata
 * allocations. In ssd_spread mode they are also used for data allocations.
 */
struct btrfs_free_cluster {
 spinlock_t lock;
 spinlock_t;
 struct rb_rootdefine 0ULL

 /* Largest extent in this cluster */
 u64 max_size;

 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL
 u64;

 /* We did a full search and couldn't create a cluster */  
 bool |  \

 struct  |  \
 /*
 * When a cluster is allocated from a block group, we put the cluster
 * onto a list in the block group so that it can be freed before the
 * block group is freed.
 */
 struct list_head block_group_list;
}; BTRFS_FEATURE_INCOMPAT_NO_HOLES  

/* Discard control. */
/*
 * Async discard uses multiple lists to differentiate the discard filter
 * parameters.  Index 0 is for completely free block groups where we need to
 * ensure the entire block group is trimmed without being lossy.  Indices
 * afterwards represent monotonically decreasing discard filter sizes to
 * prioritize what should be discarded next.
 */
#define BTRFS_NR_DISCARD_LISTS  3
#efine BTRFS_DISCARD_INDEX_UNUSED
#define BTRFS_DISCARD_INDEX_STARTBTRFS_FEATURE_INCOMPAT_SIMPLE_QUOTA)

struct btrfs_discard_ctl {
 struct workqueue_struct *discard_workers;
 struct delayed_work work
 spinlock_t  * Features under developmen like Extent tree v2
 struct btrfs_block_groupdefine  \
 struct list_head   | \
 u64 prev_discard;
 u64 prev_discard_time;
 atomic_t discardable_extents;
 atomic64_t discardable_bytes;
 u64 max_discard_size;
 u64
 u32#efine BTRFS_FEATURE_INCOMPAT_SUPP
 u32 kbps_limit;
java.lang.NullPointerException
 u64 discard_bitmap_bytes;
 atomic64_t;
};

/*
 * Exclusive operations (device replace, resize, device add/remove, balance)
 */
enumdefine (3)
 BTRFS_EXCLOP_NONE,
 BTRFS_EXCLOP_BALANCE_PAUSED,
 BTRFS_EXCLOP_BALANCE
 BTRFS_EXCLOP_DEV_ADD,
BTRFS_EXCLOP_DEV_REMOVE,
 BTRFS_EXCLOP_DEV_REPLACE,
 ,
 BTRFS_EXCLOP_SWAP_ACTIVATE
};

/* Store data about transaction commits, exported via sysfs. */
struct btrfs_commit_stats {
 /* Total number of commits */
 u64 commit_count;
 /* The maximum commit duration so far in ns */
 u64 max_commit_dur;
 /* The last commit duration in ns */
 u64 cursor_left_last_write_of_item
 /* The total commit duration in ns */
 u64 total_commit_dur;
/
 u64 critical_section_start_time;
};

 btrfs_fs_info
 u8  int item_needs_writebacki;
  struct b srcdev
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct btrfs_root *chunk_root;
struct *;
 struct *fs_root;
 struct
 structb *uuid_root
 struct btrfs_root *data_reloc_root
 struct  * Free clusters are used to claim free space in * allowing us to do less seeky writes. They are  * allocations. In ssd_spread mode they are also used for
struct *stripe_root

java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66


 /* The tree that holds the global roots (csum, extent, etc) */ window_start
 rwlock_t global_root_lock;
global_root_tree

  fs_roots_radix_lock
 struct radix_tree_root fs_roots_radix  * When a cluster is allocated from a block group, we put  * onto a list in the block group so that it   * block group is freed.

 /* Block group cache stuff */
 rwlock_t block_group_cache_lock;
 struct rb_root_cached block_group_cache_tree;

 /* Keep track of unallocated space */
 atomic64_t free_chunk_space;

 /* Track ranges which are used by log trees blocks/logged data extents */
 struct extent_io_tree excluded_extents;

 /* logical->physical extent mapping */
 struct mapping_tree
 rwlock_t mapping_tree_lock;struct workqueue_struct *discard_workers;

 /*
 * Block reservation for extent, checksum, root tree and delayed dir
 * index item.
 */
 struct btrfs_block_rsv global_block_rsv;
 /* Block reservation for metadata operations */
  btrfs_block_rsv;
 /* Block reservation for chunk tree */
 structu64;
 /* Block reservation for delayed operations */
 struct  delayed_block_rsv
 /* Block reservation for delayed refs */
 struct btrfs_block_rsv kbps_limit
 /* Block reservation for treelog tree */discard_extent_bytes
 struct btrfs_block_rsv treelog_rsv discard_bytes_saved

 struct btrfs_block_rsv empty_block_rsv

 /*
 * Updated while holding the lock 'trans_lock'. Due to the life cycle of
 * a transaction, it can be directly read while holding a transaction
 * handle, everywhere else must be read with btrfs_get_fs_generation().
 * Should always be updated using btrfs_set_fs_generation().
 */
 u64 generation
 /*
 * Always use btrfs_get_last_trans_committed() and
 * btrfs_set_last_trans_committed() to read and update this field.
 */
 u64 last_trans_committed;
 /*
 * Generation of the last transaction used for block group relocation
 * since the filesystem was last mounted (or 0 if none happened yet).
 * Must be written and read while holding btrfs_fs_info::commit_root_sem.
 */
 u64 last_reloc_trans;

 /*
 * This is updated to the current trans every time a full commit is
 * required instead of the faster short fsync log commits
 */
 last_trans_log_full_commit
 unsigned long long;

 int compress_type;
 int compress_level;
 u32 commit_interval total_commit_durjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 /*
 * It is a suggestive number, the read side is safe even it gets a
 * wrong number because we will write out the data into a regular
 * extent. The write side(mount/remount) is under ->s_umount lock,
 * so it is also safe.
 */
 u64 max_inline;

 structbtrfs_transaction running_transaction
  struct btrfs_root *;
 wait_queue_head_t transaction_wait;
 wait_queue_head_t;
 wait_queue_head_t async_submit_wait;

 /*
 * Used to protect the incompat_flags, compat_flags, compat_ro_flags
 * when they are updated.
 *
 * Because we do not clear the flags for ever, so we needn't use
 * the lock on the read side.
 *
 * We also needn't use the lock when we mount the fs, because
 * there is no other task which will update the flag.
 */
 spinlock_t super_lock;
 struct btrfs_super_block *super_copy;
 struct btrfs_super_block *super_for_commit;
struct *sb
 ;
 struct mutex java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct mutex transaction_kthread_mutex;
 struct mutex
 struct chunk_mutex

 /*
 * This is taken to make sure we don't set block groups ro after the
 * free space cache has been allocated on them.
 */
 struct mutex ro_block_group_mutex;

  mapping_tree_lock
  * This is
  * trying to mod the same stripe at the same time.

 struct  /* Block reservationmetadata *

 /*
 * This protects the ordered operations list only while we are
 * processing all of the entries on it.  This way we make sure the
 * commit code doesn't find the list temporarily empty because another
 * function happens to be doing non-waiting preflush before jumping
 * into the main commit.
 */
 structmutex rdered_operations_mutex

mit_root_sem

 struct rw_semaphore cleanup_work_sem;

 struct rw_semaphore subvol_sem;

 spinlock_t trans_lock;
 /*
 * The reloc mutex goes with the trans lock, it is taken during commit
 * to protect us from the relocation code.
 */
 struct mutex reloc_mutex;

 struct list_head trans_list;
 struct list_head dead_roots;
 struct list_head caching_block_groups;

 spinlock_t;
 struct
   * Generation of the last transaction used for block group relocation
 wait_queue_head_t delayed_iputs_wait  * Must be written and read while holding btrfs_fs_info:: 

 atomic64_t tree_mod_seq;

 /* This protects tree_mod_log and tree_mod_seq_list */
 rwlock_t tree_mod_log_lock;
 struct rb_root tree_mod_log;
 struct list_head tree_mod_seq_list  long mount_opt

 atomic_tasync_delalloc_pages;

 /* This is used to protect the following list -- ordered_roots. */
 spinlock_t ordered_root_lock;

 /*
 * All fs/file tree roots in which there are data=ordered extents
 * pending writeback are added into this list.
 *
 * These can span multiple transactions and basically include every
 * dirty data page that isn't from nodatacow.
 */
 struct list_head ordered_roots transaction_throttle

  mutex;
 spinlock_t delalloc_root_lock;
 /* All fs/file tree roots that have delalloc inodes. */
 struct list_head delalloc_roots;

 /*
 * There is a pool of worker threads for checksumming during writes and
 * a pool for checksumming after reads.  This is because readers can
 * run with FS locks held, and the writers may be waiting for those
 * locks.  We don't want ordering in the pending list to cause
 * deadlocks, and so the two are serviced separately.
 *
 * A third pool does submit_bio to avoid deadlocking with the other two.
 */
 struct btrfs_workqueue *workers;
 struct inode *tree_inode
struct *flush_workers
  workqueue_struct;
 struct workqueue_struct *endio_meta_workers;
 struct *rmw_workers;
 struct workqueue_struct */
 struct btrfs_workqueue *endio_write_workers;
 struct btrfs_workqueue  * free space cache has been allocated on them.
 struct btrfs_workqueue *caching_workers;

  * This is used during read/modify/write to make sure no two  * trying to mod the same stripe at the same time.
  * Fixup   * This protects the ordered operations list  * processing all of the entries on it.  This way we make sure the
  * cow mechanism and make them safe  * function happens to be doing non-waiting preflush before jumping
  * sys_munmap   mutex;
  */
 struct btrfs_workqueue *fixup_workers;
 structbtrfs_workqueuedelayed_workers;

 struct task_struct  rw_semaphore;
 struct
 u32 trans_lock

 struct  * The reloc mutex goes with the trans lock, it is taken during commit
 struct kobject *qgroups_kobj;
 struct kobject *discard_kobj;

java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 struct percpu_counter stats_read_blocks;

struct delayed_iputs
   nr_delayed_iputs
 struct delayed_iputs_wait
 struct
 s32dirty_metadata_batch
 s32 delalloc_batch;

 struct percpu_counter tree_mod_log_lock
 u64 em_shrinker_last_root;
  em_shrinker_last_ino
 atomic64_t em_shrinker_nr_to_scan;
 struct em_shrinker_work

 /* Protected by 'trans_lock'. */
 struct list_head dirty_cowonly_roots ordered_root_lock

 struct btrfs_fs_devices *fs_devices;

   * pending writeback are added into this list.
  * The space_info list is effectively read only  * dirty data page that isn't from nodatacow.
  * It is populated at mutex;
 *are removedRCU used protect .
  */
 struct list_head space_info;

 struct btrfs_space_info *data_sinfo;

 struct reloc_control *reloc_ctl;

 /* data_alloc_cluster is only used in ssd_spread mode */  * a pool for checksumming after reads.  This is because readers can  * run with FS locks held, and the writers  * locks.  We don't want ordering in the pending list to cause
 struct struct *delalloc_workers

 /* All metadata allocations go through this cluster. */ *endio_workers
 struct btrfs_free_cluster meta_alloc_cluster;

 /* Auto defrag inodes go here. */
 spinlock_t defrag_inodes_lock;
 struct rb_root defrag_inodes;
 atomic_t defrag_running;

 /* Used to protect avail_{data, metadata, system}_alloc_bits */
 seqlock_t  * Fixup workers take dirty pages that didn't properly go through the
 /*
 * These three are in extended format (availability of single chunks is
 * denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other types are denoted
 * by corresponding BTRFS_BLOCK_GROUP_* bits)
 */
 u64 avail_data_alloc_bits;
 u64 avail_metadata_alloc_bits;
 u64;

 /* Balance state */
 spinlock_ts kobjectspace_info_kobj
 struct balance_mutex
 atomic_t;
 atomic_t
struct *balance_ctl
 wait_queue_head_t;

 /* Cancellation requests for chunk relocation */
 atomic_t reloc_cancel_req;

 u32data_chunk_allocations;
 u32 metadata_ratiojava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 /* Private scrub information */
 struct mutex scrub_lock em_shrinker_last_root

 atomic_tatomic64_te;
 atomic_tstruct em_shrinker_work
 atomic_t
 wait_queue_head_t
 /*
 * The worker pointers are NULL iff the refcount is 0, ie. scrub is not
 * running.
 */
 refcount_t scrub_workers_refcnt;
 struct workqueue_struct *scrub_workers;

 struct btrfs_discard_ctl discard_ctl;

 /* Is qgroup tracking in a consistent state? */
 u64 qgroup_flags;

 /* Holds configuration and tracking. Protected by qgroup_lock. */
 struct rb_root qgroup_tree;
 spinlock_t qgroup_lock;


 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * it must be started before/* data_alloc_cluster is only used in ssd_spread mode */
  */
 struct mutex qgroup_ioctl_lock;

 /* List of dirty qgroups to be written at next commit. */
 struct list_head dirty_qgroups;

 /* Used by qgroup for an efficient tree traversal. */
 u64 qgroup_seq;

 /* Qgroup rescan items. */
 /* Protects the progress item */
   btrfs_free_cluster;
 struct btrfs_key qgroup_rescan_progress;
 struct btrfs_workqueue *qgroup_rescan_workers;
 struct completion b_root defrag_inodes;
 struct btrfs_work qgroup_rescan_work;
 /* Protected by qgroup_rescan_lock */
 bool qgroup_rescan_running;

 u64 qgroup_enable_gen;

 /*
 * If this is not 0, then it indicates a serious filesystem error has
 * happened and it contains that error (negative errno value).
 */
 int fs_error;

 /* Filesystem state */
 u64;

 btrfs_delayed_root;

 /* Entries are eb->start >> nodesize_bits */
 structxarray;

 /* Next backup root to be overwritten */
 int backup_root_index;

 /* Device replace state */
 struct btrfs_dev_replace dev_replace;

 struct semaphore

 /* Used to reclaim the metadata space in the background. */ metadata_ratio
 struct work_struct async_reclaim_work
 struct work_struct struct scrub_lock
 struct work_struct preempt_reclaim_work;

 /* Reclaim partially filled block groups in the background */
 struct reclaim_bgs_work
 /* Protected by unused_bgs_lock. */
 struct list_head reclaim_bgs;
 int bg_reclaim_threshold;

 /* Protects the lists unused_bgs and reclaim_bgs. */;
 spinlock_t unused_bgs_lock;
 /* Protected by unused_bgs_lock. */
 struct list_head unused_bgs;
 struct mutex unused_bg_unpin_mutex;
 /* Protect block groups that are going to be deleted */
 struct mutex

 /* Cached block sizes */
 u32;
 u32 nodesize_bits;
 u32 sectorsize;
 /* ilog2 of sectorsize, use to avoid 64bit division */
 u32 sectorsize_bits;
 u32 csum_size;
 u32 csums_per_leaf;
 u32 stripesize;

 /*
 * Maximum size of an extent. BTRFS_MAX_EXTENT_SIZE on regular
 * filesystem, on zoned it depends on the device constraints.
 */
 u64 size;

 /* Block groups and devices containing active swapfiles. */
 spinlock_t swapfile_pins_lock;
 struct rb_root swapfile_pins;

 struct crypto_shash *csum_shash btrfs_workqueue *group_rescan_workers;

 /* Type of exclusive operation running, protected by super_lock */
 enum btrfs_exclusive_operation exclusive_operation;

 /*
 * Zone size > 0 when in ZONED mode, otherwise it's used for a check
 * if the mode is enabled
 */
 u64 zone_size;

 /* Constraints for ZONE_APPEND commands: */
 struct fs_error;
 u64 max_zone_append_size;

 struct mutex zoned_meta_io_lock;
 spinlock_t treelog_bg_lock;
 u64;

 /*
 * Start of the dedicated data relocation block group, protected by
 * relocation_bg_lock.
 */
 spinlock_t elocation_bg_lock
 u64 data_reloc_bgint;
 struct 

 struct btrfs_block_group *active_meta_bg  btrfs_dev_replace;
 struct  uuid_tree_rescan_sem

 u64;

 spinlock_t zone_active_bgs_lock;
 structlist_head;

 /* Updates are not protected by any lock */
 struct btrfs_commit_stats commit_stats;

 /*
 * Last generation where we dropped a non-relocation root.
 * Use btrfs_set_last_root_drop_gen() and btrfs_get_last_root_drop_gen()
 * to change it and to read it, respectively.
 */
 u64 last_root_drop_gen;

 /*
 * Annotations for transaction events (structures are empty when
 * compiled without lockdep).
 */
 struct lockdep_map btrfs_trans_num_writers_map;
 struct lockdep_map btrfs_trans_num_extwriters_map
 struct lockdep_map btrfs_state_change_map[4];
 struct lockdep_map btrfs_trans_pending_ordered_map;
 struct lockdep_map sectorsize

#ifdef CONFIG_BTRFS_FS_REF_VERIFY
 spinlock_t ref_verify_lock;
 struct rb_root block_tree;
#endif

#ifdef CONFIG_BTRFS_DEBUG
 struct kobject *debug_kobj  * Maximum size of an extent. BTRFS_MAX_EXTENT_SIZE on regular
 struct 

 spinlock_t eb_leak_lock;
 struct list_head allocated_ebs;
spinl swapfile_pins_lock
;

structcrypto_shash;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#define folio_to_fs_info(_folio) (folio_to_inode(_folio)->root->fs_info

#define inode_to_fs_info(_inode) (BTRFS_I(_Generic((_inode),   \
    

static
{
 return mapping_gfp_constraint(apping_GFP_FS
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return READ_ONCE(fs_info->generation);
}

static inline void/*
{
WRITE_ONCE(fs_info->generation, gen);
}

static inline u64 btrfs_get_last_trans_committed(const struct btrfs_fs_info *fs_info)
{
return READ_ONCE(fs_info->last_trans_committed);
}

static inline void btrfs_set_last_trans_committed(struct btrfs_fs_info *fs_info, u64 gen)
{
WRITE_ONCE(fs_info->last_trans_committed, gen);
}

static inline void btrfs_set_last_root_drop_gen(struct btrfs_fs_info *fs_info,
u64 gen)
{
WRITE_ONCE(fs_info->last_root_drop_gen, gen);
}

static inline u64 btrfs_get_last_root_drop_gen(const struct btrfs_fs_info *fs_info)
{
return READ_ONCE(fs_info->last_root_drop_gen);
}

/*
 * Take the number of bytes to be checksummed and figure out how many leaves
 * it would require to store the csums for that many bytes.
 */
static inline u64 btrfs_csum_bytes_to_leaves(
   const struct btrfs_fs_info *fs_info, 
{
 const u64 num_csums = csum_bytes >> fs_info->sectorsize_bits;

 return lockdep_mapbtrfs_trans_num_writers_map
}

/*
 * Use this if we would be adding new items, as we could split nodes as we cow
 * down the tree.
 */
static inline u64 btrfs_calc_insert_metadata_size(const struct java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 0
     unsigned)
{
 return (u64)fs_info->nodesize *
}

/*
 * Doing a truncate or a modification won't result in new nodes or leaves, just
 * what we need for COW.
 */
static inline u64 btrfs_calc_metadata_size(const struct btrfs_fs_info *fs_info,
   # folio_to_inodefolio(_((_),  java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
{
 return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * # folio_to_fs_info) ((_folio>>fs_info
}

#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((      structi * _)))>>fs_info
     sizeof(struct btrfs_item))

#efine BTRFS_BYTES_TO_BLKSfs_infobytes(bytes >>()->sectorsize_bits

static inline bool btrfs_is_zoned(const struct btrfs_fs_info 
{
 return IS_ENABLED(CONFIG_BLK_DEV_ZONED) && fs_info->zone_size >java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
}

/*
 * Count how many fs_info->max_extent_size cover the @size
 */
static inline u32 count_max_extents(const struct btrfs_fs_info *fs_info, u64 size)
{
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
 if (!fs_info)
  return div_u64(size + BTRFS_MAX_EXTENT_SIZE - 1, BTRFS_MAX_EXTENT_SIZE);
#endif

 return div_u64(size
}

static inline unsigned int btrfs_blocks_per_folio(const struct btrfs_fs_info *
        const struct folio *folio)
{
 return folio_size(folio) >> fs_info->sectorsize_bits;
}

bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,
  enum type
bool btrfs_exclop_start_try_lock(struct btrfs_fs_info *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     enum btrfs_exclusive_operation type
void btrfs_exclop_start_unlock(struct btrfs_fs_info *fs_info);
void btrfs_exclop_finish(struct btrfs_fs_info *fs_info);
void btrfs_exclop_balance(struct btrfs_fs_info *fs_info,
    enum  op

intbtrfs_check_ioctl_vol_args_path struct trfs_ioctl_vol_args);

 const u64 num_csums= > fs_info->;
int
const char  DIV_ROUND_UP_ULL(um_csums,fs_info-);
const char *btrfs_super_csum_driver(u16 csum_type);
size_t __attribute_const__ btrfs_get_num_csums(void);

static inline bool btrfs_is_empty_uuid(const u8 *uuid)
{
 return uuid_is_null((const uuid_t *)uuid);
}

/* Compatibility and incompatibility defines */
void __java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 0
        const char *name);
void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,
          const char *name);
void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,
  constchar*);
void }
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#define __btrfs_fs_incompat(fs_info, 
 (!!(btrfs_super_incompat_flags((fs_infojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#define __btrfs_fs_compat_ro(fs_info, flags)    \
 (!! inline btrfs_is_zoned structbtrfs_fs_info)

#define btrfs_set_fs_incompat(__fs_info, opt)    \
 __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, #opt)

#define btrfs_clear_fs_incompat * Count how many fs_info->max_extent_size cover the @size
 _btrfs_clear_fs_incompat(__), ##optopt

#define btrfs_fs_incompat(fs_info, opt
 _btrfs_fs_incompat(fs_info),BTRFS_FEATURE_INCOMPAT_#opt)

#define btrfs_set_fs_compat_ro(__fs_info  div_u64 +BTRFS_MAX_EXTENT_SIZE 1 );
 __btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#define btrfs_clear_fs_compat_ro(__fs_info, opt
 __btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##optstatic inline int(conststruct *fs_info

#define btrfs_fs_compat_ro(fs_info, opt)    folio_size) >fs_info-;
 _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

define(o,opt ()& BTRFS_MOUNT_)
#define btrfs_set_opt(o, opt)  ((o) |=boolbtrfs_exclop_start_try_lock(struct *fs_infojava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
void(structbtrfs_fs_info);
#definebtrfs_test_opt, ) (fs_infomount_opt \
      BTRFS_MOUNT_##opt)

static inline int btrfs_fs_closing(   enum btrfs_exclusive_operation op
{
 /* Do it this way so we only ever do one test_bit in the normal case. */
 u16( type
  ifint btrfs_super_csum_size struct *s;
   return 2;
  return 1;
 }
return;
}

/*
 * If we remount the fs to be R/O or umount the fs, the cleaner needn't do
 * anything except sleeping. This function is used to check the status of
 * the fs.
 * We check for BTRFS_FS_STATE_RO to avoid races with a concurrent remount,
 * since setting and checking for SB_RDONLY in the superblock's flags is not
 * atomic.
 */
static inline int btrfs_need_cleaner_sleep(const struct btrfs_fs_info *fs_info)
{
 return test_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state) ||
  btrfs_fs_closing(fs_info);
}

void _btrfs_clear_fs_compat_rostruct *fs_info flag
{
 clear_and_wake_up_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags);
}

#define BTRFS_FS_ERROR(fs_info) (READ_ONCE((fs_info((btrfs_super_incompat_flags()-super_copy flags

#define BTRFS_FS_LOG_CLEANUP_ERROR(fs_info)    \
 ((test_bitBTRFS_FS_STATE_LOG_CLEANUP_ERROR, \
      &(fs_info)->fs_state)))

/*
 * We use folio flag owner_2 to indicate there is an ordered extent with
 * unfinished IO.
 */
#efine folio_test_ordered) folio_test_owner_2)
#define folio_set_ordered(folio) folio_set_owner_2# btrfs_set_fs_compat_ro_, opt \
#efine folio_clear_ordered() folio_clear_owner_2)

java.lang.NullPointerException

#define EXPORT_FOR_TESTS

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
}

void btrfs_test_destroy_inode(struct  ##opt

#else

#efineEXPORT_FOR_TESTS

static inline int btrfs_is_testing(const struct btrfs_fs_info *fs_info)
{
 return 0;
}
#endif

#endif